Rule proposal: no-useless-undefined

[fisker]

Fail

function foo() {
	return undefind;
}

let a = undefined;

call(undefined);

call(foo, bar, undefined);

const {foo = undefined} = {};

function foo({bar = undefined} = {}) {}

function foo(bar = undefined) {}

Pass

function foo() {
	return;
}

let a;

call();

call(foo, bar);
call(foo, bar,);

const {foo} = {};

function foo({bar} = {}) {}

function foo(bar) {}

Discussion #636 (comment)

Not sure about this,

const noop = () => undefined;

// prefer this?
const noop = () => {};

[sindresorhus]

// prefer this?
const noop = () => {};

Yes

[sindresorhus]

This is accepted.

[snowteamer]

I think this rule is a great idea, but how are we supposed to mark a formal parameter as optional if the following form is disallowed ?

function foo(bar = undefined) {
  if (typeof bar !== "undefined") {
    // Do something with 'bar'
  }
}

• Omitting the parameter declaration altogether does not seem to be an option since the function body will probably use it ;
• It is unclear to me wheather replacing = undefined with = void 0 is a good thing.

This information can of course be expressed in annotations, but I would prefer to be able to also keep it in the code.

[fisker]

We are not removing parameter bar

function foo(bar = undefined) {
  if (typeof bar !== "undefined") {
    // Do something with 'bar'
  }
}

To

function foo(bar) {
  if (typeof bar !== "undefined") {
    // Do something with 'bar'
  }
}

Is this breaking something?

[snowteamer]

It does not break anything per se, but it still removes the visual indication that the bar parameter is optional, which is the main reason why I sometimes use that form.

[fisker]

How about

function foo(bar /* optional */) {}

[snowteamer]

Yes this is an interesting solution, I might give it a try if nothing else changes - thank you for your time.

Although I am not sure about how to consistently enforce the presence and the exact formatting of this inline comment, as I currently do not know of any linter rule that does this.

[fisker]

Not sure which one better, but all seems clear

function foo(bar, baz /* optional */) {}

function foo(bar, /* optional */ baz) {}

[fisker]

reopen by accident.