Members of mapped types are not contextually typed

[Igorbek]

TypeScript Version: 2.3.2, 2.4.1

Update: verified in 2.4.1, still not working

Code

declare function f<T>(obj: { [K in keyof T]: (arg: number) => T[K]; }): T;
const r = f({ a: x => x, b: y => 10 });

Expected behavior:
Type of r is { a: number, b: number}
Type of both x and y is number

Actual behavior:
Type of r is { a: numberany, b: number}
Type of both x and y is numberany

[DanielRosenwasser]

I wonder if this is related to #16817 as well.

[Igorbek]

@DanielRosenwasser I've checked with strictNullChecks true/false, as you pointed in #16817, and it seems it had no effect on result. So I think they're unrelated.
Update: still reproducible in 2.4.1

[sandersn]

Mapped types are also structured types who happen to have no members, and getContextualType calls getPropertyOfType which just looks members up by name and fails to find any.

I can imagine some special-case code in getPropertyOfType that returns a property for mapped types where the constraint type is keyof T, the type parameter is K, and the template type references T[K] somewhere. This then assumes that the expression that is being contextually typed by the mapped type will then provide a type inference to T. That could be true, but I don't think it's generally true.

[sandersn]

Actually, after looking at this for a while, I'm pretty sure that you want a return-type-of operator to make this work. Then instead of putting a mapped type as the parameter and trying to get the inference engine to construct the correct T for you by pulling together the disparate properties, you could return a mapped type instead:

declare function f<T extends { [s: string]: (arg: number) => any }>(obj: T): { [K in keyof T]: (arg: number) => return-typeof T[K] };
const r = f({ a: x => x, b: y => 10)

The parent issue for this operator seems to be #6606. A possible syntax for the thing that I wrote return-typeof T[K] is T[K](number).

[Igorbek]

@sandersn I truly want a return-type-of type operator and even more I want its generic form with #6606 but that is not what I want in this case though.

In my use case (you can find it here - styled-components/styled-components#837 (comment)), what I really need is to have a type where each member can be either a value or a factory for that value. Moreover, some of properties have known type, so I need to restrict the type to that known type. If I used return-type-of operator, I would invert the source of the type and it'd be hard to express the resulting type.

Let's look at simplified version of the method I tried to give type to.

// the source component has its own known props
declare const Component: StyledComponent<{ a: number; b: string; }>;

// the resulting component can be fed with known props and new props with values or factories
const ModifiedComponent = Component.attrs({ // attrs is the desired function
  a: 10, // I can provide a value
  a: "x", // should be error, invalid type
  a: () => 10, // I can provide a factory
  a: () => "x", // should be error, invalid return type
  // b skipped, it is not required to have them all
  c: "x", // I can introduce a fresh member with a value
  d: () => "x" // I can introduce a fresh member with a factory
}); // I need to know resulting type { a: number; c: string; d: string; }

// so the idea was (simplified :) )
interface StyledComponent<P> {
  attrs<
    A extends Partial<P> // captures result types of members and constraints to what we know
  >(
    attrs: {
      [K in keyof A]: (  // each member can be defined either
        (props: P) => A[K] // by a factory
      ) | A[K];  // or by a value
    }
  ): StyledComponent<P & A>; // need to extract types of members
}

// let's try to rewrite with return of
interface StyledComponent<P> {
  attrs<
    A extends { // captures result types of members and constraints to what we know
      [K in keyof P]?: ((props: P) => P[K]) | P[K];
    }
  >(
    attrs: A
  ): StyledComponent<P & TypesOf<A>>; // need to extract types of members
}
// uses #6606 to conditionally (distinguish values and factories) map types of members
type TypesOf<A> = {
  [K in keyof A]: typeof ((
    {
      <F extends (...args: any[]) => T>(fn: F): T;
      <T>(v: T): T;
    }
  )(A[K]));
}

Ok, it can be expressed with fully-loaded #6606 but it is not that simple.

I'd say it is still reasonable to have this issue fixed separately from #6606 as they're not really duplicates.