]>
git.proxmox.com Git - pve-eslint.git/blob - eslint/tests/lib/rules/accessor-pairs.js
2 * @fileoverview Tests for complexity rule.
3 * @author Gyandeep Singh
8 //------------------------------------------------------------------------------
10 //------------------------------------------------------------------------------
12 const rule
= require ( "../../../lib/rules/accessor-pairs" ),
13 { RuleTester
} = require ( "../../../lib/rule-tester" );
15 //------------------------------------------------------------------------------
17 //------------------------------------------------------------------------------
19 const ruleTester
= new RuleTester ();
21 ruleTester
. run ( "accessor-pairs" , rule
, {
24 //------------------------------------------------------------------------------
26 //------------------------------------------------------------------------------
28 // Does not check object patterns
30 code
: "var { get: foo } = bar; ({ set: foo } = bar);" ,
31 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
32 parserOptions
: { ecmaVersion
: 6 }
35 code
: "var { set } = foo; ({ get } = foo);" ,
36 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
37 parserOptions
: { ecmaVersion
: 6 }
40 //------------------------------------------------------------------------------
42 //------------------------------------------------------------------------------
44 // Test default settings, this would be an error if `getWithoutSet` was set to `true`
45 "var o = { get a() {} }" ,
47 code
: "var o = { get a() {} }" ,
54 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
57 code
: "var o = { a: 1 };" ,
58 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
61 code
: "var o = { a };" ,
62 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
63 parserOptions
: { ecmaVersion
: 6 }
66 code
: "var o = { a: get };" ,
67 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
70 code
: "var o = { a: set };" ,
71 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
74 code
: "var o = { get: function(){} };" ,
75 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
78 code
: "var o = { set: function(foo){} };" ,
79 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
82 code
: "var o = { get };" ,
83 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
84 parserOptions
: { ecmaVersion
: 6 }
87 code
: "var o = { set };" ,
88 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
89 parserOptions
: { ecmaVersion
: 6 }
92 code
: "var o = { [get]: function() {} };" ,
93 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
94 parserOptions
: { ecmaVersion
: 6 }
97 code
: "var o = { [set]: function(foo) {} };" ,
98 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
99 parserOptions
: { ecmaVersion
: 6 }
102 code
: "var o = { get() {} };" ,
103 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
104 parserOptions
: { ecmaVersion
: 6 }
107 code
: "var o = { set(foo) {} };" ,
108 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
109 parserOptions
: { ecmaVersion
: 6 }
114 code
: "var o = { get a() {} };" ,
115 options
: [{ setWithoutGet
: false , getWithoutSet
: false }]
118 code
: "var o = { get a() {} };" ,
119 options
: [{ setWithoutGet
: true , getWithoutSet
: false }]
122 code
: "var o = { set a(foo) {} };" ,
123 options
: [{ setWithoutGet
: false , getWithoutSet
: false }]
126 code
: "var o = { set a(foo) {} };" ,
127 options
: [{ setWithoutGet
: false , getWithoutSet
: true }]
130 code
: "var o = { set a(foo) {} };" ,
131 options
: [{ setWithoutGet
: false }]
134 // Valid pairs with identifiers
136 code
: "var o = { get a() {}, set a(foo) {} };" ,
137 options
: [{ setWithoutGet
: false , getWithoutSet
: true }]
140 code
: "var o = { get a() {}, set a(foo) {} };" ,
141 options
: [{ setWithoutGet
: true , getWithoutSet
: false }]
144 code
: "var o = { get a() {}, set a(foo) {} };" ,
145 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
148 code
: "var o = { set a(foo) {}, get a() {} };" ,
149 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
152 // Valid pairs with statically computed names
154 code
: "var o = { get 'a'() {}, set 'a'(foo) {} };" ,
155 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
158 code
: "var o = { get a() {}, set 'a'(foo) {} };" ,
159 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
162 code
: "var o = { get ['abc']() {}, set ['abc'](foo) {} };" ,
163 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
164 parserOptions
: { ecmaVersion
: 6 }
167 code
: "var o = { get [1e2]() {}, set 100(foo) {} };" ,
168 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
169 parserOptions
: { ecmaVersion
: 6 }
172 code
: "var o = { get abc() {}, set [`abc`](foo) {} };" ,
173 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
174 parserOptions
: { ecmaVersion
: 6 }
177 code
: "var o = { get ['123']() {}, set 123(foo) {} };" ,
178 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
179 parserOptions
: { ecmaVersion
: 6 }
182 // Valid pairs with expressions
184 code
: "var o = { get [a]() {}, set [a](foo) {} };" ,
185 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
186 parserOptions
: { ecmaVersion
: 6 }
189 code
: "var o = { get [a]() {}, set [(a)](foo) {} };" ,
190 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
191 parserOptions
: { ecmaVersion
: 6 }
194 code
: "var o = { get [(a)]() {}, set [a](foo) {} };" ,
195 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
196 parserOptions
: { ecmaVersion
: 6 }
199 code
: "var o = { get [a]() {}, set [ a ](foo) {} };" ,
200 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
201 parserOptions
: { ecmaVersion
: 6 }
204 code
: "var o = { get [/*comment*/a/*comment*/]() {}, set [a](foo) {} };" ,
205 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
206 parserOptions
: { ecmaVersion
: 6 }
209 code
: "var o = { get [f()]() {}, set [f()](foo) {} };" ,
210 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
211 parserOptions
: { ecmaVersion
: 6 }
214 code
: "var o = { get [f(a)]() {}, set [f(a)](foo) {} };" ,
215 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
216 parserOptions
: { ecmaVersion
: 6 }
219 code
: "var o = { get [a + b]() {}, set [a + b](foo) {} };" ,
220 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
221 parserOptions
: { ecmaVersion
: 6 }
224 code
: "var o = { get [` ${a} `]() {}, set [` ${a} `](foo) {} };" ,
225 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
226 parserOptions
: { ecmaVersion
: 6 }
229 // Multiple valid pairs in the same literal
231 code
: "var o = { get a() {}, set a(foo) {}, get b() {}, set b(bar) {} };" ,
232 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
235 code
: "var o = { get a() {}, set c(foo) {}, set a(bar) {}, get b() {}, get c() {}, set b(baz) {} };" ,
236 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
239 // Valid pairs with other elements
241 code
: "var o = { get a() {}, set a(foo) {}, b: bar };" ,
242 options
: [{ setWithoutGet
: true , getWithoutSet
: true }]
245 code
: "var o = { get a() {}, b, set a(foo) {} };" ,
246 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
247 parserOptions
: { ecmaVersion
: 6 }
250 code
: "var o = { get a() {}, ...b, set a(foo) {} };" ,
251 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
252 parserOptions
: { ecmaVersion
: 2018 }
255 code
: "var o = { get a() {}, set a(foo) {}, ...a };" ,
256 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
257 parserOptions
: { ecmaVersion
: 2018 }
260 // Duplicate keys. This is the responsibility of no-dupe-keys, but this rule still checks is there the other accessor kind.
262 code
: "var o = { get a() {}, get a() {}, set a(foo) {}, };" ,
263 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
264 parserOptions
: { ecmaVersion
: 6 }
267 code
: "var o = { get a() {}, set a(foo) {}, get a() {} };" ,
268 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
269 parserOptions
: { ecmaVersion
: 6 }
272 code
: "var o = { get a() {}, set a(foo) {}, set a(foo) {} };" ,
273 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
274 parserOptions
: { ecmaVersion
: 6 }
277 code
: "var o = { set a(bar) {}, get a() {}, set a(foo) {} };" ,
278 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
279 parserOptions
: { ecmaVersion
: 6 }
282 code
: "var o = { get a() {}, get a() {} };" ,
283 options
: [{ setWithoutGet
: true , getWithoutSet
: false }],
284 parserOptions
: { ecmaVersion
: 6 }
287 code
: "var o = { set a(foo) {}, set a(foo) {} };" ,
288 options
: [{ setWithoutGet
: false , getWithoutSet
: true }],
289 parserOptions
: { ecmaVersion
: 6 }
292 code
: "var o = { get a() {}, set a(foo) {}, a };" ,
293 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
294 parserOptions
: { ecmaVersion
: 6 }
297 code
: "var o = { a, get a() {}, set a(foo) {} };" ,
298 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
299 parserOptions
: { ecmaVersion
: 6 }
303 * This should be actually invalid by this rule!
304 * This code creates a property with the setter only, the getter will be ignored.
305 * It's treated as 3 attempts to define the same key, and the last wins.
306 * However, this edge case is not covered, it should be reported by no-dupe-keys anyway.
309 code
: "var o = { get a() {}, a:1, set a(foo) {} };" ,
310 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
311 parserOptions
: { ecmaVersion
: 6 }
314 //------------------------------------------------------------------------------
315 // Property descriptors
316 //------------------------------------------------------------------------------
318 "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 });" ,
320 // https://github.com/eslint/eslint/issues/3262
321 "var o = {set: function() {}}" ,
322 "Object.defineProperties(obj, {set: {value: function() {}}});" ,
323 "Object.create(null, {set: {value: function() {}}});" ,
324 { code
: "var o = {get: function() {}}" , options
: [{ getWithoutSet
: true }] },
325 { code
: "var o = {[set]: function() {}}" , parserOptions
: { ecmaVersion
: 6 } },
326 { code
: "var set = 'value'; Object.defineProperty(obj, 'foo', {[set]: function(value) {}});" , parserOptions
: { ecmaVersion
: 6 } },
328 //------------------------------------------------------------------------------
330 //------------------------------------------------------------------------------
332 // Test default settings
334 code
: "class A { get a() {} }" ,
335 options
: [{ enforceForClassMembers
: true }],
336 parserOptions
: { ecmaVersion
: 6 }
339 // Explicitly disabled option
341 code
: "class A { set a(foo) {} }" ,
342 options
: [{ enforceForClassMembers
: false }],
343 parserOptions
: { ecmaVersion
: 6 }
346 code
: "class A { get a() {} set b(foo) {} static get c() {} static set d(bar) {} }" ,
347 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: false }],
348 parserOptions
: { ecmaVersion
: 6 }
351 code
: "(class A { get a() {} set b(foo) {} static get c() {} static set d(bar) {} });" ,
352 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: false }],
353 parserOptions
: { ecmaVersion
: 6 }
356 // Disabled accessor kind options
358 code
: "class A { get a() {} }" ,
359 options
: [{ setWithoutGet
: true , getWithoutSet
: false , enforceForClassMembers
: true }],
360 parserOptions
: { ecmaVersion
: 6 }
363 code
: "class A { set a(foo) {} }" ,
364 options
: [{ setWithoutGet
: false , getWithoutSet
: true , enforceForClassMembers
: true }],
365 parserOptions
: { ecmaVersion
: 6 }
368 code
: "class A { static get a() {} }" ,
369 options
: [{ setWithoutGet
: true , getWithoutSet
: false , enforceForClassMembers
: true }],
370 parserOptions
: { ecmaVersion
: 6 }
373 code
: "class A { static set a(foo) {} }" ,
374 options
: [{ setWithoutGet
: false , getWithoutSet
: true , enforceForClassMembers
: true }],
375 parserOptions
: { ecmaVersion
: 6 }
378 code
: "A = class { set a(foo) {} };" ,
379 options
: [{ setWithoutGet
: false , getWithoutSet
: true , enforceForClassMembers
: true }],
380 parserOptions
: { ecmaVersion
: 6 }
383 code
: "class A { get a() {} set b(foo) {} static get c() {} static set d(bar) {} }" ,
384 options
: [{ setWithoutGet
: false , getWithoutSet
: false , enforceForClassMembers
: true }],
385 parserOptions
: { ecmaVersion
: 6 }
391 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
392 parserOptions
: { ecmaVersion
: 6 }
396 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
397 parserOptions
: { ecmaVersion
: 6 }
400 code
: "class A { constructor () {} }" ,
401 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
402 parserOptions
: { ecmaVersion
: 6 }
405 code
: "class A { a() {} }" ,
406 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
407 parserOptions
: { ecmaVersion
: 6 }
410 code
: "class A { static a() {} 'b'() {} }" ,
411 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
412 parserOptions
: { ecmaVersion
: 6 }
415 code
: "class A { [a]() {} }" ,
416 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
417 parserOptions
: { ecmaVersion
: 6 }
420 code
: "A = class { a() {} static a() {} b() {} static c() {} }" ,
421 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
422 parserOptions
: { ecmaVersion
: 6 }
425 // Valid pairs with identifiers
427 code
: "class A { get a() {} set a(foo) {} }" ,
428 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
429 parserOptions
: { ecmaVersion
: 6 }
432 code
: "class A { set a(foo) {} get a() {} }" ,
433 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
434 parserOptions
: { ecmaVersion
: 6 }
437 code
: "class A { static get a() {} static set a(foo) {} }" ,
438 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
439 parserOptions
: { ecmaVersion
: 6 }
442 code
: "class A { static set a(foo) {} static get a() {} }" ,
443 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
444 parserOptions
: { ecmaVersion
: 6 }
447 code
: "(class { set a(foo) {} get a() {} });" ,
448 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
449 parserOptions
: { ecmaVersion
: 6 }
452 // Valid pairs with statically computed names
454 code
: "class A { get 'a'() {} set ['a'](foo) {} }" ,
455 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
456 parserOptions
: { ecmaVersion
: 6 }
459 code
: "class A { set [`a`](foo) {} get a() {} }" ,
460 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
461 parserOptions
: { ecmaVersion
: 6 }
464 code
: "class A { get 'a'() {} set a(foo) {} }" ,
465 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
466 parserOptions
: { ecmaVersion
: 6 }
469 code
: "A = class { static get 1e2() {} static set [100](foo) {} };" ,
470 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
471 parserOptions
: { ecmaVersion
: 6 }
474 // Valid pairs with expressions
476 code
: "class A { get [a]() {} set [a](foo) {} }" ,
477 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
478 parserOptions
: { ecmaVersion
: 6 }
481 code
: "A = class { set [(f())](foo) {} get [(f())]() {} };" ,
482 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
483 parserOptions
: { ecmaVersion
: 6 }
486 code
: "class A { static set [f(a)](foo) {} static get [f(a)]() {} }" ,
487 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
488 parserOptions
: { ecmaVersion
: 6 }
491 // Multiple valid pairs in the same class
493 code
: "class A { get a() {} set b(foo) {} set a(bar) {} get b() {} }" ,
494 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
495 parserOptions
: { ecmaVersion
: 6 }
498 code
: "class A { get a() {} set a(bar) {} b() {} set c(foo) {} get c() {} }" ,
499 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
500 parserOptions
: { ecmaVersion
: 6 }
503 code
: "(class { get a() {} static set a(foo) {} set a(bar) {} static get a() {} });" ,
504 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
505 parserOptions
: { ecmaVersion
: 6 }
508 // Valid pairs with other elements
510 code
: "class A { get a() {} b() {} set a(foo) {} }" ,
511 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
512 parserOptions
: { ecmaVersion
: 6 }
515 code
: "class A { set a(foo) {} get a() {} b() {} }" ,
516 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
517 parserOptions
: { ecmaVersion
: 6 }
520 code
: "class A { a() {} get b() {} c() {} set b(foo) {} d() {} }" ,
521 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
522 parserOptions
: { ecmaVersion
: 6 }
525 code
: "class A { get a() {} set a(foo) {} static a() {} }" ,
526 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
527 parserOptions
: { ecmaVersion
: 6 }
530 code
: "A = class { static get a() {} static b() {} static set a(foo) {} };" ,
531 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
532 parserOptions
: { ecmaVersion
: 6 }
535 code
: "A = class { static set a(foo) {} static get a() {} a() {} };" ,
536 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
537 parserOptions
: { ecmaVersion
: 6 }
540 // Duplicate keys. This is the responsibility of no-dupe-class-members, but this rule still checks if there is the other accessor kind.
542 code
: "class A { get a() {} get a() {} set a(foo) {} }" ,
543 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
544 parserOptions
: { ecmaVersion
: 6 }
547 code
: "class A { get [a]() {} set [a](foo) {} set [a](foo) {} }" ,
548 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
549 parserOptions
: { ecmaVersion
: 6 }
552 code
: "class A { get a() {} set 'a'(foo) {} get [`a`]() {} }" ,
553 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
554 parserOptions
: { ecmaVersion
: 6 }
557 code
: "A = class { get a() {} set a(foo) {} a() {} }" ,
558 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
559 parserOptions
: { ecmaVersion
: 6 }
562 code
: "A = class { a() {} get a() {} set a(foo) {} }" ,
563 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
564 parserOptions
: { ecmaVersion
: 6 }
567 code
: "class A { static set a(foo) {} static set a(foo) {} static get a() {} }" ,
568 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
569 parserOptions
: { ecmaVersion
: 6 }
572 code
: "class A { static get a() {} static set a(foo) {} static get a() {} }" ,
573 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
574 parserOptions
: { ecmaVersion
: 6 }
577 code
: "class A { static set a(foo) {} static get a() {} static a() {} }" ,
578 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
579 parserOptions
: { ecmaVersion
: 6 }
583 * This code should be invalid by this rule because it creates a class with the setter only, while the getter is ignored.
584 * However, this edge case is not covered, it should be reported by no-dupe-class-members anyway.
587 code
: "class A { get a() {} a() {} set a(foo) {} }" ,
588 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
589 parserOptions
: { ecmaVersion
: 6 }
592 code
: "class A { static set a(foo) {} static a() {} static get a() {} }" ,
593 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
594 parserOptions
: { ecmaVersion
: 6 }
600 //------------------------------------------------------------------------------
602 //------------------------------------------------------------------------------
604 // Test default settings
606 code
: "var o = { set a(value) {} };" ,
607 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" }]
610 code
: "var o = { set a(value) {} };" ,
612 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" }]
615 // Test that the options do not affect each other
617 code
: "var o = { set a(value) {} };" ,
618 options
: [{ setWithoutGet
: true , getWithoutSet
: false }],
619 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" }]
622 code
: "var o = { set a(value) {} };" ,
623 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
624 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" }]
627 code
: "var o = { get a() {} };" ,
628 options
: [{ setWithoutGet
: false , getWithoutSet
: true }],
629 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" }]
632 code
: "var o = { get a() {} };" ,
633 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
634 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" }]
637 code
: "var o = { get a() {} };" ,
638 options
: [{ getWithoutSet
: true }],
639 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" }]
642 // Various kinds of the getter's key
644 code
: "var o = { get abc() {} };" ,
645 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
646 errors
: [{ message
: "Setter is not present for getter 'abc'." , type
: "Property" }]
649 code
: "var o = { get 'abc'() {} };" ,
650 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
651 errors
: [{ message
: "Setter is not present for getter 'abc'." , type
: "Property" }]
654 code
: "var o = { get 123() {} };" ,
655 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
656 errors
: [{ message
: "Setter is not present for getter '123'." , type
: "Property" }]
659 code
: "var o = { get 1e2() {} };" ,
660 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
661 errors
: [{ message
: "Setter is not present for getter '100'." , type
: "Property" }]
664 code
: "var o = { get ['abc']() {} };" ,
665 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
666 parserOptions
: { ecmaVersion
: 6 },
667 errors
: [{ message
: "Setter is not present for getter 'abc'." , type
: "Property" }]
670 code
: "var o = { get [`abc`]() {} };" ,
671 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
672 parserOptions
: { ecmaVersion
: 6 },
673 errors
: [{ message
: "Setter is not present for getter 'abc'." , type
: "Property" }]
676 code
: "var o = { get [123]() {} };" ,
677 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
678 parserOptions
: { ecmaVersion
: 6 },
679 errors
: [{ message
: "Setter is not present for getter '123'." , type
: "Property" }]
682 code
: "var o = { get [abc]() {} };" ,
683 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
684 parserOptions
: { ecmaVersion
: 6 },
685 errors
: [{ message
: "Setter is not present for getter." , type
: "Property" }]
688 code
: "var o = { get [f(abc)]() {} };" ,
689 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
690 parserOptions
: { ecmaVersion
: 6 },
691 errors
: [{ message
: "Setter is not present for getter." , type
: "Property" }]
694 code
: "var o = { get [a + b]() {} };" ,
695 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
696 parserOptions
: { ecmaVersion
: 6 },
697 errors
: [{ message
: "Setter is not present for getter." , type
: "Property" }]
700 // Various kinds of the setter's key
702 code
: "var o = { set abc(foo) {} };" ,
703 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
704 errors
: [{ message
: "Getter is not present for setter 'abc'." , type
: "Property" }]
707 code
: "var o = { set 'abc'(foo) {} };" ,
708 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
709 errors
: [{ message
: "Getter is not present for setter 'abc'." , type
: "Property" }]
712 code
: "var o = { set 123(foo) {} };" ,
713 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
714 errors
: [{ message
: "Getter is not present for setter '123'." , type
: "Property" }]
717 code
: "var o = { set 1e2(foo) {} };" ,
718 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
719 errors
: [{ message
: "Getter is not present for setter '100'." , type
: "Property" }]
722 code
: "var o = { set ['abc'](foo) {} };" ,
723 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
724 parserOptions
: { ecmaVersion
: 6 },
725 errors
: [{ message
: "Getter is not present for setter 'abc'." , type
: "Property" }]
728 code
: "var o = { set [`abc`](foo) {} };" ,
729 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
730 parserOptions
: { ecmaVersion
: 6 },
731 errors
: [{ message
: "Getter is not present for setter 'abc'." , type
: "Property" }]
734 code
: "var o = { set [123](foo) {} };" ,
735 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
736 parserOptions
: { ecmaVersion
: 6 },
737 errors
: [{ message
: "Getter is not present for setter '123'." , type
: "Property" }]
740 code
: "var o = { set [abc](foo) {} };" ,
741 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
742 parserOptions
: { ecmaVersion
: 6 },
743 errors
: [{ message
: "Getter is not present for setter." , type
: "Property" }]
746 code
: "var o = { set [f(abc)](foo) {} };" ,
747 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
748 parserOptions
: { ecmaVersion
: 6 },
749 errors
: [{ message
: "Getter is not present for setter." , type
: "Property" }]
752 code
: "var o = { set [a + b](foo) {} };" ,
753 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
754 parserOptions
: { ecmaVersion
: 6 },
755 errors
: [{ message
: "Getter is not present for setter." , type
: "Property" }]
760 code
: "var o = { get a() {}, set b(foo) {} };" ,
761 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
763 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
764 { message
: "Getter is not present for setter 'b'." , type
: "Property" , column
: 23 }
768 code
: "var o = { set a(foo) {}, get b() {} };" ,
769 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
771 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 11 },
772 { message
: "Setter is not present for getter 'b'." , type
: "Property" , column
: 26 }
776 code
: "var o = { get 1() {}, set b(foo) {} };" ,
777 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
779 { message
: "Setter is not present for getter '1'." , type
: "Property" , column
: 11 },
780 { message
: "Getter is not present for setter 'b'." , type
: "Property" , column
: 23 }
784 code
: "var o = { get a() {}, set 1(foo) {} };" ,
785 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
787 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
788 { message
: "Getter is not present for setter '1'." , type
: "Property" , column
: 23 }
792 code
: "var o = { get a() {}, set 'a '(foo) {} };" ,
793 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
795 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
796 { message
: "Getter is not present for setter 'a '." , type
: "Property" , column
: 23 }
800 code
: "var o = { get ' a'() {}, set 'a'(foo) {} };" ,
801 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
803 { message
: "Setter is not present for getter ' a'." , type
: "Property" , column
: 11 },
804 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 26 }
808 code
: "var o = { get ''() {}, set ' '(foo) {} };" ,
809 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
811 { message
: "Setter is not present for getter ''." , type
: "Property" , column
: 11 },
812 { message
: "Getter is not present for setter ' '." , type
: "Property" , column
: 24 }
816 code
: "var o = { get ''() {}, set null(foo) {} };" ,
817 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
819 { message
: "Setter is not present for getter ''." , type
: "Property" , column
: 11 },
820 { message
: "Getter is not present for setter 'null'." , type
: "Property" , column
: 24 }
824 code
: "var o = { get [`a`]() {}, set b(foo) {} };" ,
825 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
826 parserOptions
: { ecmaVersion
: 6 },
828 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
829 { message
: "Getter is not present for setter 'b'." , type
: "Property" , column
: 27 }
833 code
: "var o = { get [a]() {}, set [b](foo) {} };" ,
834 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
835 parserOptions
: { ecmaVersion
: 6 },
837 { message
: "Setter is not present for getter." , type
: "Property" , column
: 11 },
838 { message
: "Getter is not present for setter." , type
: "Property" , column
: 25 }
842 code
: "var o = { get [a]() {}, set a(foo) {} };" ,
843 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
844 parserOptions
: { ecmaVersion
: 6 },
846 { message
: "Setter is not present for getter." , type
: "Property" , column
: 11 },
847 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 25 }
851 code
: "var o = { get a() {}, set [a](foo) {} };" ,
852 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
853 parserOptions
: { ecmaVersion
: 6 },
855 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
856 { message
: "Getter is not present for setter." , type
: "Property" , column
: 23 }
860 code
: "var o = { get [a + b]() {}, set [a - b](foo) {} };" ,
861 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
862 parserOptions
: { ecmaVersion
: 6 },
864 { message
: "Setter is not present for getter." , type
: "Property" , column
: 11 },
865 { message
: "Getter is not present for setter." , type
: "Property" , column
: 29 }
869 code
: "var o = { get [` ${0} `]() {}, set [` ${0} `](foo) {} };" ,
870 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
871 parserOptions
: { ecmaVersion
: 6 },
873 { message
: "Setter is not present for getter." , type
: "Property" , column
: 11 },
874 { message
: "Getter is not present for setter." , type
: "Property" , column
: 31 }
878 // Multiple invalid of same and different kinds
880 code
: "var o = { get a() {}, get b() {} };" ,
881 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
883 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
884 { message
: "Setter is not present for getter 'b'." , type
: "Property" , column
: 23 }
888 code
: "var o = { set a(foo) {}, set b(bar) {} };" ,
889 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
891 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 11 },
892 { message
: "Getter is not present for setter 'b'." , type
: "Property" , column
: 26 }
896 code
: "var o = { get a() {}, set b(foo) {}, set c(foo) {}, get d() {} };" ,
897 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
899 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
900 { message
: "Getter is not present for setter 'b'." , type
: "Property" , column
: 23 },
901 { message
: "Getter is not present for setter 'c'." , type
: "Property" , column
: 38 },
902 { message
: "Setter is not present for getter 'd'." , type
: "Property" , column
: 53 }
906 // Checks per object literal
908 code
: "var o1 = { get a() {} }, o2 = { set a(foo) {} };" ,
909 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
911 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 12 },
912 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 33 }
916 code
: "var o1 = { set a(foo) {} }, o2 = { get a() {} };" ,
917 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
919 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 12 },
920 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 36 }
924 // Combinations or valid and invalid
926 code
: "var o = { get a() {}, get b() {}, set b(foo) {} };" ,
927 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
928 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 }]
931 code
: "var o = { get b() {}, get a() {}, set b(foo) {} };" ,
932 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
933 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 23 }]
936 code
: "var o = { get b() {}, set b(foo) {}, get a() {} };" ,
937 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
938 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 38 }]
941 code
: "var o = { set a(foo) {}, get b() {}, set b(bar) {} };" ,
942 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
943 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 11 }]
946 code
: "var o = { get b() {}, set a(foo) {}, set b(bar) {} };" ,
947 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
948 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 23 }]
951 code
: "var o = { get b() {}, set b(bar) {}, set a(foo) {} };" ,
952 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
953 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 38 }]
956 code
: "var o = { get v1() {}, set i1(foo) {}, get v2() {}, set v2(bar) {}, get i2() {}, set v1(baz) {} };" ,
957 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
959 { message
: "Getter is not present for setter 'i1'." , type
: "Property" , column
: 24 },
960 { message
: "Setter is not present for getter 'i2'." , type
: "Property" , column
: 69 }
964 // In the case of duplicates which don't have the other kind, all nodes are reported
966 code
: "var o = { get a() {}, get a() {} };" ,
967 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
968 parserOptions
: { ecmaVersion
: 6 },
970 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 },
971 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 23 }
975 code
: "var o = { set a(foo) {}, set a(foo) {} };" ,
976 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
977 parserOptions
: { ecmaVersion
: 6 },
979 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 11 },
980 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 26 }
984 // Other elements or even value property duplicates in the same literal do not affect this rule
986 code
: "var o = { a, get b() {}, c };" ,
987 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
988 parserOptions
: { ecmaVersion
: 6 },
989 errors
: [{ message
: "Setter is not present for getter 'b'." , type
: "Property" , column
: 14 }]
992 code
: "var o = { a, get b() {}, c, set d(foo) {} };" ,
993 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
994 parserOptions
: { ecmaVersion
: 6 },
996 { message
: "Setter is not present for getter 'b'." , type
: "Property" , column
: 14 },
997 { message
: "Getter is not present for setter 'd'." , type
: "Property" , column
: 29 }
1001 code
: "var o = { get a() {}, a:1 };" ,
1002 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1003 parserOptions
: { ecmaVersion
: 6 },
1004 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 }]
1007 code
: "var o = { a, get a() {} };" ,
1008 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1009 parserOptions
: { ecmaVersion
: 6 },
1010 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 14 }]
1013 code
: "var o = { set a(foo) {}, a:1 };" ,
1014 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1015 parserOptions
: { ecmaVersion
: 6 },
1016 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 11 }]
1019 code
: "var o = { a, set a(foo) {} };" ,
1020 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1021 parserOptions
: { ecmaVersion
: 6 },
1022 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 14 }]
1025 code
: "var o = { get a() {}, ...b };" ,
1026 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1027 parserOptions
: { ecmaVersion
: 2018 },
1028 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 }]
1031 code
: "var o = { get a() {}, ...a };" ,
1032 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1033 parserOptions
: { ecmaVersion
: 2018 },
1034 errors
: [{ message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 11 }]
1037 code
: "var o = { set a(foo) {}, ...a };" ,
1038 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1039 parserOptions
: { ecmaVersion
: 2018 },
1040 errors
: [{ message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 11 }]
1043 // Full location tests
1045 code
: "var o = { get a() {} };" ,
1046 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1048 message
: "Setter is not present for getter 'a'." ,
1057 code
: "var o = { \n set [ \n a](foo) {} };" ,
1058 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1059 parserOptions
: { ecmaVersion
: 2015 },
1061 message
: "Getter is not present for setter." ,
1070 //------------------------------------------------------------------------------
1071 // Property descriptors
1072 //------------------------------------------------------------------------------
1075 code
: "var o = {d: 1}; \n Object.defineProperty(o, 'c', \n {set: function(value) { \n val = value; \n } \n });" ,
1076 errors
: [{ message
: "Getter is not present in property descriptor." , type
: "ObjectExpression" }]
1079 code
: "Reflect.defineProperty(obj, 'foo', {set: function(value) {}});" ,
1080 errors
: [{ message
: "Getter is not present in property descriptor." , type
: "ObjectExpression" }]
1083 code
: "Object.defineProperties(obj, {foo: {set: function(value) {}}});" ,
1084 errors
: [{ message
: "Getter is not present in property descriptor." , type
: "ObjectExpression" }]
1087 code
: "Object.create(null, {foo: {set: function(value) {}}});" ,
1088 errors
: [{ message
: "Getter is not present in property descriptor." , type
: "ObjectExpression" }]
1091 //------------------------------------------------------------------------------
1093 //------------------------------------------------------------------------------
1095 // Test default settings
1097 code
: "class A { set a(foo) {} }" ,
1098 parserOptions
: { ecmaVersion
: 6 },
1099 errors
: [{ message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" }]
1102 code
: "class A { get a() {} set b(foo) {} }" ,
1104 parserOptions
: { ecmaVersion
: 6 },
1105 errors
: [{ message
: "Getter is not present for class setter 'b'." , type
: "MethodDefinition" }]
1108 code
: "class A { get a() {} }" ,
1109 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1110 parserOptions
: { ecmaVersion
: 6 },
1111 errors
: [{ message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" }]
1114 code
: "class A { set a(foo) {} }" ,
1115 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1116 parserOptions
: { ecmaVersion
: 6 },
1117 errors
: [{ message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" }]
1120 code
: "class A { static get a() {} }" ,
1121 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1122 parserOptions
: { ecmaVersion
: 6 },
1123 errors
: [{ message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" }]
1126 code
: "class A { static set a(foo) {} }" ,
1127 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1128 parserOptions
: { ecmaVersion
: 6 },
1129 errors
: [{ message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" }]
1132 code
: "A = class { get a() {} };" ,
1133 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1134 parserOptions
: { ecmaVersion
: 6 },
1135 errors
: [{ message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" }]
1138 code
: "A = class { get a() {} set b(foo) {} };" ,
1139 options
: [{ setWithoutGet
: true , getWithoutSet
: true }],
1140 parserOptions
: { ecmaVersion
: 6 },
1142 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" },
1143 { message
: "Getter is not present for class setter 'b'." , type
: "MethodDefinition" }
1147 code
: "class A { set a(value) {} }" ,
1148 options
: [{ enforceForClassMembers
: true }],
1149 parserOptions
: { ecmaVersion
: 6 },
1150 errors
: [{ message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" }]
1153 code
: "class A { static set a(value) {} }" ,
1154 options
: [{ enforceForClassMembers
: true }],
1155 parserOptions
: { ecmaVersion
: 6 },
1156 errors
: [{ message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" }]
1159 code
: "A = class { set a(value) {} };" ,
1160 options
: [{ enforceForClassMembers
: true }],
1161 parserOptions
: { ecmaVersion
: 6 },
1162 errors
: [{ message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" }]
1165 code
: "(class A { static set a(value) {} });" ,
1166 options
: [{ enforceForClassMembers
: true }],
1167 parserOptions
: { ecmaVersion
: 6 },
1168 errors
: [{ message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" }]
1171 // Test that the accessor kind options do not affect each other
1173 code
: "class A { set a(value) {} }" ,
1174 options
: [{ setWithoutGet
: true , getWithoutSet
: false , enforceForClassMembers
: true }],
1175 parserOptions
: { ecmaVersion
: 6 },
1176 errors
: [{ message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" }]
1179 code
: "A = class { static set a(value) {} };" ,
1180 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1181 parserOptions
: { ecmaVersion
: 6 },
1182 errors
: [{ message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" }]
1185 code
: "let foo = class A { get a() {} };" ,
1186 options
: [{ setWithoutGet
: false , getWithoutSet
: true , enforceForClassMembers
: true }],
1187 parserOptions
: { ecmaVersion
: 6 },
1188 errors
: [{ message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" }]
1191 code
: "class A { static get a() {} };" ,
1192 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1193 parserOptions
: { ecmaVersion
: 6 },
1194 errors
: [{ message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" }]
1197 code
: "(class { get a() {} });" ,
1198 options
: [{ getWithoutSet
: true , enforceForClassMembers
: true }],
1199 parserOptions
: { ecmaVersion
: 6 },
1200 errors
: [{ message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" }]
1203 // Various kinds of keys
1205 code
: "class A { get abc() {} }" ,
1206 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1207 parserOptions
: { ecmaVersion
: 6 },
1208 errors
: [{ message
: "Setter is not present for class getter 'abc'." , type
: "MethodDefinition" }]
1211 code
: "A = class { static set 'abc'(foo) {} };" ,
1212 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1213 parserOptions
: { ecmaVersion
: 6 },
1214 errors
: [{ message
: "Getter is not present for class static setter 'abc'." , type
: "MethodDefinition" }]
1217 code
: "(class { get 123() {} });" ,
1218 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1219 parserOptions
: { ecmaVersion
: 6 },
1220 errors
: [{ message
: "Setter is not present for class getter '123'." , type
: "MethodDefinition" }]
1223 code
: "class A { static get 1e2() {} }" ,
1224 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1225 parserOptions
: { ecmaVersion
: 6 },
1226 errors
: [{ message
: "Setter is not present for class static getter '100'." , type
: "MethodDefinition" }]
1229 code
: "A = class { get ['abc']() {} };" ,
1230 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1231 parserOptions
: { ecmaVersion
: 6 },
1232 errors
: [{ message
: "Setter is not present for class getter 'abc'." , type
: "MethodDefinition" }]
1235 code
: "class A { set [`abc`](foo) {} }" ,
1236 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1237 parserOptions
: { ecmaVersion
: 6 },
1238 errors
: [{ message
: "Getter is not present for class setter 'abc'." , type
: "MethodDefinition" }]
1241 code
: "class A { static get [123]() {} }" ,
1242 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1243 parserOptions
: { ecmaVersion
: 6 },
1244 errors
: [{ message
: "Setter is not present for class static getter '123'." , type
: "MethodDefinition" }]
1247 code
: "class A { get [abc]() {} }" ,
1248 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1249 parserOptions
: { ecmaVersion
: 6 },
1250 errors
: [{ message
: "Setter is not present for class getter." , type
: "MethodDefinition" }]
1253 code
: "class A { static get [f(abc)]() {} }" ,
1254 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1255 parserOptions
: { ecmaVersion
: 6 },
1256 errors
: [{ message
: "Setter is not present for class static getter." , type
: "MethodDefinition" }]
1259 code
: "A = class { set [a + b](foo) {} };" ,
1260 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1261 parserOptions
: { ecmaVersion
: 6 },
1262 errors
: [{ message
: "Getter is not present for class setter." , type
: "MethodDefinition" }]
1265 code
: "class A { get ['constructor']() {} }" ,
1266 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1267 parserOptions
: { ecmaVersion
: 6 },
1268 errors
: [{ message
: "Setter is not present for class getter 'constructor'." , type
: "MethodDefinition" }]
1273 code
: "class A { get a() {} set b(foo) {} }" ,
1274 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1275 parserOptions
: { ecmaVersion
: 6 },
1277 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1278 { message
: "Getter is not present for class setter 'b'." , type
: "MethodDefinition" , column
: 22 }
1282 code
: "A = class { set a(foo) {} get b() {} }" ,
1283 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1284 parserOptions
: { ecmaVersion
: 6 },
1286 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 13 },
1287 { message
: "Setter is not present for class getter 'b'." , type
: "MethodDefinition" , column
: 27 }
1291 code
: "A = class { static get a() {} static set b(foo) {} }" ,
1292 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1293 parserOptions
: { ecmaVersion
: 6 },
1295 { message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 13 },
1296 { message
: "Getter is not present for class static setter 'b'." , type
: "MethodDefinition" , column
: 31 }
1300 code
: "class A { get a() {} set b(foo) {} }" ,
1301 options
: [{ setWithoutGet
: false , getWithoutSet
: true , enforceForClassMembers
: true }],
1302 parserOptions
: { ecmaVersion
: 6 },
1304 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 }
1308 code
: "class A { get a() {} set b(foo) {} }" ,
1309 options
: [{ setWithoutGet
: true , getWithoutSet
: false , enforceForClassMembers
: true }],
1310 parserOptions
: { ecmaVersion
: 6 },
1312 { message
: "Getter is not present for class setter 'b'." , type
: "MethodDefinition" , column
: 22 }
1316 code
: "class A { get 'a '() {} set 'a'(foo) {} }" ,
1317 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1318 parserOptions
: { ecmaVersion
: 6 },
1320 { message
: "Setter is not present for class getter 'a '." , type
: "MethodDefinition" , column
: 11 },
1321 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 25 }
1325 code
: "class A { get 'a'() {} set 1(foo) {} }" ,
1326 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1327 parserOptions
: { ecmaVersion
: 6 },
1329 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1330 { message
: "Getter is not present for class setter '1'." , type
: "MethodDefinition" , column
: 24 }
1334 code
: "class A { get 1() {} set 2(foo) {} }" ,
1335 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1336 parserOptions
: { ecmaVersion
: 6 },
1338 { message
: "Setter is not present for class getter '1'." , type
: "MethodDefinition" , column
: 11 },
1339 { message
: "Getter is not present for class setter '2'." , type
: "MethodDefinition" , column
: 22 }
1343 code
: "class A { get ''() {} set null(foo) {} }" ,
1344 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1345 parserOptions
: { ecmaVersion
: 6 },
1347 { message
: "Setter is not present for class getter ''." , type
: "MethodDefinition" , column
: 11 },
1348 { message
: "Getter is not present for class setter 'null'." , type
: "MethodDefinition" , column
: 23 }
1352 code
: "class A { get a() {} set [a](foo) {} }" ,
1353 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1354 parserOptions
: { ecmaVersion
: 6 },
1356 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1357 { message
: "Getter is not present for class setter." , type
: "MethodDefinition" , column
: 22 }
1361 code
: "class A { get [a]() {} set [b](foo) {} }" ,
1362 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1363 parserOptions
: { ecmaVersion
: 6 },
1365 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 11 },
1366 { message
: "Getter is not present for class setter." , type
: "MethodDefinition" , column
: 24 }
1370 code
: "class A { get [a]() {} set [a++](foo) {} }" ,
1371 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1372 parserOptions
: { ecmaVersion
: 6 },
1374 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 11 },
1375 { message
: "Getter is not present for class setter." , type
: "MethodDefinition" , column
: 24 }
1379 code
: "class A { get [a + b]() {} set [a - b](foo) {} }" ,
1380 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1381 parserOptions
: { ecmaVersion
: 6 },
1383 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 11 },
1384 { message
: "Getter is not present for class setter." , type
: "MethodDefinition" , column
: 28 }
1388 // Prototype and static accessors with same keys
1390 code
: "class A { get a() {} static set a(foo) {} }" ,
1391 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1392 parserOptions
: { ecmaVersion
: 6 },
1394 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1395 { message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" , column
: 22 }
1399 code
: "A = class { static get a() {} set a(foo) {} };" ,
1400 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1401 parserOptions
: { ecmaVersion
: 6 },
1403 { message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 13 },
1404 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 31 }
1408 code
: "class A { set [a](foo) {} static get [a]() {} }" ,
1409 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1410 parserOptions
: { ecmaVersion
: 6 },
1412 { message
: "Getter is not present for class setter." , type
: "MethodDefinition" , column
: 11 },
1413 { message
: "Setter is not present for class static getter." , type
: "MethodDefinition" , column
: 27 }
1417 code
: "class A { static set [a](foo) {} get [a]() {} }" ,
1418 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1419 parserOptions
: { ecmaVersion
: 6 },
1421 { message
: "Getter is not present for class static setter." , type
: "MethodDefinition" , column
: 11 },
1422 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 34 }
1426 // Multiple invalid of same and different kinds
1428 code
: "class A { get a() {} get b() {} }" ,
1429 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1430 parserOptions
: { ecmaVersion
: 6 },
1432 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1433 { message
: "Setter is not present for class getter 'b'." , type
: "MethodDefinition" , column
: 22 }
1437 code
: "A = class { get a() {} get [b]() {} }" ,
1438 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1439 parserOptions
: { ecmaVersion
: 6 },
1441 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 13 },
1442 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 24 }
1446 code
: "class A { get [a]() {} get [b]() {} }" ,
1447 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1448 parserOptions
: { ecmaVersion
: 6 },
1450 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 11 },
1451 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 24 }
1455 code
: "A = class { set a(foo) {} set b(bar) {} };" ,
1456 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1457 parserOptions
: { ecmaVersion
: 6 },
1459 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 13 },
1460 { message
: "Getter is not present for class setter 'b'." , type
: "MethodDefinition" , column
: 27 }
1464 code
: "class A { static get a() {} static get b() {} }" ,
1465 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1466 parserOptions
: { ecmaVersion
: 6 },
1468 { message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1469 { message
: "Setter is not present for class static getter 'b'." , type
: "MethodDefinition" , column
: 29 }
1473 code
: "A = class { static set a(foo) {} static set b(bar) {} }" ,
1474 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1475 parserOptions
: { ecmaVersion
: 6 },
1477 { message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" , column
: 13 },
1478 { message
: "Getter is not present for class static setter 'b'." , type
: "MethodDefinition" , column
: 34 }
1482 code
: "class A { static get a() {} set b(foo) {} static set c(bar) {} get d() {} }" ,
1483 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1484 parserOptions
: { ecmaVersion
: 6 },
1486 { message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1487 { message
: "Getter is not present for class setter 'b'." , type
: "MethodDefinition" , column
: 29 },
1488 { message
: "Getter is not present for class static setter 'c'." , type
: "MethodDefinition" , column
: 43 },
1489 { message
: "Setter is not present for class getter 'd'." , type
: "MethodDefinition" , column
: 64 }
1495 code
: "class A { get a() {} } class B { set a(foo) {} }" ,
1496 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1497 parserOptions
: { ecmaVersion
: 6 },
1499 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1500 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 34 }
1504 code
: "A = class { set a(foo) {} }, class { get a() {} };" ,
1505 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1506 parserOptions
: { ecmaVersion
: 6 },
1508 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 13 },
1509 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 38 }
1513 code
: "A = class { get a() {} }, { set a(foo) {} }" ,
1514 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1515 parserOptions
: { ecmaVersion
: 6 },
1517 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 13 },
1518 { message
: "Getter is not present for setter 'a'." , type
: "Property" , column
: 29 }
1522 code
: "A = { get a() {} }, class { set a(foo) {} }" ,
1523 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1524 parserOptions
: { ecmaVersion
: 6 },
1526 { message
: "Setter is not present for getter 'a'." , type
: "Property" , column
: 7 },
1527 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 29 }
1531 // Combinations or valid and invalid
1533 code
: "class A { get a() {} get b() {} set b(foo) {} }" ,
1534 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1535 parserOptions
: { ecmaVersion
: 6 },
1536 errors
: [{ message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 }]
1539 code
: "A = class { get b() {} get a() {} set b(foo) {} };" ,
1540 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1541 parserOptions
: { ecmaVersion
: 6 },
1542 errors
: [{ message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 24 }]
1545 code
: "class A { set b(foo) {} get b() {} set a(bar) {} }" ,
1546 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1547 parserOptions
: { ecmaVersion
: 6 },
1548 errors
: [{ message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 36 }]
1551 code
: "A = class { static get b() {} set a(foo) {} static set b(bar) {} };" ,
1552 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1553 parserOptions
: { ecmaVersion
: 6 },
1554 errors
: [{ message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 31 }]
1557 code
: "class A { static set a(foo) {} get b() {} set b(bar) {} }" ,
1558 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1559 parserOptions
: { ecmaVersion
: 6 },
1560 errors
: [{ message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" , column
: 11 }]
1563 code
: "class A { get b() {} static get a() {} set b(bar) {} }" ,
1564 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1565 parserOptions
: { ecmaVersion
: 6 },
1566 errors
: [{ message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 22 }]
1569 code
: "class A { static set b(foo) {} static get a() {} static get b() {} }" ,
1570 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1571 parserOptions
: { ecmaVersion
: 6 },
1572 errors
: [{ message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 32 }]
1575 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){} }" ,
1576 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1577 parserOptions
: { ecmaVersion
: 6 },
1579 { message
: "Getter is not present for class static setter 'i1'." , type
: "MethodDefinition" , column
: 24 },
1580 { message
: "Setter is not present for class getter." , type
: "MethodDefinition" , column
: 66 },
1581 { message
: "Setter is not present for class static getter 'i3'." , type
: "MethodDefinition" , column
: 79 },
1582 { message
: "Getter is not present for class setter 'i4'." , type
: "MethodDefinition" , column
: 131 }
1586 // In the case of duplicates which don't have the other kind, all nodes are reported
1588 code
: "class A { get a() {} get a() {} }" ,
1589 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1590 parserOptions
: { ecmaVersion
: 6 },
1592 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 11 },
1593 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 22 }
1597 code
: "A = class { set a(foo) {} set a(foo) {} };" ,
1598 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1599 parserOptions
: { ecmaVersion
: 6 },
1601 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 13 },
1602 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 27 }
1606 code
: "A = class { static get a() {} static get a() {} };" ,
1607 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1608 parserOptions
: { ecmaVersion
: 6 },
1610 { message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 13 },
1611 { message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 31 }
1615 code
: "class A { set a(foo) {} set a(foo) {} }" ,
1616 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1617 parserOptions
: { ecmaVersion
: 6 },
1619 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 11 },
1620 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 25 }
1624 // Other elements or even method duplicates in the same class do not affect this rule
1626 code
: "class A { a() {} get b() {} c() {} }" ,
1627 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1628 parserOptions
: { ecmaVersion
: 6 },
1630 { message
: "Setter is not present for class getter 'b'." , type
: "MethodDefinition" , column
: 18 }
1634 code
: "A = class { a() {} get b() {} c() {} set d(foo) {} };" ,
1635 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1636 parserOptions
: { ecmaVersion
: 6 },
1638 { message
: "Setter is not present for class getter 'b'." , type
: "MethodDefinition" , column
: 20 },
1639 { message
: "Getter is not present for class setter 'd'." , type
: "MethodDefinition" , column
: 38 }
1643 code
: "class A { static a() {} get b() {} static c() {} }" ,
1644 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1645 parserOptions
: { ecmaVersion
: 6 },
1647 { message
: "Setter is not present for class getter 'b'." , type
: "MethodDefinition" , column
: 25 }
1651 code
: "class A { a() {} get a() {} }" ,
1652 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1653 parserOptions
: { ecmaVersion
: 6 },
1655 { message
: "Setter is not present for class getter 'a'." , type
: "MethodDefinition" , column
: 18 }
1659 code
: "A = class { static a() {} set a(foo) {} };" ,
1660 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1661 parserOptions
: { ecmaVersion
: 6 },
1663 { message
: "Getter is not present for class setter 'a'." , type
: "MethodDefinition" , column
: 27 }
1667 code
: "class A { a() {} static get b() {} c() {} }" ,
1668 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1669 parserOptions
: { ecmaVersion
: 6 },
1671 { message
: "Setter is not present for class static getter 'b'." , type
: "MethodDefinition" , column
: 18 }
1675 code
: "A = class { static a() {} static set b(foo) {} static c() {} d() {} };" ,
1676 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1677 parserOptions
: { ecmaVersion
: 6 },
1679 { message
: "Getter is not present for class static setter 'b'." , type
: "MethodDefinition" , column
: 27 }
1683 code
: "class A { a() {} static get a() {} a() {} }" ,
1684 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1685 parserOptions
: { ecmaVersion
: 6 },
1687 { message
: "Setter is not present for class static getter 'a'." , type
: "MethodDefinition" , column
: 18 }
1691 code
: "class A { static set a(foo) {} static a() {} }" ,
1692 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1693 parserOptions
: { ecmaVersion
: 6 },
1695 { message
: "Getter is not present for class static setter 'a'." , type
: "MethodDefinition" , column
: 11 }
1699 // Full location tests
1701 code
: "class A { get a() {} };" ,
1702 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1703 parserOptions
: { ecmaVersion
: 6 },
1705 message
: "Setter is not present for class getter 'a'." ,
1706 type
: "MethodDefinition" ,
1714 code
: "A = class { \n set [ \n a](foo) {} };" ,
1715 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1716 parserOptions
: { ecmaVersion
: 6 },
1718 message
: "Getter is not present for class setter." ,
1719 type
: "MethodDefinition" ,
1727 code
: "class A { static get a() {} };" ,
1728 options
: [{ setWithoutGet
: true , getWithoutSet
: true , enforceForClassMembers
: true }],
1729 parserOptions
: { ecmaVersion
: 6 },
1731 message
: "Setter is not present for class static getter 'a'." ,
1732 type
: "MethodDefinition" ,