mirror of
https://github.com/hanzoai/eslint.git
synced 2026-10-30 19:38:10 +00:00
3590 lines
79 KiB
JavaScript
3590 lines
79 KiB
JavaScript
/**
|
|
* @fileoverview Tests for complexity rule.
|
|
* @author Gyandeep Singh
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const rule = require("../../../lib/rules/accessor-pairs"),
|
|
RuleTester = require("../../../lib/rule-tester/rule-tester");
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Helpers
|
|
//------------------------------------------------------------------------------
|
|
|
|
const ruleTester = new RuleTester();
|
|
|
|
ruleTester.run("accessor-pairs", rule, {
|
|
valid: [
|
|
//------------------------------------------------------------------------------
|
|
// General
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Does not check object patterns
|
|
{
|
|
code: "var { get: foo } = bar; ({ set: foo } = bar);",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var { set } = foo; ({ get } = foo);",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Object literals
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Test default settings, this would be an error if `getWithoutSet` was set to `true`
|
|
"var o = { get a() {} }",
|
|
{
|
|
code: "var o = { get a() {} }",
|
|
options: [{}],
|
|
},
|
|
|
|
// No accessors
|
|
{
|
|
code: "var o = {};",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { a: 1 };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { a };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { a: get };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { a: set };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { get: function(){} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { set: function(foo){} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { get };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { set };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { [get]: function() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { [set]: function(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { set(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Disabled options
|
|
{
|
|
code: "var o = { get a() {} };",
|
|
options: [{ setWithoutGet: false, getWithoutSet: false }],
|
|
},
|
|
{
|
|
code: "var o = { get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: false }],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {} };",
|
|
options: [{ setWithoutGet: false, getWithoutSet: false }],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {} };",
|
|
options: [{ setWithoutGet: false, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {} };",
|
|
options: [{ setWithoutGet: false }],
|
|
},
|
|
|
|
// Valid pairs with identifiers
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: false, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: false }],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
|
|
// Valid pairs with statically computed names
|
|
{
|
|
code: "var o = { get 'a'() {}, set 'a'(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set 'a'(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { get ['abc']() {}, set ['abc'](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [1e2]() {}, set 100(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get abc() {}, set [`abc`](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get ['123']() {}, set 123(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Valid pairs with expressions
|
|
{
|
|
code: "var o = { get [a]() {}, set [a](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [a]() {}, set [(a)](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [(a)]() {}, set [a](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [a]() {}, set [ a ](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [/*comment*/a/*comment*/]() {}, set [a](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [f()]() {}, set [f()](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [f(a)]() {}, set [f(a)](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [a + b]() {}, set [a + b](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get [`${a}`]() {}, set [`${a}`](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Multiple valid pairs in the same literal
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {}, get b() {}, set b(bar) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set c(foo) {}, set a(bar) {}, get b() {}, get c() {}, set b(baz) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
|
|
// Valid pairs with other elements
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {}, b: bar };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, b, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, ...b, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 2018 },
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {}, ...a };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 2018 },
|
|
},
|
|
|
|
// Duplicate keys. This is the responsibility of no-dupe-keys, but this rule still checks is there the other accessor kind.
|
|
{
|
|
code: "var o = { get a() {}, get a() {}, set a(foo) {}, };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {}, get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { set a(bar) {}, get a() {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: false }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: false, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set a(foo) {}, a };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var o = { a, get a() {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
/*
|
|
* This should be actually invalid by this rule!
|
|
* This code creates a property with the setter only, the getter will be ignored.
|
|
* It's treated as 3 attempts to define the same key, and the last wins.
|
|
* However, this edge case is not covered, it should be reported by no-dupe-keys anyway.
|
|
*/
|
|
{
|
|
code: "var o = { get a() {}, a:1, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Property descriptors
|
|
//------------------------------------------------------------------------------
|
|
|
|
"var o = {a: 1};\n Object.defineProperty(o, 'b', \n{set: function(value) {\n val = value; \n},\n get: function() {\n return val; \n} \n});",
|
|
|
|
// https://github.com/eslint/eslint/issues/3262
|
|
"var o = {set: function() {}}",
|
|
"Object.defineProperties(obj, {set: {value: function() {}}});",
|
|
"Object.create(null, {set: {value: function() {}}});",
|
|
{
|
|
code: "var o = {get: function() {}}",
|
|
options: [{ getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "var o = {[set]: function() {}}",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var set = 'value'; Object.defineProperty(obj, 'foo', {[set]: function(value) {}});",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// wrong argument index (not in the property descriptor position)
|
|
"Object.defineProperty({ set: function(value) {} }, 'foo', { value: 1 });",
|
|
{
|
|
code: "Reflect.defineProperty({ get() {} }, 'foo', { value: 1 });",
|
|
options: [{ getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "Object.defineProperties({ foo: { get() {} } }, { bar: { value: 1 } });",
|
|
options: [{ getWithoutSet: true }],
|
|
},
|
|
"Object.create({ foo: { set(value) {} } }, { bar: { value: 1 } });",
|
|
|
|
// global object is shadowed
|
|
{
|
|
code: "let Object; Object.defineProperty(foo, 'bar', { get() {} })",
|
|
options: [{ getWithoutSet: true }],
|
|
},
|
|
{
|
|
code: "function f() { Reflect.defineProperty(foo, 'bar', { set(value) {} }); var Reflect;}",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
"function f(Object) { Object.defineProperties(foo, { bar: { set(value) {} } }) }",
|
|
{
|
|
code: "if (x) { const Object = getObject(); Object.create(foo, { bar: { get() {} } }) }",
|
|
options: [{ getWithoutSet: true }],
|
|
},
|
|
|
|
// global object doesn't exist
|
|
{
|
|
code: "Reflect.defineProperty(foo, 'bar', { get() {} })",
|
|
options: [{ getWithoutSet: true }],
|
|
languageOptions: { globals: { Reflect: "off" } },
|
|
},
|
|
"/* globals Object:off */ Object.defineProperty(foo, 'bar', { set(value) {} })",
|
|
{
|
|
code: "Object.defineProperties(foo, { bar: { set(value) {} } })",
|
|
languageOptions: { globals: { Object: "off" } },
|
|
},
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Classes
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Test default settings
|
|
{
|
|
code: "class A { get a() {} }",
|
|
options: [{ enforceForClassMembers: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get #a() {} }",
|
|
options: [{ enforceForClassMembers: true }],
|
|
languageOptions: { ecmaVersion: 13 },
|
|
},
|
|
|
|
// Explicitly disabled option
|
|
{
|
|
code: "class A { set a(foo) {} }",
|
|
options: [{ enforceForClassMembers: false }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get a() {} set b(foo) {} static get c() {} static set d(bar) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: false,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "(class A { get a() {} set b(foo) {} static get c() {} static set d(bar) {} });",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: false,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Disabled accessor kind options
|
|
{
|
|
code: "class A { get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: false,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: false,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { set a(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get a() {} set b(foo) {} static get c() {} static set d(bar) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: false,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// No accessors
|
|
{
|
|
code: "class A {}",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "(class {})",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { constructor () {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static a() {} 'b'() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { [a]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { a() {} static a() {} b() {} static c() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Valid pairs with identifiers
|
|
{
|
|
code: "class A { get a() {} set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { set a(foo) {} get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static get a() {} static set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} static get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "(class { set a(foo) {} get a() {} });",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Valid pairs with statically computed names
|
|
{
|
|
code: "class A { get 'a'() {} set ['a'](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { set [`a`](foo) {} get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get 'a'() {} set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { static get 1e2() {} static set [100](foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Valid pairs with expressions
|
|
{
|
|
code: "class A { get [a]() {} set [a](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { set [(f())](foo) {} get [(f())]() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static set [f(a)](foo) {} static get [f(a)]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Multiple valid pairs in the same class
|
|
{
|
|
code: "class A { get a() {} set b(foo) {} set a(bar) {} get b() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get a() {} set a(bar) {} b() {} set c(foo) {} get c() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "(class { get a() {} static set a(foo) {} set a(bar) {} static get a() {} });",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Valid pairs with other elements
|
|
{
|
|
code: "class A { get a() {} b() {} set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { set a(foo) {} get a() {} b() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { a() {} get b() {} c() {} set b(foo) {} d() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get a() {} set a(foo) {} static a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { static get a() {} static b() {} static set a(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { static set a(foo) {} static get a() {} a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// Duplicate keys. This is the responsibility of no-dupe-class-members, but this rule still checks if there is the other accessor kind.
|
|
{
|
|
code: "class A { get a() {} get a() {} set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get [a]() {} set [a](foo) {} set [a](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { get a() {} set 'a'(foo) {} get [`a`]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { get a() {} set a(foo) {} a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "A = class { a() {} get a() {} set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} static set a(foo) {} static get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static get a() {} static set a(foo) {} static get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} static get a() {} static a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
/*
|
|
* This code should be invalid by this rule because it creates a class with the setter only, while the getter is ignored.
|
|
* However, this edge case is not covered, it should be reported by no-dupe-class-members anyway.
|
|
*/
|
|
{
|
|
code: "class A { get a() {} a() {} set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} static a() {} static get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
],
|
|
|
|
invalid: [
|
|
//------------------------------------------------------------------------------
|
|
// Object literals
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Test default settings
|
|
{
|
|
code: "var o = { set a(value) {} };",
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(value) {} };",
|
|
options: [{}],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
|
|
// Test that the options do not affect each other
|
|
{
|
|
code: "var o = { set a(value) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: false }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(value) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {} };",
|
|
options: [{ setWithoutGet: false, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {} };",
|
|
options: [{ getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
|
|
// Various kinds of the getter's key
|
|
{
|
|
code: "var o = { get abc() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get 'abc'() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get 123() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter '123'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get 1e2() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter '100'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get ['abc']() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [`abc`]() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [123]() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter '123'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [abc]() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [f(abc)]() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [a + b]() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter.",
|
|
},
|
|
],
|
|
},
|
|
|
|
// Various kinds of the setter's key
|
|
{
|
|
code: "var o = { set abc(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set 'abc'(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set 123(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter '123'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set 1e2(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter '100'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set ['abc'](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set [`abc`](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set [123](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter '123'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set [abc](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set [f(abc)](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set [a + b](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
},
|
|
],
|
|
},
|
|
|
|
// Different keys
|
|
{
|
|
code: "var o = { get a() {}, set b(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'b'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, get b() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for getter 'b'.",
|
|
column: 26,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get 1() {}, set b(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter '1'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'b'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set 1(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter '1'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set 'a '(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'a '.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get ' a'() {}, set 'a'(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter ' a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 26,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get ''() {}, set ' '(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter ''.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter ' '.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get ''() {}, set null(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter ''.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'null'.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [`a`]() {}, set b(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'b'.",
|
|
column: 27,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [a]() {}, set [b](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
column: 25,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [a]() {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 25,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set [a](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [a + b]() {}, set [a - b](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
column: 29,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get [`${0} `]() {}, set [`${0}`](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
column: 31,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Multiple invalid of same and different kinds
|
|
{
|
|
code: "var o = { get a() {}, get b() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for getter 'b'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, set b(bar) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'b'.",
|
|
column: 26,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, set b(foo) {}, set c(foo) {}, get d() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'b'.",
|
|
column: 23,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'c'.",
|
|
column: 38,
|
|
},
|
|
{
|
|
message: "Setter is not present for getter 'd'.",
|
|
column: 53,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Checks per object literal
|
|
{
|
|
code: "var o1 = { get a() {} }, o2 = { set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 12,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 33,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o1 = { set a(foo) {} }, o2 = { get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 12,
|
|
},
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 36,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Combinations or valid and invalid
|
|
{
|
|
code: "var o = { get a() {}, get b() {}, set b(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get b() {}, get a() {}, set b(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get b() {}, set b(foo) {}, get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 38,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, get b() {}, set b(bar) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get b() {}, set a(foo) {}, set b(bar) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get b() {}, set b(bar) {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 38,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get v1() {}, set i1(foo) {}, get v2() {}, set v2(bar) {}, get i2() {}, set v1(baz) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'i1'.",
|
|
column: 24,
|
|
},
|
|
{
|
|
message: "Setter is not present for getter 'i2'.",
|
|
column: 69,
|
|
},
|
|
],
|
|
},
|
|
|
|
// In the case of duplicates which don't have the other kind, all nodes are reported
|
|
{
|
|
code: "var o = { get a() {}, get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 26,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Other elements or even value property duplicates in the same literal do not affect this rule
|
|
{
|
|
code: "var o = { a, get b() {}, c };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'b'.",
|
|
column: 14,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { a, get b() {}, c, set d(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'b'.",
|
|
column: 14,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'd'.",
|
|
column: 29,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, a:1 };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { a, get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 14,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, a:1 };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { a, set a(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 14,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, ...b };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 2018 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { get a() {}, ...a };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 2018 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = { set a(foo) {}, ...a };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 2018 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Full location tests
|
|
{
|
|
code: "var o = { get b() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'b'.",
|
|
line: 1,
|
|
column: 11,
|
|
endLine: 1,
|
|
endColumn: 16,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = {\n set [\n a](foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 2015 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter.",
|
|
line: 2,
|
|
column: 3,
|
|
endLine: 3,
|
|
endColumn: 4,
|
|
},
|
|
],
|
|
},
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Property descriptors
|
|
//------------------------------------------------------------------------------
|
|
|
|
{
|
|
code: "var o = {d: 1};\n Object.defineProperty(o, 'c', \n{set: function(value) {\n val = value; \n} \n});",
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Reflect.defineProperty(obj, 'foo', {set: function(value) {}});",
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Object.defineProperties(obj, {foo: {set: function(value) {}}});",
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Object.create(null, {foo: {set: function(value) {}}});",
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = {d: 1};\n Object?.defineProperty(o, 'c', \n{set: function(value) {\n val = value; \n} \n});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Reflect?.defineProperty(obj, 'foo', {set: function(value) {}});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Object?.defineProperties(obj, {foo: {set: function(value) {}}});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Object?.create(null, {foo: {set: function(value) {}}});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var o = {d: 1};\n (Object?.defineProperty)(o, 'c', \n{set: function(value) {\n val = value; \n} \n});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "(Reflect?.defineProperty)(obj, 'foo', {set: function(value) {}});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "(Object?.defineProperties)(obj, {foo: {set: function(value) {}}});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "(Object?.create)(null, {foo: {set: function(value) {}}});",
|
|
languageOptions: { ecmaVersion: 2020 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present in property descriptor.",
|
|
},
|
|
],
|
|
},
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Classes
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Test default settings
|
|
{
|
|
code: "class A { set a(foo) {} }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get a() {} set b(foo) {} }",
|
|
options: [{}],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'b'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get a() {} }",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set a(foo) {} }",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get a() {} }",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} }",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { get a() {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { get a() {} set b(foo) {} };",
|
|
options: [{ setWithoutGet: true, getWithoutSet: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'b'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set a(value) {} }",
|
|
options: [{ enforceForClassMembers: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set a(value) {} }",
|
|
options: [{ enforceForClassMembers: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { set a(value) {} };",
|
|
options: [{ enforceForClassMembers: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "(class A { static set a(value) {} });",
|
|
options: [{ enforceForClassMembers: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set '#a'(foo) {} }",
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter '#a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set #a(foo) {} }",
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class private setter #a.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set '#a'(foo) {} }",
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter '#a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set #a(foo) {} }",
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static private setter #a.",
|
|
},
|
|
],
|
|
},
|
|
|
|
// Test that the accessor kind options do not affect each other
|
|
{
|
|
code: "class A { set a(value) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: false,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static set a(value) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let foo = class A { get a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "(class { get a() {} });",
|
|
options: [{ getWithoutSet: true, enforceForClassMembers: true }],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get '#a'() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter '#a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get #a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class private getter #a.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get '#a'() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter '#a'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get #a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static private getter #a.",
|
|
},
|
|
],
|
|
},
|
|
|
|
// Various kinds of keys
|
|
{
|
|
code: "class A { get abc() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static set 'abc'(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "(class { get 123() {} });",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter '123'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get 1e2() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter '100'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { get ['abc']() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set [`abc`](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'abc'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get [123]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter '123'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get [abc]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get [f(abc)]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class static getter.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { set [a + b](foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get ['constructor']() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class getter 'constructor'.",
|
|
},
|
|
],
|
|
},
|
|
|
|
// Different keys
|
|
{
|
|
code: "class A { get a() {} set b(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'b'.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { set a(foo) {} get b() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter 'b'.",
|
|
column: 27,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static get a() {} static set b(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'b'.",
|
|
column: 31,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get a() {} set b(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: false,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get a() {} set b(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: false,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'b'.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get 'a '() {} set 'a'(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a '.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 25,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get 'a'() {} set 1(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter '1'.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get 1() {} set 2(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter '1'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter '2'.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get ''() {} set null(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter ''.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'null'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get a() {} set [a](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get [a]() {} set [b](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get [a]() {} set [a++](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get [a + b]() {} set [a - b](foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter.",
|
|
column: 28,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get #a() {} set '#a'(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class private getter #a.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter '#a'.",
|
|
column: 23,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get '#a'() {} set #a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 13 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter '#a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message:
|
|
"Getter is not present for class private setter #a.",
|
|
column: 25,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Prototype and static accessors with same keys
|
|
{
|
|
code: "class A { get a() {} static set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static get a() {} set a(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 31,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set [a](foo) {} static get [a]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for class static getter.",
|
|
column: 27,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set [a](foo) {} get [a]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class static setter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 34,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Multiple invalid of same and different kinds
|
|
{
|
|
code: "class A { get a() {} get b() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter 'b'.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { get a() {} get [b]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get [a]() {} get [b]() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { set a(foo) {} set b(bar) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'b'.",
|
|
column: 27,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get a() {} static get b() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'b'.",
|
|
column: 29,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static set a(foo) {} static set b(bar) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'b'.",
|
|
column: 34,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get a() {} set b(foo) {} static set c(bar) {} get d() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'b'.",
|
|
column: 29,
|
|
},
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'c'.",
|
|
column: 43,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter 'd'.",
|
|
column: 64,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Checks per class
|
|
{
|
|
code: "class A { get a() {} } class B { set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 34,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { set a(foo) {} }, class { get a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 38,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { get a() {} }, { set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message: "Getter is not present for setter 'a'.",
|
|
column: 29,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = { get a() {} }, class { set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for getter 'a'.",
|
|
column: 7,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 29,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Combinations or valid and invalid
|
|
{
|
|
code: "class A { get a() {} get b() {} set b(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { get b() {} get a() {} set b(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 24,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set b(foo) {} get b() {} set a(bar) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 36,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static get b() {} set a(foo) {} static set b(bar) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 31,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} get b() {} set b(bar) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get b() {} static get a() {} set b(bar) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set b(foo) {} static get a() {} static get b() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 32,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { get [v1](){} static set i1(foo){} static set v2(bar){} get [i2](){} static get i3(){} set [v1](baz){} static get v2(){} set i4(quux){} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'i1'.",
|
|
column: 24,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter.",
|
|
column: 66,
|
|
},
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'i3'.",
|
|
column: 79,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'i4'.",
|
|
column: 131,
|
|
},
|
|
],
|
|
},
|
|
|
|
// In the case of duplicates which don't have the other kind, all nodes are reported
|
|
{
|
|
code: "class A { get a() {} get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 22,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { set a(foo) {} set a(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 27,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static get a() {} static get a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 13,
|
|
},
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 31,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { set a(foo) {} set a(foo) {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 11,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 25,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Other elements or even method duplicates in the same class do not affect this rule
|
|
{
|
|
code: "class A { a() {} get b() {} c() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'b'.",
|
|
column: 18,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { a() {} get b() {} c() {} set d(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'b'.",
|
|
column: 20,
|
|
},
|
|
{
|
|
message: "Getter is not present for class setter 'd'.",
|
|
column: 38,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static a() {} get b() {} static c() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'b'.",
|
|
column: 25,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { a() {} get a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
column: 18,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static a() {} set a(foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter 'a'.",
|
|
column: 27,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { a() {} static get b() {} c() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'b'.",
|
|
column: 18,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class { static a() {} static set b(foo) {} static c() {} d() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'b'.",
|
|
column: 27,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { a() {} static get a() {} a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'a'.",
|
|
column: 18,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static set a(foo) {} static a() {} }",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Getter is not present for class static setter 'a'.",
|
|
column: 11,
|
|
},
|
|
],
|
|
},
|
|
|
|
// Full location tests
|
|
{
|
|
code: "class A { get a() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for class getter 'a'.",
|
|
line: 1,
|
|
column: 11,
|
|
endLine: 1,
|
|
endColumn: 16,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "A = class {\n set [\n a](foo) {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for class setter.",
|
|
line: 2,
|
|
column: 3,
|
|
endLine: 3,
|
|
endColumn: 4,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "class A { static get b() {} };",
|
|
options: [
|
|
{
|
|
setWithoutGet: true,
|
|
getWithoutSet: true,
|
|
enforceForClassMembers: true,
|
|
},
|
|
],
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
message:
|
|
"Setter is not present for class static getter 'b'.",
|
|
line: 1,
|
|
column: 11,
|
|
endLine: 1,
|
|
endColumn: 23,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
const ruleTesterTypeScript = new RuleTester({
|
|
languageOptions: {
|
|
parser: require("@typescript-eslint/parser"),
|
|
},
|
|
});
|
|
|
|
ruleTesterTypeScript.run("accessor-pairs", rule, {
|
|
valid: [
|
|
"interface I { get prop(): any }",
|
|
"type T = { set prop(value: any): void }",
|
|
{
|
|
code: "interface I { get prop(): any, set prop(value: any): void }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "type T = { get prop(): any, set prop(value: any): void }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "interface I { get prop(): any, between: true, set prop(value: any): void }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "interface I { set prop(value: any): void, get prop(): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "interface I { set prop(value: any): void, get 'prop'(): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
|
|
{
|
|
code: "interface I {}",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "interface I { (...args): void }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "interface I { new(...args): unknown }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "interface I { prop: () => any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
{
|
|
code: "interface I { method(): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
|
|
{
|
|
code: "type T = { get prop(): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
},
|
|
],
|
|
invalid: [
|
|
{
|
|
code: "({ set prop(value) {} });",
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for setter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "interface I { set prop(value: any): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for type setter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "interface I { set prop(value: any): any, get other(): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for type setter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "interface I { set prop(value: any): any, prop(): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for type setter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "interface I { set [prop](value: any): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for type setter 'null'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "interface I { get prop(): any } interface J { set prop(value: any): void }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for type setter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "type T = { set prop(value: any): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for type setter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "function fn(): { set prop(value: any): any }",
|
|
options: [{ enforceForTSTypes: true }],
|
|
errors: [
|
|
{
|
|
message: "Getter is not present for type setter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "type T = { get prop(): any }",
|
|
options: [{ enforceForTSTypes: true, getWithoutSet: true }],
|
|
errors: [
|
|
{
|
|
message: "Setter is not present for type getter 'prop'.",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|