Regression: Covariance fails in latest TS release?

[nicojs]

TypeScript Version: 3.3.0-dev.20190125

Search Terms:
covariance

Code

type Injector<TContext> = {
  resolve: <T extends keyof TContext>() => T extends keyof TContext ? TContext[T] : never;
}

const foo: Injector<{ foo: string, bar: string }> = {} as any;
const bar: Injector<{ bar: string }> = foo; // no error
console.log(bar);

Expected behavior:
No compiler error with --strictFunctionTypes. As was the case in TS 3.2.2

Actual behavior:
Compiler error (since TS 3.2.4)

index.ts:18:7 - error TS2322: Type 'Injector<{ foo: string; bar: string; }>' is not assignable to type 'Injector<{ bar: string; }>'.
  Property 'foo' is missing in type '{ bar: string; }' but required in type '{ foo: string; bar: string; }'.

18 const bar: Injector<{ bar: string }> = foo;
         ~~~

  index.ts:17:23
    17 const foo: Injector<{ foo: string, bar: string }> = {} as any;
                             ~~~
    'foo' is declared here.

Playground Link:
https://www.typescriptlang.org/play/index.html#src=type%20Injector%3CTContext%3E%20%3D%20%7B%0D%0A%20%20resolve%3A%20%3CT%20extends%20keyof%20TContext%3E()%20%3D%3E%20T%20extends%20keyof%20TContext%20%3F%20TContext%5BT%5D%20%3A%20never%3B%0D%0A%7D%0D%0A%0D%0Aconst%20foo%3A%20Injector%3C%7B%20foo%3A%20string%2C%20bar%3A%20string%20%7D%3E%20%3D%20%7B%7D%20as%20any%3B%0D%0Aconst%20bar%3A%20Injector%3C%7B%20bar%3A%20string%20%7D%3E%20%3D%20foo%3B%20%2F%2F%20no%20error%0D%0Aconsole.log(bar)%3B

Related Issues:

(maybe): #28752

[nicojs]

It might work as intended, but I'm not sure why Injector<TContext> wouldn't be covariant in TContext. If anyone can point that out to me, I would be very grateful.

You can also look at typed-inject. I've added a test for covariance. Running it with ts 3.2.2 works fine, 3.2.4 (or 3.3.0-rc) gives the error.

[fatcerberus]

I think, but not positive, that type parameters are (supposed to be) completely invariant in TS. There is an open proposal to add co- and contravariance annotations a la C#, see #10717, but AFAICT nothing has been implemented yet.

[nicojs]

I don't think that's true. See this comment by @ahejlsberg #10717 (comment)

[jack-williams]

Smaller repro?

interface Injector<TContext> {
  resolve: TContext[keyof TContext];
}

const foo: Injector<{ foo: string, bar: string }> = {} as any;
const bar: Injector<{ bar: string }> = foo;
console.log(bar);

[nicojs]

@jack-williams I don't think that's a reproduction of my issue. Your code example already gave a compile error in [email protected] (just tested it). However, it might indicate that it my example also should have been a compile error in [email protected].

[jack-williams]

Ooops, sorry --- got carried away deleting code! What about this?

interface Injector<TContext> {
  resolve: <T extends keyof TContext>() => T extends keyof TContext ? TContext[T] : never;
}

const foo: Injector<{ foo: string, bar: string }> = {} as any;
const bar: Injector<{ bar: string }> = foo;
console.log(bar);

There have been a few recent changes to conditional types; it may the be the case that one of those have affected this.

Seems to work for type aliases, but not interfaces:

type Injector<TContext> = {
  resolve: <T extends keyof TContext>() => T extends keyof TContext ? TContext[T] : never;
}

const foo: Injector<{ foo: string, bar: string }> = {} as any;
const bar: Injector<{ bar: string }> = foo; // no error
console.log(bar);

[nicojs]

@jack-williams
exactly! I'll update my original post. Thanks.

Seems to work for type aliases, but not interfaces:

Do you think this was an unintended side effect? Or is there a reason for this change?

[ahejlsberg]

This is basically a design limitation.

In --strictFunctionTypes mode we compute a variance digest for type parameters of classes and interfaces up front and use that when relating instantiations, whereas we always perform a structural comparison for object type literals (see #18654 for more discussion of the details). Our variance digest is sometimes too conservative and that's causing the issue here. Specifically, given a type parameter T and a type parameter U extends T, T[keyof T] is neither a supertype nor a subtype of U[keyof U]. Therefore a class or interface that uses this construct on a particular type parameter will be considered invariant in that type parameter. This misses the subtlety that T[keyof T] and U[keyof U] are sometimes covariant, e.g. when extra properties in U all have types that already exist as types of properties in T. The only way to "see" that is to always perform a full structural comparison, but we don't want to do that for classes and interfaces as the performance regressions are rather draconian.

[nicojs]

Ok. I'm assuming that the fact that it didn't report errors in 3.2.2 was a bug, and it now works as intended. Closing because it is a design limitation.

Given a type parameter T and a type parameter U extends T, T[keyof T] is neither a supertype nor a subtype of U[keyof U].

Got it, thanks for replying!