satisfies operator could not completely overshadow the existing contextual type #57667
Open
Description
🔍 Search Terms
satisfies contextual type implicit any parameters
✅ Viability Checklist
- 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, new syntax sugar for JS, etc.)
- This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals
⭐ Suggestion
It would be great if satisfies wouldn't completely disassociate the expression from the existing contextual type.
📃 Motivating Example
declare function fn<T extends Record<string, (arg: number) => void>>(
obj: T,
): void;
// this works without problems
fn({
foo: (a) => {},
bar: (a) => {},
});
// but we can't add extra constraints through `satisfies` without breaking existing contextual typing
fn({
foo: (a) => {}, // Parameter 'a' implicitly has an 'any' type.(7006)
bar: (a) => {}, // Parameter 'a' implicitly has an 'any' type.(7006)
} satisfies Record<"foo" | "bar", unknown>);💻 Use Cases
- What do you want to use this for?
It would be nice, at times, to add some extra constraints in places where the existing contextual type exists
- What shortcomings exist with current approaches?
satisfies breaks existing contextual typing so things like contextual parameters "break". It requires us to type the parameters manually or to introduce identity functions with those extra constraints like below
- What workarounds are you using in the meantime?
This is one of the possible workarounds:
declare function fn<T extends Record<string, (arg: number) => void>>(
obj: T,
): void;
declare function identityConstraint<T extends Record<"foo" | "bar", unknown>>(
arg: T,
): T;
fn(
identityConstraint({
foo: (a) => {},
bar: (a) => {},
}),
);However, this has an unintended side-effect: excess property check doesn't apply to this object now.
A similar shortcoming related to ThisType and satisfies combination has been recently reported here.
Activity