Rule proposal: `prefer-immediate-return`

In my opinion it’s never desirable to assign a value to a variable, only to be returned immediately. I believe this is often the leftover result of debugging.

In other words, if a value is declared, and returned immediately in the next statement, the two should be merged, removing the useless variable.

Fail

// A
function foo() {
  const result = bar();
  return result;
}

// B
function foo() {
  let result;
  return result;
}

Pass

function foo() {
  const result = bar();
  // Anything in between is allowed.
  console.log(result);
  return result;
}

function foo() {
  let result;
  result = bar();
  return result;
}

// Autofix result for A
function foo() {
  return bar();
}

// Autofix result for B
function foo() {
  return;
}

[remcohaszing]

This rule would also play nice with no-return-await. Currently an intermediate variable could be used to circumvent this rule.

async function foo() {
  const value = await bar();
  return value;
}

Becomes (because of prefer-immediate-return):

async function foo() {
  return await bar();
}

Which then becomes (because of no-return-await):

async function foo() {
  return bar();
}

[fregante]

@fisker Why not a fan? It seems reasonable. When would that code be preferable?