Possible regression in 3.1: destructured parameter is not recognized if it comes from intersection type

[fictitious]

TypeScript Version: 3.2.0-dev.20181011

Search Terms: destructuring inference parameters intersection

Code

type MethodBase = { p: {}, needsPrep: 'yes' | 'no', prepArgs: {} };
type Methods = { [m in string]: MethodBase };

interface OptionsForMethodTypes<M extends MethodBase> {
    'yes': { prep: (args: { p: M['p'] } & M['prepArgs']) => void };
    'no': { };
}
type OptionsForMethod<M extends MethodBase> = OptionsForMethodTypes<M>[M['needsPrep']];

type Callers<MM extends Methods> = { [m in keyof MM]: (p: MM[m]['p']) => void };

type Options<MM extends Methods> = { [m in keyof MM]?: OptionsForMethod<MM[m]> };

declare function createCallers<MM extends Methods>(methods: MM, options?: Options<MM>): Callers<MM>;

const someMethods = {
    a: {} as { p: string, needsPrep: 'yes', prepArgs: {foo: number} },
    b: {} as { p: number, needsPrep: 'no', prepArgs: {} }
}

const c = createCallers(someMethods, {
    a: { prep: ({ p, foo }) => { } },

  // ERROR:  Type '{ p: unknown; }' has no property 'foo' and no string index signature.
  // at the same time, correct type for foo is shown in the same tooltip:
  // var foo: number
});

Expected behavior:

No error. This code compiles without errors in 3.0.1

Actual behavior:

ERROR: Type '{ p: unknown; }' has no property 'foo' and no string index signature.

Playground Link: link

Related Issues:

did not find anything

Here's a simplified repro that I think is the same issue:

type MethodNameToArgs = { [m: string]: {} };

function f<M extends MethodNameToArgs>(o: { [K in keyof M]: (args: M[K]) => void }): void {}

interface MyMethods extends MethodNameToArgs {
    a: { x: number };
}

f<MyMethods>({
    a(args) {},
});

args is correctly of type { x: number }, but there's a compile error under --strictFunctionTypes:

src/a.ts:9:14 - error TS2345: Argument of type '{ a(args: { x: number; }): void; }' is not assignable to parameter of type '{ [x: string]: (args: {}) => void; a: (args: { x: number; }) => void; }'.
  Property 'a' is incompatible with index signature.
    Type '(args: { x: number; }) => void' is not assignable to type '(args: {}) => void'.
      Types of parameters 'args' and 'args' are incompatible.
        Type '{}' is not assignable to type '{ x: number; }'.
          Property 'x' is missing in type '{}'.

 9 f<MyMethods>({
                ~
10     a(args) {},
   ~~~~~~~~~~~~~~~
11 });

Works if I remove MethodNameToArgs, but in a more complex situation like the original issue that might not be doable.

I get get rid of the index signature, but there's another error.

type MethodBase = { p: {}, needsPrep: 'yes' | 'no', prepArgs: {} };
interface OptionsForMethodTypes<M extends MethodBase> {
    'yes': { prep: (args: M['prepArgs']) => void };
    'no': { };
}
type OptionsForMethod<M extends MethodBase> = OptionsForMethodTypes<M>[M['needsPrep']];

type Callers<K extends string, MM extends Record<K, MethodBase>> = { [m in keyof MM]: (p: MM[m]['p']) => void };

type Options<K extends string, MM extends Record<K, MethodBase>> = { [m in keyof MM]?: OptionsForMethod<MM[m]> };

declare function createCallers<K extends string, MM extends Record<K, MethodBase>>(methods: MM, options?: Options<K, MM>): Callers<K, MM>;

const someMethods = {
    a: {} as { p: string, needsPrep: 'yes', prepArgs: {foo: number} },
    b: {} as { p: number, needsPrep: 'no', prepArgs: {} }
}

const c = createCallers(someMethods, {
    a: {
        prep(args) {
            args;
        }
    },
});

Gives an error Parameter 'args' implicitly has an 'any' type., but when I hover over prep it shows the correct type for that.

[fictitious]

@Andy-MS FWIW Parameter 'args' implicitly has an 'any' type error is present in both 3.0 and 3.1, unlike the original error

[fictitious]

The workaround is as usual, to use currying or builder pattern. Contextual typing in the second argument based on type inferred from the first argument has a tendency to be unreliable.

type MethodBase = { p: {}, needsPrep: 'yes' | 'no', prepArgs: {} };
type Methods = { [m in string]: MethodBase };

interface OptionsForMethodTypes<M extends MethodBase> {
    'yes': { prep: (args: { p: M['p'] } & M['prepArgs']) => void };
    'no': { };
}
type OptionsForMethod<M extends MethodBase> = OptionsForMethodTypes<M>[M['needsPrep']];

type Callers<MM extends Methods> = { [m in keyof MM]: (p: MM[m]['p']) => void };

type Options<MM extends Methods> = { [m in keyof MM]?: OptionsForMethod<MM[m]> };

interface CallersBuilder<MM extends Methods> {
    options(o: Options<MM>): CallersBuilder<MM>;
    get(): Callers<MM>;
}

declare function create2<MM extends Methods>(methods: MM): CallersBuilder<MM>;

const someMethods = {
    a: {} as { p: string, needsPrep: 'yes', prepArgs: {foo: number} },
    b: {} as { p: number, needsPrep: 'no', prepArgs: {} }
}

const c2 = create2(someMethods)
    .options({
        a: { prep: ({ p, foo }) => { } }, // ok
    })
    .get()
;

[DanielRosenwasser]

Seems like @Andy-MS's minimal repro ought to work.

[ahejlsberg]

The real issue here is that we display inconsistent types in quick info pop-ups for foo depending on which source element you hover over first. For example, if you first hover over the createCallers identifier in the call expression and then hover over the foo parameter, you'll see type any. But if, after making some edit to the source to dispose of the cached type checker results, you first hover over the foo parameter, you'll see type number.

In reality, in a complete type check of the source file (such as is used by the command-line compiler or the error lists in the IDE), foo is always given type any, as demonstrated by the fact that you get no errors for this (whether using 3.0 or 3.2):

const c = createCallers(someMethods, {
    a: { prep: ({ p, foo }) => { foo.doesNotExist } },  // <== No error!
});

So, in 3.0 you were getting a silent any where in 3.2 at least you get an error. But the thing we should fix is the inconsistent hover results.