Rule request: no-useless-builtin-calls

Please describe what the rule should do:

The rule would prevent users from creating an Object of an object, a Number if a number, a Boolean of a boolean, etc.

Note that:

• no-new-object will not block code like Object({a:1}) (without the new)
• no-restricted-globals could work with a custom list of Boolean, Object, Number and String but it would block code like a instanceof String.

What category of rule is this? (place an “X” next to just one item)

[ ] Enforces code style [ ] Warns about a potential error [X] Suggests an alternate way of doing something [ ] Other (please specify:)

Provide 2-3 code examples that this rule will warn about:

const alreadyAnObject = new Object({a: 1});
const alreadyABoolean = new Boolean(true);
const alreadyAString = new String('hello world');
const alreadyANumber = new Number(12);

Why should this rule be included in ESLint (instead of a plugin)?

The 4 examples I gave are literally useless. What I propose is an improvement of no-new-object, but more powerful and with a needed renaming.

[kaicataldo]

Thinking about this some more, I’m not sure combining no-new-object and no-new-wrappers is the best course here, since we also have no-array-constructor. They all do slightly different things to deal with the pitfalls of their respective types, and I think it might be best to leave them as is (though we should maybe consider naming them in such a way that it’s obvious they’re related).

Putting the discussion to combine no-new-object and no-new-wrappers aside for a moment, disallowing unnecessary typecasting seems like a fundamentally different problem than what the no-new-wrappers rule is trying to solve (preventing unnecessary type coercion of a value vs. preventing creating wrappers objects rather than primitive values).

That being said, that does seem like a useful rule - maybe something like no-useless-coercion? The rule would disallow type coercion with the following function calls if the argument is already of that type:

Object({a: 1});
Boolean(true);
String('hello world');
Number(12);

TL;DR: Maybe we should leave the current type constructor function rules alone and create a new rule that disallows unnecessary type coercion.

Thoughts?

[kaicataldo]

I’m curious why we have both no-new-object and no-new-wrappers. Seems like this could all be one rule.