Contextual typing not working on optional members

[DanielRosenwasser]

The following sample works perfectly in noImplicitAny unless I turn on strictNullChecks. In that event, the s parameter on foo seems to get an implicit any.

interface ActionsObject<State> {
    [prop: string]: (state: State) => State
}

interface Options<State, Actions> {
    state?: State;
    view?: (state: State, actions: Actions) => any;
    actions?: Actions;
}

declare function app<State, Actions extends ActionsObject<State>>(obj: Options<State, Actions>): void;

app({
    state: 100,
    actions: {
        foo: s => s
    },
    view: (s, a) => null as any,
})

If I make actions non-optional, then things work perfectly again.

Context: jorgebucaran/hyperapp#87

[weswigham]

This isn't strictNullChecks specific (though it's much easier to trigger the bug there); we're failing to produce parameter inferences for any parameter within an index within a union:

    interface ActionsObject<State> {
        [prop: string]: (state: State) => State;
    }
    
    interface Options<State, Actions> {
        state?: State;
        view?: (state: State, actions: Actions) => any;
        actions: string | Actions;
    }
    
    declare function app<State, Actions extends ActionsObject<State>>(obj: Options<State, Actions>): void;
    
    app({
        state: 100,
        actions: {
            foo: s => s
                 ~
!!! error TS7006: Parameter 's' implicitly has an 'any' type.
        },
        view: (s, a) => undefined as any,
    });

[ahejlsberg]

This is working as intended. The actions property of the object literal is contextually typed by a type parameter type Actions, and during the inference process we don't yet know what the type argument for Actions will be (and constraints don't factor into type inference). I suggest rewriting the example to:

interface ActionsObject<State> {
    [prop: string]: (state: State) => State
}

interface Options<State> {
    state?: State;
    actions?: ActionsObject<State>;
}

declare function app<State>(obj: Options<State>): void;

app({
    state: 100,
    actions: {
        foo: s => s
    },
})

If it is really important to capture the actual type of the object literal, it can be done with an intersection type:

interface ActionsObject<State> {
    [prop: string]: (state: State) => State
}

interface Options<State> {
    state?: State;
    actions?: ActionsObject<State>;
}

declare function app<State, Actions>(obj: Options<State> & Actions): void;

app({
    state: 100,
    actions: {
        foo: s => s
    },
})

(I omitted the view property to reduce noise.)

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.

[weswigham]

This issue is tagged incorrectly and we have a fix up, it's pretty simple. We actually do contextually type the nonunion case right (the generic's constraint is the contextual type), so it is, in fact, a bug that a union is not appropriately contextually typed. The issue is that when we get the apparent type of a contextual type, we didn't get the apparent type of all union members - we just returned the union.