Disallow values of type 'symbol' from being passed to 'Number' function/constructor or 'String' constructor

Suggestion

Change the NumberConstructor and StringConstructor interfaces to disallow passing values of type Symbol. Currently it accepts values of type any.

Attempting to call Number(Symbol()), new Number(Symbol()), or new String(Symbol()) all throw TypeErrors at runtime.

Note: String(Symbol()) is fine - only new String(Symbol()) will throw.

Use Cases

Any time a value of type any is passed to Number, there is a risk of that value being a symbol and throwing a TypeError.

Object keys are explicitly allowed to be of type symbol (as number | string | symbol). Passing an arbitrary object key to Number can throw a TypeError as well.

Examples

Checking if a value can be coerced to a number

I just ran into this issue when checking if an object key could be a valid array index. The following should be an error as it will throw if value is of type symbol.

function keyCanBeArrayIndex(value: string | number | symbol): boolean {
  return !Number.isNaN(Number(value));
}

Having this be invalid would have forced me to write something like:

function canBeArrayIndex(value: string | number | symbol): boolean {
  try {
    return !Number.isNaN(Number(value));
  } catch {
    return false;
  }
}

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Start by locating the NumberConstructor and StringConstructor interface declarations in TypeScript's library definitions and review existing tests for constructor argument checking. Confirm the desired distinction between Number(Symbol()), new Number(Symbol()), String(Symbol()), and new String(Symbol()), then add coverage showing the intended compile-time diagnostics. Done means symbol values are rejected only where the issue specifies, without changing emitted JavaScript.