eslint/tests/lib/rules/no-useless-call.js

   1 /**
   2  * @fileoverview Tests for no-useless-call rule.
   3  * @author Toru Nagashima
   4  */
   5
   6 "use strict";
   7
   8 //------------------------------------------------------------------------------
   9 // Requirements
  10 //------------------------------------------------------------------------------
  11
  12 const rule = require("../../../lib/rules/no-useless-call");
  13 const { RuleTester } = require("../../../lib/rule-tester");
  14
  15 //------------------------------------------------------------------------------
  16 // Tests
  17 //------------------------------------------------------------------------------
  18
  19 const ruleTester = new RuleTester();
  20
  21 ruleTester.run("no-useless-call", rule, {
  22     valid: [
  23
  24         // `this` binding is different.
  25         "foo.apply(obj, 1, 2);",
  26         "obj.foo.apply(null, 1, 2);",
  27         "obj.foo.apply(otherObj, 1, 2);",
  28         "a.b(x, y).c.foo.apply(a.b(x, z).c, 1, 2);",
  29         "foo.apply(obj, [1, 2]);",
  30         "obj.foo.apply(null, [1, 2]);",
  31         "obj.foo.apply(otherObj, [1, 2]);",
  32         "a.b(x, y).c.foo.apply(a.b(x, z).c, [1, 2]);",
  33         "a.b.foo.apply(a.b.c, [1, 2]);",
  34
  35         // ignores variadic.
  36         "foo.apply(null, args);",
  37         "obj.foo.apply(obj, args);",
  38
  39         // ignores computed property.
  40         "var call; foo[call](null, 1, 2);",
  41         "var apply; foo[apply](null, [1, 2]);",
  42
  43         // ignores incomplete things.
  44         "foo.call();",
  45         "obj.foo.call();",
  46         "foo.apply();",
  47         "obj.foo.apply();",
  48
  49         // Optional chaining
  50         {
  51             code: "obj?.foo.bar.call(obj.foo, 1, 2);",
  52             parserOptions: { ecmaVersion: 2020 }
  53         },
  54
  55         // Private members
  56         {
  57             code: "class C { #call; wrap(foo) { foo.#call(undefined, 1, 2); } }",
  58             parserOptions: { ecmaVersion: 2022 }
  59         }
  60     ],
  61     invalid: [
  62
  63         // call.
  64         {
  65             code: "foo.call(undefined, 1, 2);",
  66             errors: [{
  67                 messageId: "unnecessaryCall",
  68                 data: { name: "call" },
  69                 type: "CallExpression"
  70             }]
  71         },
  72         {
  73             code: "foo.call(void 0, 1, 2);",
  74             errors: [{
  75                 messageId: "unnecessaryCall",
  76                 data: { name: "call" },
  77                 type: "CallExpression"
  78             }]
  79         },
  80         {
  81             code: "foo.call(null, 1, 2);",
  82             errors: [{
  83                 messageId: "unnecessaryCall",
  84                 data: { name: "call" },
  85                 type: "CallExpression"
  86             }]
  87         },
  88         {
  89             code: "obj.foo.call(obj, 1, 2);",
  90             errors: [{
  91                 messageId: "unnecessaryCall",
  92                 data: { name: "call" },
  93                 type: "CallExpression"
  94             }]
  95         },
  96         {
  97             code: "a.b.c.foo.call(a.b.c, 1, 2);",
  98             errors: [{
  99                 messageId: "unnecessaryCall",
 100                 data: { name: "call" },
 101                 type: "CallExpression"
 102             }]
 103         },
 104         {
 105             code: "a.b(x, y).c.foo.call(a.b(x, y).c, 1, 2);",
 106             errors: [{
 107                 messageId: "unnecessaryCall",
 108                 data: { name: "call" },
 109                 type: "CallExpression"
 110             }]
 111         },
 112
 113         // apply.
 114         {
 115             code: "foo.apply(undefined, [1, 2]);",
 116             errors: [{
 117                 messageId: "unnecessaryCall",
 118                 data: { name: "apply" },
 119                 type: "CallExpression"
 120             }]
 121         },
 122         {
 123             code: "foo.apply(void 0, [1, 2]);",
 124             errors: [{
 125                 messageId: "unnecessaryCall",
 126                 data: { name: "apply" },
 127                 type: "CallExpression"
 128             }]
 129         },
 130         {
 131             code: "foo.apply(null, [1, 2]);",
 132             errors: [{
 133                 messageId: "unnecessaryCall",
 134                 data: { name: "apply" },
 135                 type: "CallExpression"
 136             }]
 137         },
 138         {
 139             code: "obj.foo.apply(obj, [1, 2]);",
 140             errors: [{
 141                 messageId: "unnecessaryCall",
 142                 data: { name: "apply" },
 143                 type: "CallExpression"
 144             }]
 145         },
 146         {
 147             code: "a.b.c.foo.apply(a.b.c, [1, 2]);",
 148             errors: [{
 149                 messageId: "unnecessaryCall",
 150                 data: { name: "apply" },
 151                 type: "CallExpression"
 152             }]
 153         },
 154         {
 155             code: "a.b(x, y).c.foo.apply(a.b(x, y).c, [1, 2]);",
 156             errors: [{
 157                 messageId: "unnecessaryCall",
 158                 data: { name: "apply" },
 159                 type: "CallExpression"
 160             }]
 161         },
 162         {
 163             code: "[].concat.apply([ ], [1, 2]);",
 164             errors: [{
 165                 messageId: "unnecessaryCall",
 166                 data: { name: "apply" },
 167                 type: "CallExpression"
 168             }]
 169         },
 170         {
 171             code: "[].concat.apply([\n/*empty*/\n], [1, 2]);",
 172             errors: [{
 173                 messageId: "unnecessaryCall",
 174                 data: { name: "apply" },
 175                 type: "CallExpression"
 176             }]
 177         },
 178         {
 179             code: "abc.get(\"foo\", 0).concat.apply(abc . get(\"foo\",  0 ), [1, 2]);",
 180             errors: [{
 181                 messageId: "unnecessaryCall",
 182                 data: { name: "apply" },
 183                 type: "CallExpression"
 184             }]
 185         },
 186
 187         // Optional chaining
 188         {
 189             code: "foo.call?.(undefined, 1, 2);",
 190             parserOptions: { ecmaVersion: 2020 },
 191             errors: [{ messageId: "unnecessaryCall", data: { name: "call" } }]
 192         },
 193         {
 194             code: "foo?.call(undefined, 1, 2);",
 195             parserOptions: { ecmaVersion: 2020 },
 196             errors: [{ messageId: "unnecessaryCall", data: { name: "call" } }]
 197         },
 198         {
 199             code: "(foo?.call)(undefined, 1, 2);",
 200             parserOptions: { ecmaVersion: 2020 },
 201             errors: [{ messageId: "unnecessaryCall", data: { name: "call" } }]
 202         },
 203         {
 204             code: "obj.foo.call?.(obj, 1, 2);",
 205             parserOptions: { ecmaVersion: 2020 },
 206             errors: [{
 207                 messageId: "unnecessaryCall",
 208                 data: { name: "call" },
 209                 type: "CallExpression"
 210             }]
 211         },
 212         {
 213             code: "obj?.foo.call(obj, 1, 2);",
 214             parserOptions: { ecmaVersion: 2020 },
 215             errors: [{
 216                 messageId: "unnecessaryCall",
 217                 data: { name: "call" },
 218                 type: "CallExpression"
 219             }]
 220         },
 221         {
 222             code: "(obj?.foo).call(obj, 1, 2);",
 223             parserOptions: { ecmaVersion: 2020 },
 224             errors: [{
 225                 messageId: "unnecessaryCall",
 226                 data: { name: "call" },
 227                 type: "CallExpression"
 228             }]
 229         },
 230         {
 231             code: "(obj?.foo.call)(obj, 1, 2);",
 232             parserOptions: { ecmaVersion: 2020 },
 233             errors: [{
 234                 messageId: "unnecessaryCall",
 235                 data: { name: "call" },
 236                 type: "CallExpression"
 237             }]
 238         },
 239         {
 240             code: "obj?.foo.bar.call(obj?.foo, 1, 2);",
 241             parserOptions: { ecmaVersion: 2020 },
 242             errors: [{
 243                 messageId: "unnecessaryCall",
 244                 data: { name: "call" },
 245                 type: "CallExpression"
 246             }]
 247         },
 248         {
 249             code: "(obj?.foo).bar.call(obj?.foo, 1, 2);",
 250             parserOptions: { ecmaVersion: 2020 },
 251             errors: [{
 252                 messageId: "unnecessaryCall",
 253                 data: { name: "call" },
 254                 type: "CallExpression"
 255             }]
 256         },
 257         {
 258             code: "obj.foo?.bar.call(obj.foo, 1, 2);",
 259             parserOptions: { ecmaVersion: 2020 },
 260             errors: [{
 261                 messageId: "unnecessaryCall",
 262                 data: { name: "call" },
 263                 type: "CallExpression"
 264             }]
 265         }
 266     ]
 267 });