Repository: TypeScript
Issue: Remove key from object after `delete object.key`
Labels: Suggestion,Awaiting More Feedback

# Suggestion
## 🔍 Search Terms
delete
delete key
narrowing
narrowing delete

## ✅ Viability Checklist

<!--
   Suggestions that don't meet all these criteria are very, very unlikely to be accepted.
   We always recommend reviewing the TypeScript design goals before investing time writing
   a proposal for ideas outside the scope of the project.
-->
My suggestion meets these guidelines:

* [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 feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).


## ⭐ Suggestion
In TypeScript, it's already possible to have objects add keys to their types using `if ("key" in object) // object: { key: unknown }`. It is not currently possible to do the exact opposite: deleting a key off of an object.

This could be achieved in two ways:
- Guaranteed: `type { key: string }; delete object.key; type { }`.
- Optional: `type { key?: string | undefined }; if (object.key === undefined) delete object.key; type { key?: string }`.

The guaranteed way is pretty straight forward: it removes the key entirely.
The optional way is slightly more tricky: it should only remove the type information checked in the if statement. Remaining type options should still exist after the if statement. If the last remaining type option is removed, then it should function the same as the guaranteed way.

Naturally, if the key didn't exist on the object in the first place, the type information should remain the exact same as before.

## 📃 Motivating Example

I'm using the zod library, with which I set a value on object user as `{ givenName: string; infix?: string | undefined; surname: string; }`.
I wrote a factory function `toUser({ givenName, infix, surname }: { givenName: string; infix?: string; surname: string; }): User { ... }`.
The type `infix?: string | undefined` is not compatible with type `infix?: string`.
![image](https://user-images.githubusercontent.com/123112608/230669575-c7d6c602-5fd0-4092-bda8-610c9c50f3ae.png)

--- EDIT: Extra example ---
After executing `delete object.key`, I'm expecting the type information to no longer contain this key:
```
  const myObject: { key1?: string | undefined, key2?: string | undefined } = { ... };
  delete myObject.key1; // Type should now become: { key2?: string | undefined}
  myObject.key1 // Should error, key was deleted
```

Now, if I want to remove a key under certain conditions:
```
  const myObject: { key1?: string | number | undefined } = { ... };
  if (typeof myObject.key1 === "number") delete myObject.key1; // Removes "number" from types. This already works.
  if (typeof myObject.key1 === "undefined") delete myObject.key1; // Removes "undefined" from type definition. This does not work yet.
  if (typeof myObject.key1 === "string") delete myObject.key1; // Removes the last type; "key1" will no longer exist on object.
```

In the above example, the native types "number" and "string" get stripped off as expected. The type "undefined" however, does not. This breaks the tsconfig option exactOptionalPropertyTypes as the key should now no longer be able to exist. It cannot exist with literal value `undefined`.

## 💻 Use Cases

<!--
  What do you want to use this for?
  What shortcomings exist with current approaches?
  What workarounds are you using in the meantime?
-->

This is purely type information, but it seems essential if the typing system is to remain correct after the `delete` keyword. 
For the time being, I'll have to set the type to `infix?: string | undefined`, knowing it's not entirely accurate (key "infix" should not be permitted with value "undefined").