Allow usage of `Reflect.get()` by returning `unknown` instead of `any`

Search Terms

Reflect get unknown

Suggestion

Change the type definition of Reflect.get() to return unknown instead of any.

Use Cases

Allow type safe dynamic access of fields on an object or { [k: string}: unknown }

Using Reflect.get(o, 'some key') and have it return unknown.

This allows usage of Reflect.get() in code bases where we do not want implicit any and where we have @typescript-eslint rules to ban unsafe usage of any.

Examples

/**
 * @param {CustomError} cause
 * @returns {{ [k: string]: unknown }}
 */
function getInfoForPlainError (cause) {
  /** @type {{ [k: string]: unknown }} */
  const info = {}
  for (const field of PLAIN_ERROR_FIELDS) {
    const v = reflectGet(cause, field)
    if (typeof v !== 'undefined') {
      info[field] = v
    }
  }
  return info
}

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.

Unfortunately changing a signature from any to unknown is a breaking change.

Start by locating the lib.d.ts declaration for Reflect.get and the tests covering its inferred return type. Check how changing any to unknown affects existing type-checking expectations; done means the declaration and relevant tests consistently support the requested return type.