no-unused-vars-eslint.test.ts

// The following tests are adapted from the tests in eslint.
// Original Code: https://github.com/eslint/eslint/blob/0cb81a9b90dd6b92bac383022f886e501bd2cb31/tests/lib/rules/no-unused-vars.js
// License      : https://github.com/eslint/eslint/blob/0cb81a9b90dd6b92bac383022f886e501bd2cb31/LICENSE

'use strict';

import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
import rule, { MessageIds } from '../../../src/rules/no-unused-vars';
import { RuleTester } from '../../RuleTester';

const ruleTester = new RuleTester({
  parser: '@typescript-eslint/parser',
  parserOptions: {
    // espree defaults to `script`, so we need to mirror it
    sourceType: 'script',
  },
});

ruleTester.defineRule('use-every-a', context => {
  /**
   * Mark a variable as used
   */
  function useA(): void {
    context.markVariableAsUsed('a');
  }
  return {
    VariableDeclaration: useA,
    ReturnStatement: useA,
  };
});

/**
 * Returns an expected error for defined-but-not-used variables.
 * @param varName The name of the variable
 * @param [additional] The additional text for the message data
 * @param [type] The node type (defaults to "Identifier")
 * @returns An expected error object
 */
function definedError(
  varName: string,
  additional = '',
  type = AST_NODE_TYPES.Identifier,
): TSESLint.TestCaseError<MessageIds> {
  return {
    messageId: 'unusedVar',
    data: {
      varName,
      action: 'defined',
      additional,
    },
    type,
  };
}

/**
 * Returns an expected error for assigned-but-not-used variables.
 * @param varName The name of the variable
 * @param [additional] The additional text for the message data
 * @param [type] The node type (defaults to "Identifier")
 * @returns An expected error object
 */
function assignedError(
  varName: string,
  additional = '',
  type = AST_NODE_TYPES.Identifier,
): TSESLint.TestCaseError<MessageIds> {
  return {
    messageId: 'unusedVar',
    data: {
      varName,
      action: 'assigned a value',
      additional,
    },
    type,
  };
}

ruleTester.run('no-unused-vars', rule, {
  valid: [
    'var foo = 5;\n\nlabel: while (true) {\n  console.log(foo);\n  break label;\n}',
    'var foo = 5;\n\nwhile (true) {\n  console.log(foo);\n  break;\n}',
    {
      code: `
for (let prop in box) {
  box[prop] = parseInt(box[prop]);
}
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    `
var box = { a: 2 };
for (var prop in box) {
  box[prop] = parseInt(box[prop]);
}
    `,
    `
f({
  set foo(a) {
    return;
  },
});
    `,
    {
      code: `
a;
var a;
      `,
      options: ['all'],
    },
    {
      code: `
var a = 10;
alert(a);
      `,
      options: ['all'],
    },
    {
      code: `
var a = 10;
(function () {
  alert(a);
})();
      `,
      options: ['all'],
    },
    {
      code: `
var a = 10;
(function () {
  setTimeout(function () {
    alert(a);
  }, 0);
})();
      `,
      options: ['all'],
    },
    {
      code: `
var a = 10;
d[a] = 0;
      `,
      options: ['all'],
    },
    {
      code: `
(function () {
  var a = 10;
  return a;
})();
      `,
      options: ['all'],
    },
    {
      code: '(function g() {})();',
      options: ['all'],
    },
    {
      code: `
function f(a) {
  alert(a);
}
f();
      `,
      options: ['all'],
    },
    {
      code: `
var c = 0;
function f(a) {
  var b = a;
  return b;
}
f(c);
      `,
      options: ['all'],
    },
    {
      code: `
function a(x, y) {
  return y;
}
a();
      `,
      options: ['all'],
    },
    {
      code: `
var arr1 = [1, 2];
var arr2 = [3, 4];
for (var i in arr1) {
  arr1[i] = 5;
}
for (var i in arr2) {
  arr2[i] = 10;
}
      `,
      options: ['all'],
    },
    {
      code: 'var a = 10;',
      options: ['local'],
    },
    {
      code: `
var min = 'min';
Math[min];
      `,
      options: ['all'],
    },
    {
      code: `
Foo.bar = function (baz) {
  return baz;
};
      `,
      options: ['all'],
    },
    'myFunc(function foo() {}.bind(this));',
    'myFunc(function foo() {}.toString());',
    `
function foo(first, second) {
  doStuff(function () {
    console.log(second);
  });
}
foo();
    `,
    `
(function () {
  var doSomething = function doSomething() {};
  doSomething();
})();
    `,
    `
try {
} catch (e) {}
    `,
    '/*global a */ a;',
    {
      code: `
var a = 10;
(function () {
  alert(a);
})();
      `,
      options: [{ vars: 'all' }],
    },
    {
      code: `
function g(bar, baz) {
  return baz;
}
g();
      `,
      options: [{ vars: 'all' }],
    },
    {
      code: `
function g(bar, baz) {
  return baz;
}
g();
      `,
      options: [{ vars: 'all', args: 'after-used' }],
    },
    {
      code: `
function g(bar, baz) {
  return bar;
}
g();
      `,
      options: [{ vars: 'all', args: 'none' }],
    },
    {
      code: `
function g(bar, baz) {
  return 2;
}
g();
      `,
      options: [{ vars: 'all', args: 'none' }],
    },
    {
      code: `
function g(bar, baz) {
  return bar + baz;
}
g();
      `,
      options: [{ vars: 'local', args: 'all' }],
    },
    {
      code: `
var g = function (bar, baz) {
  return 2;
};
g();
      `,
      options: [{ vars: 'all', args: 'none' }],
    },
    `
(function z() {
  z();
})();
    `,
    {
      code: ' ',
      globals: { a: true },
    },
    {
      code: `
var who = 'Paul';
module.exports = \`Hello \${who}!\`;
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: 'export var foo = 123;',
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
    },
    {
      code: 'export function foo() {}',
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
    },
    {
      code: `
let toUpper = partial => partial.toUpperCase;
export { toUpper };
      `,
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
    },
    {
      code: 'export class foo {}',
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
    },
    {
      code: `
class Foo {}
var x = new Foo();
x.foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const foo = 'hello!';
function bar(foobar = foo) {
  foobar.replace(/!$/, ' world!');
}
bar();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    `
function Foo() {}
var x = new Foo();
x.foo();
    `,
    `
function foo() {
  var foo = 1;
  return foo;
}
foo();
    `,
    `
function foo(foo) {
  return foo;
}
foo(1);
    `,
    `
function foo() {
  function foo() {
    return 1;
  }
  return foo();
}
foo();
    `,
    {
      code: `
function foo() {
  var foo = 1;
  return foo;
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
function foo(foo) {
  return foo;
}
foo(1);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
function foo() {
  function foo() {
    return 1;
  }
  return foo();
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
const [y = x] = [];
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
const { y = x } = {};
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
const {
  z: [y = x],
} = {};
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = [];
const { z: [y] = x } = {};
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
let y;
[y = x] = [];
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
let y;
({
  z: [y = x],
} = {});
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = [];
let y;
({ z: [y] = x } = {});
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
function foo(y = x) {
  bar(y);
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
function foo({ y = x } = {}) {
  bar(y);
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
function foo(
  y = function (z = x) {
    bar(z);
  },
) {
  y();
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const x = 1;
function foo(
  y = function () {
    bar(x);
  },
) {
  y();
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1;
var [y = x] = [];
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1;
var { y = x } = {};
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1;
var {
  z: [y = x],
} = {};
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = [];
var { z: [y] = x } = {};
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1,
  y;
[y = x] = [];
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1,
  y;
({
  z: [y = x],
} = {});
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = [],
  y;
({ z: [y] = x } = {});
foo(y);
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1;
function foo(y = x) {
  bar(y);
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1;
function foo({ y = x } = {}) {
  bar(y);
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1;
function foo(
  y = function (z = x) {
    bar(z);
  },
) {
  y();
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
var x = 1;
function foo(
  y = function () {
    bar(x);
  },
) {
  y();
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },

    // exported variables should work
    "/*exported toaster*/ var toaster = 'great';",
    `
/*exported toaster, poster*/ var toaster = 1;
poster = 0;
    `,
    {
      code: '/*exported x*/ var { x } = y;',
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: '/*exported x, y*/ var { x, y } = z;',
      parserOptions: { ecmaVersion: 6 },
    },

    // Can mark variables as used via context.markVariableAsUsed()
    '/*eslint use-every-a:1*/ var a;',
    `
/*eslint use-every-a:1*/ !function (a) {
  return 1;
};
    `,
    `
/*eslint use-every-a:1*/ !function () {
  var a;
  return 1;
};
    `,

    // ignore pattern
    {
      code: 'var _a;',
      options: [{ vars: 'all', varsIgnorePattern: '^_' }],
    },
    {
      code: `
var a;
function foo() {
  var _b;
}
foo();
      `,
      options: [{ vars: 'local', varsIgnorePattern: '^_' }],
    },
    {
      code: `
function foo(_a) {}
foo();
      `,
      options: [{ args: 'all', argsIgnorePattern: '^_' }],
    },
    {
      code: `
function foo(a, _b) {
  return a;
}
foo();
      `,
      options: [{ args: 'after-used', argsIgnorePattern: '^_' }],
    },
    {
      code: `
var [firstItemIgnored, secondItem] = items;
console.log(secondItem);
      `,
      options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const [a, _b, c] = items;
console.log(a + c);
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const [[a, _b, c]] = items;
console.log(a + c);
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
const {
  x: [_a, foo],
} = bar;
console.log(foo);
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
function baz([_b, foo]) {
  foo;
}
baz();
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
function baz({ x: [_b, foo] }) {
  foo;
}
baz();
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
function baz([
  {
    x: [_b, foo],
  },
]) {
  foo;
}
baz();
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
let _a, b;
foo.forEach(item => {
  [_a, b] = item;
  doSomething(b);
});
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
// doesn't report _x
let _x, y;
_x = 1;
[_x, y] = foo;
y;
// doesn't report _a
let _a, b;
[_a, b] = foo;
_a = 1;
b;
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 2018 },
    },
    {
      code: `
// doesn't report _x
let _x, y;
_x = 1;
[_x, y] = foo;
y;
// doesn't report _a
let _a, b;
_a = 1;
({ _a, ...b } = foo);
b;
      `,
      options: [
        { destructuredArrayIgnorePattern: '^_', ignoreRestSiblings: true },
      ],
      parserOptions: { ecmaVersion: 2018 },
    },

    // for-in loops (see #2342)
    `
(function (obj) {
  var name;
  for (name in obj) return;
})({});
    `,
    `
(function (obj) {
  var name;
  for (name in obj) {
    return;
  }
})({});
    `,
    `
(function (obj) {
  for (var name in obj) {
    return true;
  }
})({});
    `,
    `
(function (obj) {
  for (var name in obj) return true;
})({});
    `,

    {
      code: `
(function (obj) {
  let name;
  for (name in obj) return;
})({});
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
(function (obj) {
  let name;
  for (name in obj) {
    return;
  }
})({});
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
(function (obj) {
  for (let name in obj) {
    return true;
  }
})({});
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
(function (obj) {
  for (let name in obj) return true;
})({});
      `,
      parserOptions: { ecmaVersion: 6 },
    },

    {
      code: `
(function (obj) {
  for (const name in obj) {
    return true;
  }
})({});
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
(function (obj) {
  for (const name in obj) return true;
})({});
      `,
      parserOptions: { ecmaVersion: 6 },
    },

    // caughtErrors
    {
      code: `
try {
} catch (err) {
  console.error(err);
}
      `,
      options: [{ caughtErrors: 'all' }],
    },
    {
      code: `
try {
} catch (err) {}
      `,
      options: [{ caughtErrors: 'none' }],
    },
    {
      code: `
try {
} catch (ignoreErr) {}
      `,
      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
    },

    // caughtErrors with other combinations
    {
      code: `
try {
} catch (err) {}
      `,
      options: [{ vars: 'all', args: 'all' }],
    },

    // Using object rest for variable omission
    {
      code: `
const data = { type: 'coords', x: 1, y: 2 };
const { type, ...coords } = data;
console.log(coords);
      `,
      options: [{ ignoreRestSiblings: true }],
      parserOptions: { ecmaVersion: 2018 },
    },

    // https://github.com/eslint/eslint/issues/6348
    `
var a = 0,
  b;
b = a = a + 1;
foo(b);
    `,
    `
var a = 0,
  b;
b = a += a + 1;
foo(b);
    `,
    `
var a = 0,
  b;
b = a++;
foo(b);
    `,
    `
function foo(a) {
  var b = (a = a + 1);
  bar(b);
}
foo();
    `,
    `
function foo(a) {
  var b = (a += a + 1);
  bar(b);
}
foo();
    `,
    `
function foo(a) {
  var b = a++;
  bar(b);
}
foo();
    `,

    // https://github.com/eslint/eslint/issues/6576
    [
      'var unregisterFooWatcher;',
      '// ...',
      'unregisterFooWatcher = $scope.$watch( "foo", function() {',
      '    // ...some code..',
      '    unregisterFooWatcher();',
      '});',
    ].join('\n'),
    [
      'var ref;',
      'ref = setInterval(',
      '    function(){',
      '        clearInterval(ref);',
      '    }, 10);',
    ].join('\n'),
    [
      'var _timer;',
      'function f() {',
      '    _timer = setTimeout(function () {}, _timer ? 100 : 0);',
      '}',
      'f();',
    ].join('\n'),
    `
function foo(cb) {
  cb = (function () {
    function something(a) {
      cb(1 + a);
    }
    register(something);
  })();
}
foo();
    `,
    {
      code: `
function* foo(cb) {
  cb = yield function (a) {
    cb(1 + a);
  };
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
function foo(cb) {
  cb = tag\`hello\${function (a) {
    cb(1 + a);
  }}\`;
}
foo();
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    `
function foo(cb) {
  var b;
  cb = b = function (a) {
    cb(1 + a);
  };
  b();
}
foo();
    `,

    // https://github.com/eslint/eslint/issues/6646
    [
      'function someFunction() {',
      '    var a = 0, i;',
      '    for (i = 0; i < 2; i++) {',
      '        a = myFunction(a);',
      '    }',
      '}',
      'someFunction();',
    ].join('\n'),

    // https://github.com/eslint/eslint/issues/7124
    {
      code: `
(function (a, b, { c, d }) {
  d;
});
      `,
      options: [{ argsIgnorePattern: 'c' }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
(function (a, b, { c, d }) {
  c;
});
      `,
      options: [{ argsIgnorePattern: 'd' }],
      parserOptions: { ecmaVersion: 6 },
    },

    // https://github.com/eslint/eslint/issues/7250
    {
      code: `
(function (a, b, c) {
  c;
});
      `,
      options: [{ argsIgnorePattern: 'c' }],
    },
    {
      code: `
(function (a, b, { c, d }) {
  c;
});
      `,
      options: [{ argsIgnorePattern: '[cd]' }],
      parserOptions: { ecmaVersion: 6 },
    },

    // https://github.com/eslint/eslint/issues/7351
    {
      code: `
(class {
  set foo(UNUSED) {}
});
      `,
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: `
class Foo {
  set bar(UNUSED) {}
}
console.log(Foo);
      `,
      parserOptions: { ecmaVersion: 6 },
    },

    // https://github.com/eslint/eslint/issues/8119
    {
      code: '({ a, ...rest }) => rest;',
      options: [{ args: 'all', ignoreRestSiblings: true }],
      parserOptions: { ecmaVersion: 2018 },
    },

    // https://github.com/eslint/eslint/issues/14163
    {
      code: 'let foo, rest;\n({ foo, ...rest } = something);\nconsole.log(rest);',
      options: [{ ignoreRestSiblings: true }],
      parserOptions: { ecmaVersion: 2020 },
    },

    // https://github.com/eslint/eslint/issues/10952
    `
/*eslint use-every-a:1*/ !function (b, a) {
  return 1;
};
    `,

    // https://github.com/eslint/eslint/issues/10982
    `
var a = function () {
  a();
};
a();
    `,
    `
var a = function () {
  return function () {
    a();
  };
};
a();
    `,
    {
      code: `
const a = () => {
  a();
};
a();
      `,
      parserOptions: { ecmaVersion: 2015 },
    },
    {
      code: `
const a = () => () => {
  a();
};
a();
      `,
      parserOptions: { ecmaVersion: 2015 },
    },

    // export * as ns from "source"
    {
      code: "export * as ns from 'source';",
      parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
    },

    // import.meta
    {
      code: 'import.meta;',
      parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
    },
  ],
  invalid: [
    {
      code: `
function foox() {
  return foox();
}
      `,
      errors: [definedError('foox')],
    },
    {
      code: `
(function () {
  function foox() {
    if (true) {
      return foox();
    }
  }
})();
      `,
      errors: [definedError('foox')],
    },
    {
      code: 'var a = 10;',
      errors: [assignedError('a')],
    },
    {
      code: `
function f() {
  var a = 1;
  return function () {
    f((a *= 2));
  };
}
      `,
      errors: [definedError('f')],
    },
    {
      code: `
function f() {
  var a = 1;
  return function () {
    f(++a);
  };
}
      `,
      errors: [definedError('f')],
    },
    {
      code: '/*global a */',
      errors: [definedError('a', '', AST_NODE_TYPES.Program)],
    },
    {
      code: `
function foo(first, second) {
  doStuff(function () {
    console.log(second);
  });
}
      `,
      errors: [definedError('foo')],
    },
    {
      code: 'var a = 10;',
      options: ['all'],
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 10;
a = 20;
      `,
      options: ['all'],
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 10;
(function () {
  var a = 1;
  alert(a);
})();
      `,
      options: ['all'],
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 10,
  b = 0,
  c = null;
alert(a + b);
      `,
      options: ['all'],
      errors: [assignedError('c')],
    },
    {
      code: `
var a = 10,
  b = 0,
  c = null;
setTimeout(function () {
  var b = 2;
  alert(a + b + c);
}, 0);
      `,
      options: ['all'],
      errors: [assignedError('b')],
    },
    {
      code: `
var a = 10,
  b = 0,
  c = null;
setTimeout(function () {
  var b = 2;
  var c = 2;
  alert(a + b + c);
}, 0);
      `,
      options: ['all'],
      errors: [assignedError('b'), assignedError('c')],
    },
    {
      code: `
function f() {
  var a = [];
  return a.map(function () {});
}
      `,
      options: ['all'],
      errors: [definedError('f')],
    },
    {
      code: `
function f() {
  var a = [];
  return a.map(function g() {});
}
      `,
      options: ['all'],
      errors: [definedError('f')],
    },
    {
      code: `
function foo() {
  function foo(x) {
    return x;
  }
  return function () {
    return foo;
  };
}
      `,
      errors: [
        {
          messageId: 'unusedVar',
          data: { varName: 'foo', action: 'defined', additional: '' },
          line: 2,
          type: AST_NODE_TYPES.Identifier,
        },
      ],
    },
    {
      code: `
function f() {
  var x;
  function a() {
    x = 42;
  }
  function b() {
    alert(x);
  }
}
      `,
      options: ['all'],
      errors: [definedError('f'), definedError('a'), definedError('b')],
    },
    {
      code: `
function f(a) {}
f();
      `,
      options: ['all'],
      errors: [definedError('a')],
    },
    {
      code: `
function a(x, y, z) {
  return y;
}
a();
      `,
      options: ['all'],
      errors: [definedError('z')],
    },
    {
      code: 'var min = Math.min;',
      options: ['all'],
      errors: [assignedError('min')],
    },
    {
      code: 'var min = { min: 1 };',
      options: ['all'],
      errors: [assignedError('min')],
    },
    {
      code: `
Foo.bar = function (baz) {
  return 1;
};
      `,
      options: ['all'],
      errors: [definedError('baz')],
    },
    {
      code: 'var min = { min: 1 };',
      options: [{ vars: 'all' }],
      errors: [assignedError('min')],
    },
    {
      code: `
function gg(baz, bar) {
  return baz;
}
gg();
      `,
      options: [{ vars: 'all' }],
      errors: [definedError('bar')],
    },
    {
      code: `
(function (foo, baz, bar) {
  return baz;
})();
      `,
      options: [{ vars: 'all', args: 'after-used' }],
      errors: [definedError('bar')],
    },
    {
      code: `
(function (foo, baz, bar) {
  return baz;
})();
      `,
      options: [{ vars: 'all', args: 'all' }],
      errors: [definedError('foo'), definedError('bar')],
    },
    {
      code: `
(function z(foo) {
  var bar = 33;
})();
      `,
      options: [{ vars: 'all', args: 'all' }],
      errors: [definedError('foo'), assignedError('bar')],
    },
    {
      code: `
(function z(foo) {
  z();
})();
      `,
      options: [{}],
      errors: [definedError('foo')],
    },
    {
      code: `
function f() {
  var a = 1;
  return function () {
    f((a = 2));
  };
}
      `,
      options: [{}],
      errors: [definedError('f'), assignedError('a')],
    },
    {
      code: "import x from 'y';",
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('x')],
    },
    {
      code: `
export function fn2({ x, y }) {
  console.log(x);
}
      `,
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('y')],
    },
    {
      code: `
export function fn2(x, y) {
  console.log(x);
}
      `,
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('y')],
    },

    // exported
    {
      code: `
/*exported max*/ var max = 1,
  min = { min: 1 };
      `,
      errors: [assignedError('min')],
    },
    {
      code: '/*exported x*/ var { x, y } = z;',
      parserOptions: { ecmaVersion: 6 },
      errors: [assignedError('y')],
    },

    // ignore pattern
    {
      code: `
var _a;
var b;
      `,
      options: [{ vars: 'all', varsIgnorePattern: '^_' }],
      errors: [
        {
          line: 3,
          column: 5,
          messageId: 'unusedVar',
          data: {
            varName: 'b',
            action: 'defined',
            additional: '. Allowed unused vars must match /^_/u',
          },
        },
      ],
    },
    {
      code: `
var a;
function foo() {
  var _b;
  var c_;
}
foo();
      `,
      options: [{ vars: 'local', varsIgnorePattern: '^_' }],
      errors: [
        {
          line: 5,
          column: 7,
          messageId: 'unusedVar',
          data: {
            varName: 'c_',
            action: 'defined',
            additional: '. Allowed unused vars must match /^_/u',
          },
        },
      ],
    },
    {
      code: `
function foo(a, _b) {}
foo();
      `,
      options: [{ args: 'all', argsIgnorePattern: '^_' }],
      errors: [
        {
          line: 2,
          column: 14,
          messageId: 'unusedVar',
          data: {
            varName: 'a',
            action: 'defined',
            additional: '. Allowed unused args must match /^_/u',
          },
        },
      ],
    },
    {
      code: `
function foo(a, _b, c) {
  return a;
}
foo();
      `,
      options: [{ args: 'after-used', argsIgnorePattern: '^_' }],
      errors: [
        {
          line: 2,
          column: 21,
          messageId: 'unusedVar',
          data: {
            varName: 'c',
            action: 'defined',
            additional: '. Allowed unused args must match /^_/u',
          },
        },
      ],
    },
    {
      code: `
function foo(_a) {}
foo();
      `,
      options: [{ args: 'all', argsIgnorePattern: '[iI]gnored' }],
      errors: [
        {
          line: 2,
          column: 14,
          messageId: 'unusedVar',
          data: {
            varName: '_a',
            action: 'defined',
            additional: '. Allowed unused args must match /[iI]gnored/u',
          },
        },
      ],
    },
    {
      code: 'var [firstItemIgnored, secondItem] = items;',
      options: [{ vars: 'all', varsIgnorePattern: '[iI]gnored' }],
      parserOptions: { ecmaVersion: 6 },
      errors: [
        {
          line: 1,
          column: 24,
          messageId: 'unusedVar',
          data: {
            varName: 'secondItem',
            action: 'assigned a value',
            additional: '. Allowed unused vars must match /[iI]gnored/u',
          },
        },
      ],
    },
    // https://github.com/eslint/eslint/issues/15611
    {
      code: `
const array = ['a', 'b', 'c'];
const [a, _b, c] = array;
const newArray = [a, c];
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        // should report only `newArray`
        { ...assignedError('newArray'), line: 4, column: 7 },
      ],
    },
    {
      code: `
const array = ['a', 'b', 'c', 'd', 'e'];
const [a, _b, c] = array;
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        {
          ...assignedError(
            'a',
            '. Allowed unused elements of array destructuring patterns must match /^_/u',
          ),
          line: 3,
          column: 8,
        },
        {
          ...assignedError(
            'c',
            '. Allowed unused elements of array destructuring patterns must match /^_/u',
          ),
          line: 3,
          column: 15,
        },
      ],
    },
    {
      code: `
const array = ['a', 'b', 'c'];
const [a, _b, c] = array;
const fooArray = ['foo'];
const barArray = ['bar'];
const ignoreArray = ['ignore'];
      `,
      options: [
        { destructuredArrayIgnorePattern: '^_', varsIgnorePattern: 'ignore' },
      ],
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        {
          ...assignedError(
            'a',
            '. Allowed unused elements of array destructuring patterns must match /^_/u',
          ),
          line: 3,
          column: 8,
        },
        {
          ...assignedError(
            'c',
            '. Allowed unused elements of array destructuring patterns must match /^_/u',
          ),
          line: 3,
          column: 15,
        },
        {
          ...assignedError(
            'fooArray',
            '. Allowed unused vars must match /ignore/u',
          ),
          line: 4,
          column: 7,
        },
        {
          ...assignedError(
            'barArray',
            '. Allowed unused vars must match /ignore/u',
          ),
          line: 5,
          column: 7,
        },
      ],
    },
    {
      code: `
const array = [obj];
const [{ _a, foo }] = array;
console.log(foo);
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        {
          ...assignedError('_a'),
          line: 3,
          column: 10,
        },
      ],
    },
    {
      code: `
function foo([{ _a, bar }]) {
  bar;
}
foo();
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        {
          ...definedError('_a'),
          line: 2,
          column: 17,
        },
      ],
    },
    {
      code: `
let _a, b;
foo.forEach(item => {
  [a, b] = item;
});
      `,
      options: [{ destructuredArrayIgnorePattern: '^_' }],
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        {
          ...definedError('_a'),
          line: 2,
          column: 5,
        },
        {
          ...assignedError('b'),
          line: 2,
          column: 9,
        },
      ],
    },

    // for-in loops (see #2342)
    {
      code: `
(function (obj) {
  var name;
  for (name in obj) {
    i();
    return;
  }
})({});
      `,
      errors: [
        {
          line: 4,
          column: 8,
          messageId: 'unusedVar',
          data: {
            varName: 'name',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },
    {
      code: `
(function (obj) {
  var name;
  for (name in obj) {
  }
})({});
      `,
      errors: [
        {
          line: 4,
          column: 8,
          messageId: 'unusedVar',
          data: {
            varName: 'name',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },
    {
      code: `
(function (obj) {
  for (var name in obj) {
  }
})({});
      `,
      errors: [
        {
          line: 3,
          column: 12,
          messageId: 'unusedVar',
          data: {
            varName: 'name',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },

    // https://github.com/eslint/eslint/issues/3617
    {
      code: `
/* global foobar, foo, bar */
foobar;
      `,
      errors: [
        {
          line: 2,
          endLine: 2,
          column: 19,
          endColumn: 22,
          messageId: 'unusedVar',
          data: {
            varName: 'foo',
            action: 'defined',
            additional: '',
          },
        },
        {
          line: 2,
          endLine: 2,
          column: 24,
          endColumn: 27,
          messageId: 'unusedVar',
          data: {
            varName: 'bar',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },
    {
      code: `
/* global foobar,
   foo,
   bar
 */
foobar;
      `,
      errors: [
        {
          line: 3,
          column: 4,
          endLine: 3,
          endColumn: 7,
          messageId: 'unusedVar',
          data: {
            varName: 'foo',
            action: 'defined',
            additional: '',
          },
        },
        {
          line: 4,
          column: 4,
          endLine: 4,
          endColumn: 7,
          messageId: 'unusedVar',
          data: {
            varName: 'bar',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },

    // Rest property sibling without ignoreRestSiblings
    {
      code: `
const data = { type: 'coords', x: 1, y: 2 };
const { type, ...coords } = data;
console.log(coords);
      `,
      parserOptions: { ecmaVersion: 2018 },
      errors: [
        {
          line: 3,
          column: 9,
          messageId: 'unusedVar',
          data: {
            varName: 'type',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },

    // Unused rest property with ignoreRestSiblings
    {
      code: `
const data = { type: 'coords', x: 2, y: 2 };
const { type, ...coords } = data;
console.log(type);
      `,
      options: [{ ignoreRestSiblings: true }],
      parserOptions: { ecmaVersion: 2018 },
      errors: [
        {
          line: 3,
          column: 18,
          messageId: 'unusedVar',
          data: {
            varName: 'coords',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },
    {
      code: `
let type, coords;
({ type, ...coords } = data);
console.log(type);
      `,
      options: [{ ignoreRestSiblings: true }],
      parserOptions: { ecmaVersion: 2018 },
      errors: [
        {
          line: 3,
          column: 13,
          messageId: 'unusedVar',
          data: {
            varName: 'coords',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },

    // Unused rest property without ignoreRestSiblings
    {
      code: `
const data = { type: 'coords', x: 3, y: 2 };
const { type, ...coords } = data;
console.log(type);
      `,
      parserOptions: { ecmaVersion: 2018 },
      errors: [
        {
          line: 3,
          column: 18,
          messageId: 'unusedVar',
          data: {
            varName: 'coords',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },

    // Nested array destructuring with rest property
    {
      code: `
const data = { vars: ['x', 'y'], x: 1, y: 2 };
const {
  vars: [x],
  ...coords
} = data;
console.log(coords);
      `,
      parserOptions: { ecmaVersion: 2018 },
      errors: [
        {
          line: 4,
          column: 10,
          messageId: 'unusedVar',
          data: {
            varName: 'x',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },

    // Nested object destructuring with rest property
    {
      code: `
const data = { defaults: { x: 0 }, x: 1, y: 2 };
const {
  defaults: { x },
  ...coords
} = data;
console.log(coords);
      `,
      parserOptions: { ecmaVersion: 2018 },
      errors: [
        {
          line: 4,
          column: 15,
          messageId: 'unusedVar',
          data: {
            varName: 'x',
            action: 'assigned a value',
            additional: '',
          },
        },
      ],
    },

    // https://github.com/eslint/eslint/issues/8119
    {
      code: '({ a, ...rest }) => {};',
      options: [{ args: 'all', ignoreRestSiblings: true }],
      parserOptions: { ecmaVersion: 2018 },
      errors: [definedError('rest')],
    },

    // https://github.com/eslint/eslint/issues/3714
    {
      // cspell:disable-next-line
      code: '/* global a$fooz,$foo */\na$fooz;',
      errors: [
        {
          line: 1,
          column: 18,
          endLine: 1,
          endColumn: 22,
          messageId: 'unusedVar',
          data: {
            varName: '$foo',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },
    {
      // cspell:disable-next-line
      code: '/* globals a$fooz, $ */\na$fooz;',
      errors: [
        {
          line: 1,
          column: 20,
          endLine: 1,
          endColumn: 21,
          messageId: 'unusedVar',
          data: {
            varName: '$',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },
    {
      code: '/*globals $foo*/',
      errors: [
        {
          line: 1,
          column: 11,
          endLine: 1,
          endColumn: 15,
          messageId: 'unusedVar',
          data: {
            varName: '$foo',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },
    {
      code: '/* global global*/',
      errors: [
        {
          line: 1,
          column: 11,
          endLine: 1,
          endColumn: 17,
          messageId: 'unusedVar',
          data: {
            varName: 'global',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },
    {
      code: '/*global foo:true*/',
      errors: [
        {
          line: 1,
          column: 10,
          endLine: 1,
          endColumn: 13,
          messageId: 'unusedVar',
          data: {
            varName: 'foo',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },

    // non ascii.
    {
      code: '/*global 変数, 数*/\n変数;',
      errors: [
        {
          line: 1,
          column: 14,
          endLine: 1,
          endColumn: 15,
          messageId: 'unusedVar',
          data: {
            varName: '数',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },

    // surrogate pair.
    {
      code: `
/*global 𠮷𩸽, 𠮷*/
𠮷𩸽;
      `,
      env: { es6: true },
      errors: [
        {
          line: 2,
          column: 16,
          endLine: 2,
          endColumn: 18,
          messageId: 'unusedVar',
          data: {
            varName: '𠮷',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },

    // https://github.com/eslint/eslint/issues/4047
    {
      code: 'export default function (a) {}',
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('a')],
    },
    {
      code: `
export default function (a, b) {
  console.log(a);
}
      `,
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('b')],
    },
    {
      code: 'export default (function (a) {});',
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('a')],
    },
    {
      code: `
export default (function (a, b) {
  console.log(a);
});
      `,
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('b')],
    },
    {
      code: 'export default a => {};',
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('a')],
    },
    {
      code: `
export default (a, b) => {
  console.log(a);
};
      `,
      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      errors: [definedError('b')],
    },

    // caughtErrors
    {
      code: `
try {
} catch (err) {}
      `,
      options: [{ caughtErrors: 'all' }],
      errors: [definedError('err')],
    },
    {
      code: `
try {
} catch (err) {}
      `,
      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
      errors: [
        definedError('err', '. Allowed unused args must match /^ignore/u'),
      ],
    },

    // multiple try catch with one success
    {
      code: `
try {
} catch (ignoreErr) {}
try {
} catch (err) {}
      `,
      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
      errors: [
        definedError('err', '. Allowed unused args must match /^ignore/u'),
      ],
    },

    // multiple try catch both fail
    {
      code: `
try {
} catch (error) {}
try {
} catch (err) {}
      `,
      options: [{ caughtErrors: 'all', caughtErrorsIgnorePattern: '^ignore' }],
      errors: [
        definedError('error', '. Allowed unused args must match /^ignore/u'),
        definedError('err', '. Allowed unused args must match /^ignore/u'),
      ],
    },

    // caughtErrors with other configs
    {
      code: `
try {
} catch (err) {}
      `,
      options: [{ vars: 'all', args: 'all', caughtErrors: 'all' }],
      errors: [definedError('err')],
    },

    // no conflict in ignore patterns
    {
      code: `
try {
} catch (err) {}
      `,
      options: [
        {
          vars: 'all',
          args: 'all',
          caughtErrors: 'all',
          argsIgnorePattern: '^er',
        },
      ],
      errors: [definedError('err')],
    },

    // Ignore reads for modifications to itself: https://github.com/eslint/eslint/issues/6348
    {
      code: `
var a = 0;
a = a + 1;
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 0;
a = a + a;
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 0;
a += a + 1;
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 0;
a++;
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
function foo(a) {
  a = a + 1;
}
foo();
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
function foo(a) {
  a += a + 1;
}
foo();
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
function foo(a) {
  a++;
}
foo();
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 3;
a = a * 5 + 6;
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
var a = 2,
  b = 4;
a = a * 2 + b;
      `,
      errors: [assignedError('a')],
    },

    // https://github.com/eslint/eslint/issues/6576 (For coverage)
    {
      code: `
function foo(cb) {
  cb = function (a) {
    cb(1 + a);
  };
  bar(not_cb);
}
foo();
      `,
      errors: [assignedError('cb')],
    },
    {
      code: `
function foo(cb) {
  cb = (function (a) {
    return cb(1 + a);
  })();
}
foo();
      `,
      errors: [assignedError('cb')],
    },
    {
      code: `
function foo(cb) {
  cb =
    (function (a) {
      cb(1 + a);
    },
    cb);
}
foo();
      `,
      errors: [assignedError('cb')],
    },
    {
      code: `
function foo(cb) {
  cb =
    (0,
    function (a) {
      cb(1 + a);
    });
}
foo();
      `,
      errors: [assignedError('cb')],
    },

    // https://github.com/eslint/eslint/issues/6646
    {
      code: [
        'while (a) {',
        '    function foo(b) {',
        '        b = b + 1;',
        '    }',
        '    foo()',
        '}',
      ].join('\n'),
      errors: [assignedError('b')],
    },

    // https://github.com/eslint/eslint/issues/7124
    {
      code: '(function (a, b, c) {});',
      options: [{ argsIgnorePattern: 'c' }],
      errors: [
        definedError('a', '. Allowed unused args must match /c/u'),
        definedError('b', '. Allowed unused args must match /c/u'),
      ],
    },
    {
      code: '(function (a, b, { c, d }) {});',
      options: [{ argsIgnorePattern: '[cd]' }],
      parserOptions: { ecmaVersion: 6 },
      errors: [
        definedError('a', '. Allowed unused args must match /[cd]/u'),
        definedError('b', '. Allowed unused args must match /[cd]/u'),
      ],
    },
    {
      code: '(function (a, b, { c, d }) {});',
      options: [{ argsIgnorePattern: 'c' }],
      parserOptions: { ecmaVersion: 6 },
      errors: [
        definedError('a', '. Allowed unused args must match /c/u'),
        definedError('b', '. Allowed unused args must match /c/u'),
        definedError('d', '. Allowed unused args must match /c/u'),
      ],
    },
    {
      code: '(function (a, b, { c, d }) {});',
      options: [{ argsIgnorePattern: 'd' }],
      parserOptions: { ecmaVersion: 6 },
      errors: [
        definedError('a', '. Allowed unused args must match /d/u'),
        definedError('b', '. Allowed unused args must match /d/u'),
        definedError('c', '. Allowed unused args must match /d/u'),
      ],
    },
    {
      code: `
/*global
foo*/
      `,
      errors: [
        {
          line: 3,
          column: 1,
          endLine: 3,
          endColumn: 4,
          messageId: 'unusedVar',
          data: {
            varName: 'foo',
            action: 'defined',
            additional: '',
          },
        },
      ],
    },

    // https://github.com/eslint/eslint/issues/8442
    {
      code: `
(function ({ a }, b) {
  return b;
})();
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [definedError('a')],
    },
    {
      code: `
(function ({ a }, { b, c }) {
  return b;
})();
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [definedError('a'), definedError('c')],
    },
    {
      code: `
(function ({ a, b }, { c }) {
  return b;
})();
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [definedError('a'), definedError('c')],
    },
    {
      code: `
(function ([a], b) {
  return b;
})();
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [definedError('a')],
    },
    {
      code: `
(function ([a], [b, c]) {
  return b;
})();
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [definedError('a'), definedError('c')],
    },
    {
      code: `
(function ([a, b], [c]) {
  return b;
})();
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [definedError('a'), definedError('c')],
    },

    // https://github.com/eslint/eslint/issues/9774
    {
      code: '(function (_a) {})();',
      options: [{ args: 'all', varsIgnorePattern: '^_' }],
      errors: [definedError('_a')],
    },
    {
      code: '(function (_a) {})();',
      options: [{ args: 'all', caughtErrorsIgnorePattern: '^_' }],
      errors: [definedError('_a')],
    },

    // https://github.com/eslint/eslint/issues/10982
    {
      code: `
var a = function () {
  a();
};
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
var a = function () {
  return function () {
    a();
  };
};
      `,
      errors: [assignedError('a')],
    },
    {
      code: `
const a = () => {
  a();
};
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [assignedError('a')],
    },
    {
      code: `
const a = () => () => {
  a();
};
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [assignedError('a')],
    },
    {
      code: `
let myArray = [1, 2, 3, 4].filter(x => x == 0);
myArray = myArray.filter(x => x == 1);
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [
        {
          ...assignedError('myArray'),
          line: 3,
          column: 1,
        },
      ],
    },
    {
      code: `
const a = 1;
a += 1;
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [
        {
          ...assignedError('a'),
          line: 3,
          column: 1,
        },
      ],
    },
    {
      code: `
var a = function () {
  a();
};
      `,
      errors: [
        {
          ...assignedError('a'),
          line: 2,
          column: 5,
        },
      ],
    },
    {
      code: `
var a = function () {
  return function () {
    a();
  };
};
      `,
      errors: [
        {
          ...assignedError('a'),
          line: 2,
          column: 5,
        },
      ],
    },
    {
      code: `
const a = () => {
  a();
};
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [
        {
          ...assignedError('a'),
          line: 2,
          column: 7,
        },
      ],
    },
    {
      code: `
const a = () => () => {
  a();
};
      `,
      parserOptions: { ecmaVersion: 2015 },
      errors: [
        {
          ...assignedError('a'),
          line: 2,
          column: 7,
        },
      ],
    },

    // https://github.com/eslint/eslint/issues/14324
    {
      code: 'let x = [];\nx = x.concat(x);',
      parserOptions: { ecmaVersion: 2015 },
      errors: [{ ...assignedError('x'), line: 2, column: 1 }],
    },
    {
      code: `
let a = 'a';
a = 10;
function foo() {
  a = 11;
  a = () => {
    a = 13;
  };
}
      `,
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        {
          ...assignedError('a'),
          line: 3,
          column: 1,
        },
        {
          ...definedError('foo'),
          line: 4,
          column: 10,
        },
      ],
    },
    {
      code: `
let foo;
init();
foo = foo + 2;
function init() {
  foo = 1;
}
      `,
      parserOptions: { ecmaVersion: 2020 },
      errors: [{ ...assignedError('foo'), line: 4, column: 1 }],
    },
    {
      code: `
function foo(n) {
  if (n < 2) return 1;
  return n * foo(n - 1);
}
      `,
      parserOptions: { ecmaVersion: 2020 },
      errors: [{ ...definedError('foo'), line: 2, column: 10 }],
    },
    {
      code: `
let c = 'c';
c = 10;
function foo1() {
  c = 11;
  c = () => {
    c = 13;
  };
}
c = foo1;
      `,
      parserOptions: { ecmaVersion: 2020 },
      errors: [
        {
          ...assignedError('c'),
          line: 10,
          column: 1,
        },
      ],
    },
  ],
});