Make isTypeAssignableTo public on TypeChecker #56448

jakebailey · 2023-11-17T19:58:12Z

See:

This function has been exported on the checker since TypeScript 3.7. It's meaning has not changed in that time, and many people have begun depending on it.

ts-eslint doesn't use it as it's internal (as they're trying to do "the right thing"), but using it would fix many many lint bugs, and wouldn't require waiting for 5.4 (as stated above, it's been around since 3.7 and has seemingly worked the same).

We've previously been unhappy with exporting relation APIs because (1) we're free to add and remove relations at any time, (2) we're free to change relations, and (3) it's sometimes hard to document what they are.

But, assignability is assignability; it's unlikely that this relation is going to go away, and if we change its meaning, it's probably the case that dependents want that behavior change too to match the language. That and its pervasiveness has made it such that we probably can't remove it anyhow (as they say, "load-bearing").

So, this PR just exports it. This does not fully cover #9879, of course, but it seems worse to not do anything when we could just export this one well-defined function so many are already using unsafely.

cc @JoshuaKGoldberg

typescript-bot · 2023-11-17T19:58:28Z

Looks like you're introducing a change to the public API surface area. If this includes breaking changes, please document them on our wiki's API Breaking Changes page.

Also, please make sure @DanielRosenwasser and @RyanCavanaugh are aware of the changes, just as a heads up.

jakebailey · 2023-11-17T20:02:07Z

src/compiler/types.ts

@@ -5158,7 +5158,7 @@ export interface TypeChecker {
 /** @internal */ getPromiseLikeType(): Type;
 /** @internal */ getAsyncIterableType(): Type | undefined;

- /** @internal */ isTypeAssignableTo(source: Type, target: Type): boolean;
+ isTypeAssignableTo(source: Type, target: Type): boolean;


This needs a doc; please leave suggestions!

Thinking on what I'd want as a user, it's mostly just knowing what kind of caching I'd have to worry about (since that was brought up by TS folks previously) and examples of what direction the assignability runs in. Vaguely:

/** * Performs an assignability check, including using persistent caches. * @returns Whether `source` is assignable to `type`. * @example * ```ts * declare const literal: ts.Type; // Type of "abc" * declare const primitive: ts.Type; // Type of string * isTypeAssignableTo(literal, literal); // true * isTypeAssignableTo(literal, primitive); // true * isTypeAssignableTo(primitive, literal); // false * isTypeAssignableTo(primitive, primitive); // true * ```

Added something similar to the above.

JoshuaKGoldberg

YES! Thank you very much for getting this started!

bradzacher

One thing that might be important is the ability to resolve a type in the context of a file. For example most of our "promise checking" rules currently do really funky checks on the type to see if it has specific signatures.

The ability to do like "grab the global promise type and check if thing is assignable to that type" would vastly simplify our logic.

Similar for like Function (which I believe we shim right now via "has at least one call signature").

Error is another case we've used a few times where we do some shonky thing like "keep checking the inheritance chain until we find the last parent, ensure that parent is named error and it is in the TS lib file"

jakebailey · 2023-11-17T22:05:29Z

My impression from the recent thread was that this function was all that was needed to make everyone happy; is that incorrect such that we need to discuss this more?

bradzacher · 2023-11-18T00:24:33Z

This will definitely do for a huge chunk of new cases!
There's also our existing rules which... Approximate the API in some cases by manually pulling apart types and applying some heuristic.

If there's ways to fetch "common" types or construct new types based on common types then we could vastly simplify some existing rules.

jakebailey · 2023-11-18T00:30:25Z

#52473 added quite a few of these, but I am curious what else you're looking for.

bradzacher · 2023-11-18T01:08:55Z

The only thing missing would be the ability to get a type from the globals, I think. Or less generally - some of the more "spec standard" types like Promise.
Really getPromiseType would be the biggest one for us and would help us out given how many promise rules we have.

As an example the no-floating-promise rule and no-misused-promises rule rules have their own logic (some of which is based off ts-api-utils.isThenable) to vaguely determine if a type is a promise. They are mostly correct - but it's a few hundred lines of code that could generally be reduced to checker.isTypeAssignableTo(type, anyPromise).

jakebailey · 2023-11-18T01:29:44Z

This isn't a public method (yet), but theoretically you could use getAwaitedType; if it returns something different than the input, then the input has a promise.

fatcerberus · 2023-11-18T02:36:32Z

But, assignability is assignability; it's unlikely that this relation is going to go away

Given that assignability is the basic primitive the type system is built on (conditional types check assignability, generic constraints are based on assignability, A & B means the set of values assignable to both, heck even parameter contravariance is just assignability with the polarity reversed!), I'd be very surprised if it went away without, you know, rearchitecting the whole language from scratch. Which I guess is what is meant by "load-bearing"

jakebailey · 2023-11-18T02:51:12Z

Which I guess is what is meant by "load-bearing"

In this instance, I meant that we couldn't remove the function without breaking the ecosystem, even though it's not public.

nickserv · 2023-11-18T03:52:58Z

@jakebailey The GitHub search in your original comment has non-JavaScript files, try this:

https://github.com/search?q=%2F%5C.isTypeAssignableTo%2F+%28language%3AJavaScript+OR+language%3ATypeScript%29&type=code

bradzacher

jakebailey · 2023-11-18T19:05:02Z

This isn't a public method (yet), but theoretically you could use getAwaitedType; if it returns something different than the input, then the input has a promise.

I have not tried to stick this into your codebase, but testing on ts-ast-viewer.com shows that it seems to work:

> function containsPromise(type) { return type !== checker.getAwaitedType(type) }
< undefined
> [checker.typeToString(type), containsPromise(type)]
< (2) ['number', false]
> [checker.typeToString(type), containsPromise(type)]
< (2) ['number | undefined', false]
> [checker.typeToString(type), containsPromise(type)]
< (2) ['Promise<number>', true]
> [checker.typeToString(type), containsPromise(type)]
< (2) ['Promise<number> | Promise<string> | Promise<boolea…| string[]> | Promise<bigint | Promise<number[]>>', true]

A single equality check is almost surely better than 100 lines of code!

I actually would have thought people would have already used getAwaitedType externally, but apparently not. I only see it used in our codefixes. I know a few people have asked for that one already on the Discord.

EDIT: this is not totally accurate; for non-promise Thenables, this method returns undefined, so that's another special case.

sandersn

One thing: it still might need some discussion of caching.

jakebailey · 2023-11-27T19:58:01Z

One thing: it still might need some discussion of caching.

My general feeling is that because we don't provide any mechanism to create new types (only those derived from actual code), that the cache sizes would be bounded.

sandersn · 2023-11-27T22:08:19Z

Were there specific concerns we brought up in discord? I don't remember.

jakebailey · 2023-11-27T23:28:58Z

I don't recall any, besides what I mentioned in the thread here (then went back on once I realized that you couldn't just make random types and overflow the cache).

sandersn · 2023-11-28T21:29:26Z

jakebailey · 2023-12-07T19:45:59Z

Alrighty, if there are no more objections, I'm going to merge this one in.

JoshuaKGoldberg · 2023-12-11T15:49:23Z

SlurpTheo · 2024-01-26T14:06:46Z

src/compiler/types.ts

@@ -5158,7 +5158,20 @@ export interface TypeChecker {
 /** @internal */ getPromiseLikeType(): Type;
 /** @internal */ getAsyncIterableType(): Type | undefined;

- /** @internal */ isTypeAssignableTo(source: Type, target: Type): boolean;
+ /**
+ * Returns true if the "source" type is assignable to the "target" type.


Suggested change

* Returns true if the "source" type is assignable to the "target" type.

* Returns true if the `source` type is assignable to the `target` type.

Export isTypeAssignableTo on TypeChecker

335cea4

jakebailey requested review from DanielRosenwasser, weswigham, ahejlsberg and RyanCavanaugh November 17, 2023 19:58

typescript-bot assigned jakebailey Nov 17, 2023

typescript-bot added Author: Team For Uncommitted Bug PR for untriaged, rejected, closed or missing bug labels Nov 17, 2023

jakebailey commented Nov 17, 2023

View reviewed changes

JoshuaKGoldberg reviewed Nov 17, 2023

View reviewed changes

bradzacher reviewed Nov 17, 2023

View reviewed changes

Add some sort of docstring

1ef7d15

bradzacher reviewed Nov 18, 2023

View reviewed changes

sandersn approved these changes Nov 27, 2023

View reviewed changes

sandersn mentioned this pull request Dec 5, 2023

Add noUnnecessaryTypeAssertions compiler option, quickfix #51527

Closed

andrewbranch approved these changes Dec 5, 2023

View reviewed changes

Merge branch 'main' into export-isTypeAssignableTo

7ad4e52

jakebailey merged commit 14da488 into microsoft:main Dec 8, 2023
19 checks passed

jakebailey deleted the export-isTypeAssignableTo branch December 8, 2023 21:16

jakebailey mentioned this pull request Dec 8, 2023

Proposal: Type Relationship API #9879

Open

voxpelli mentioned this pull request Dec 9, 2023

Add references to possible discussions about upstreaming this tsdjs/typescript#1

Open

JoshuaKGoldberg mentioned this pull request Dec 19, 2023

Feature: add a new assertion that uses assignability checking JoshuaKGoldberg/eslint-plugin-expect-type#18

Closed

c0sta pushed a commit to c0sta/TypeScript that referenced this pull request Dec 20, 2023

Make isTypeAssignableTo public on TypeChecker (microsoft#56448)

c5afb4d

DanielRosenwasser mentioned this pull request Jan 4, 2024

TypeScript 5.4 Iteration Plan #56948

Closed

jasikpark mentioned this pull request Jan 4, 2024

Proposal: Add IsAssignable Utility Type MichiganTypeScript/type-testing#3

Open

jakebailey mentioned this pull request Jan 5, 2024

Expose getUnknownType #56826

Draft

devversion mentioned this pull request Jan 17, 2024

fix(compiler-cli): interpolatedSignalNotInvoked diagnostic for input signals angular/angular#53883

Closed

14 tasks

SlurpTheo reviewed Jan 26, 2024

View reviewed changes

kirkwaiblinger mentioned this pull request May 16, 2024

Bug: [no-unnecessary-boolean-literal-compare] False positive and unsafe fix with exactOptionalPropertyTypes typescript-eslint/typescript-eslint#9105

Closed

4 tasks

controversial mentioned this pull request Jul 23, 2024

Rule proposal: no-unsafe-type-assertion typescript-eslint/typescript-eslint#7173

Open

6 tasks

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Make isTypeAssignableTo public on TypeChecker #56448

Make isTypeAssignableTo public on TypeChecker #56448

jakebailey commented Nov 17, 2023 •

edited

Loading

typescript-bot commented Nov 17, 2023

jakebailey Nov 17, 2023

JoshuaKGoldberg Nov 17, 2023

This comment was marked as resolved.

This comment was marked as resolved.

jakebailey Nov 17, 2023

JoshuaKGoldberg left a comment

bradzacher left a comment

jakebailey commented Nov 17, 2023

bradzacher commented Nov 18, 2023

jakebailey commented Nov 18, 2023

bradzacher commented Nov 18, 2023

jakebailey commented Nov 18, 2023 •

edited

Loading

fatcerberus commented Nov 18, 2023

jakebailey commented Nov 18, 2023

nickserv commented Nov 18, 2023 •

edited

Loading

bradzacher left a comment

jakebailey commented Nov 18, 2023 •

edited

Loading

sandersn left a comment

jakebailey commented Nov 27, 2023

sandersn commented Nov 27, 2023

jakebailey commented Nov 27, 2023

sandersn commented Nov 28, 2023

jakebailey commented Dec 7, 2023

JoshuaKGoldberg commented Dec 11, 2023

SlurpTheo Jan 26, 2024

	* Returns true if the "source" type is assignable to the "target" type.
	* Returns true if the `source` type is assignable to the `target` type.

Make isTypeAssignableTo public on TypeChecker #56448

Make isTypeAssignableTo public on TypeChecker #56448

Conversation

jakebailey commented Nov 17, 2023 • edited Loading

typescript-bot commented Nov 17, 2023

jakebailey Nov 17, 2023

Choose a reason for hiding this comment

JoshuaKGoldberg Nov 17, 2023

Choose a reason for hiding this comment

This comment was marked as resolved.

This comment was marked as resolved.

jakebailey Nov 17, 2023

Choose a reason for hiding this comment

JoshuaKGoldberg left a comment

Choose a reason for hiding this comment

bradzacher left a comment

Choose a reason for hiding this comment

jakebailey commented Nov 17, 2023

bradzacher commented Nov 18, 2023

jakebailey commented Nov 18, 2023

bradzacher commented Nov 18, 2023

jakebailey commented Nov 18, 2023 • edited Loading

fatcerberus commented Nov 18, 2023

jakebailey commented Nov 18, 2023

nickserv commented Nov 18, 2023 • edited Loading

bradzacher left a comment

Choose a reason for hiding this comment

jakebailey commented Nov 18, 2023 • edited Loading

sandersn left a comment

Choose a reason for hiding this comment

jakebailey commented Nov 27, 2023

sandersn commented Nov 27, 2023

jakebailey commented Nov 27, 2023

sandersn commented Nov 28, 2023

jakebailey commented Dec 7, 2023

JoshuaKGoldberg commented Dec 11, 2023

SlurpTheo Jan 26, 2024

Choose a reason for hiding this comment

jakebailey commented Nov 17, 2023 •

edited

Loading

jakebailey commented Nov 18, 2023 •

edited

Loading

nickserv commented Nov 18, 2023 •

edited

Loading

jakebailey commented Nov 18, 2023 •

edited

Loading