Repository: TypeScript
Issue: Consider disallowing `in` operator use with arbitrary key operands on closed types for which the keys are known
Labels: Suggestion,Awaiting More Feedback

### 🔍 Search Terms

`in` operator, type guard, known property/props, closed type, rename property

### ✅ Viability Checklist

- [X] This wouldn't be a breaking change in existing TypeScript/JavaScript code
- [X] This wouldn't change the runtime behavior of existing JavaScript code
- [X] This could be implemented without emitting different JS based on the types of the expressions
- [X] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
- [X] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- [X] This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

### ⭐ Suggestion

The `in` operator serves as a type guard against record types: https://github.com/Microsoft/TypeScript/issues/10485

As it is implemented, it allows checking for the presence of arbitrary keys on an object.

The suggestion would be to disallow using the `in` operator with key names that not one of the known keys in the object's type. This would prevent developer errors where the key for which the presence is checked is not one of the keys that was explicitly declared to the type system, and might for example contain a typo.

```ts
declare const foo: { someProp: number }

if ('a' in foo) { // type error: Property 'a' does not exist on type '{ someProp: number; }'.
  ...
}
```

This could be guarded behind a compiler option, so as to not introduce a breaking change.

Of course, the `in` operator has a wide range of uses, especially for type guarding property accesses on objects of completely unknown types, so these should be preserved:

```ts
declare const foo: unknown
declare const bar: Record<string, number>
declare const baz: { someProp: number; [k in string]: number }

 // in allowed against unknown, any, and other "open" record types or types with an index signature
if ('a' in foo || 'a' in bar || 'a' in baz) {
  ...
}
```

For cases where the original type of the variable was not permissive enough, but the programmer knows better, we can allow checking for the presence of the key with an explicit cast:

```ts
const foo = { someProp: 123, a: 'hello' }
const bar: { someProp: number } = foo

if ('a' in bar as unknown) { // valid, with the explicit cast
  bar // type is inferred the same as currently
  // ^? { someProp: number } & { a: unknown; } 
}
```

### 📃 Motivating Example

Currently, I can write a valid program to discriminate a union:

```ts
type Puppy = {
  color: string
}

declare const foo: Puppy | { someProp: string }

if ('color' in foo) {
  console.log(foo.color)
}
```

Now, let's say my British colleague has a pass at the code, renaming variable names to UK English:

```ts
type Puppy = {
  colour: string // change made
}

declare const foo: Puppy | { someProp: string }

// elsewhere in the program
if ('color' in foo) { // change forgotten
  console.log(foo.color)
}
```

the program remains valid, yet TypeScript is unable to provide any indication that the change had consequences.

With the proposed feature:

```ts
type Puppy = {
  colour: string // change made
}

declare const foo: Puppy | { someProp: number }

// elsewhere in the program
if ('color' in foo) { // type error: Property 'color' does not exist on type 'Puppy | { someProp: number; }'.
  console.log(foo.color)
}

if ('color' in foo as unknown) { // valid, with the explicit cast
  console.log(foo.color)
}
```

### 💻 Use Cases

1. What do you want to use this for?
Preventing developer errors (typos), allowing for safe property renames.

2. What shortcomings exist with current approaches?
Does not warn of checks for presence of properties which are unknown to the type system (to allow for checking of properties not represented in the type system). This is especially evident when using the operator to discriminate a union, as the `in` operator key operand is always intended to be a known property in such cases.

5. What workarounds are you using in the meantime?
https://stackoverflow.com/questions/70670913/type-safe-in-type-guard