Contextual typing fails to throw error with function return type on left side of equals sign

[danbockapps]

TypeScript Version: I got the same behavior on 3.7.4 and 4.0.0-dev.20200601

Search Terms:
left side
right side
contextual typing
type inference

Code

interface ReportState {
  reportDefinition: {
    [key: number]: ReportDetails;
  };
}

interface ReportDetails {
  requiredNumber: number;
  columnWidths?: number[];
}

export const Report: (state: ReportState, action: any) => ReportState = (
  state,
  action
) => { // See note below about this line
  switch (action.type) {
    case "TYPE0": {
      const { reportDef, sequenceId } = action.payload;
      return {
        ...state,
        reportDefinition: {
          ...state.reportDefinition,
          [sequenceId]: {
            ...reportDef,
            selectedElements: ["0x0"],
          },
        },
      };
    }

    case "TYPE1": {
      return {
        ...state,
        reportDefinition: {
          ...state.reportDefinition,
          [action.payload.sequenceId]: {
            // requiredNumber is missing here. This should be an error.
            columnWidths: action.payload.columnWidths,
          },
        },
      };
    }

    default:
      return state;
  }
};

Expected behavior:
There should be an error, because requiredNumber is missing from the second return statement.

Actual behavior:
Compilation succeeds without error.

Curiosity 1:
If you add the return type on the right side of the =, i.e. by changing
) => {
to
): ReportState => {
, it correctly finds the error. This should not be necessary, because the return type is already specified on the left side of the =.

Curiosity 2:
If you remove the first case block, it correctly finds the error (which is in the second case block).

Playground Link: Click here

Related Issues:
No

[RyanCavanaugh]

@ahejlsberg any thoughts on a fix? Reduced:

interface ReportState {
    reportDefinition: {
        [key: number]: {
            a: number
        };
    };
}

const fn: () => ReportState = () => {
    if (Math.random() > 0.5) {
        return null as any as { reportDefinition: { [key: number]: any } };
    } else {
        return {
            reportDefinition: {
                // 'a' is missing, but no error
                0: { }
            }
        }
    }
}

[ahejlsberg]

Even simpler repro:

const fn2: () => number = () => {
    if (!!true) {
        return 5 as any;
    }
    else {
        return 'abc';
    }
}

This is technically working as intended. The return type is a union of each of the return expression types. Since one of them is any, the union reduces to any and no error is reported.

[danbockapps]

The original example doesn't have any as a return type, at least not explicitly. Is the first return type interpreted as an any?

[jgbpercy]

Hmm @ahejlsberg I'm not sure I understand how your example and @RyanCavanaugh 's are equivalent? If you remove the functions are just look at the assignability of the types without whatever return type inference stuff is going on, then Ryan's example yields an error (as I would expect) and yours doesn't (again as I would expect):

// --------------- RyanCavanaugh example:

interface ReportState {
    reportDefinition: {
        [key: number]: {
            a: number
        };
    };
}

declare const returnA: { reportDefinition: { [key: number]: any } };

const returnB = { reportDefinition: { 0: {} } };

declare const returnUnion1: typeof returnA | typeof returnB;

const return1Assigned: ReportState = returnUnion1; // <-- error here

// -------------- ahejlsberg example:

const returnC = 5 as any;

const returnD = 'abc';

declare const returnUnion2: typeof returnC | typeof returnD;

const return2Assigned: number = returnUnion2; // <-- no error here

Playground link

Given the assignment error in the "Ryan example" I would have expected the same in a function return context. Whereas with yours, while the behavior may not be ideal in a certain sense, I can see what's going on with the return type union and why that ultimately boils down to any and yields no error.