Property type is not narrowed for readonly object in some contexts

[OliverJAsh]

TypeScript Version: 2.4.1 and 2.6.0-rc

Code

{
    type User = { name: string };
    const logUser = (_user: User) => {};

    type State = {
        user: User | undefined;
    };

    const fn = function<Own extends {}>(p: Readonly<Own & State>) {
        const { user } = p;
        if (user !== undefined) {
            // Unexpected error: Type 'undefined' is not assignable to type 'User'
            // `user` should be narrowed to exclude `undefined` here.
            logUser(user);
        }
    };
}

//
// KNOWN WORKAROUNDS
//

{
    type User = { name: string };
    const logUser = (_user: User) => {};

    type State = {
        user: User | undefined;
    };

    const fn = function<Own extends {}>(p: Own & State) {
        const { user } = p;
        if (user !== undefined) {
            // No error when `Readonly` is dropped
            logUser(user);
        }
    };
}

{
    type User = { name: string };
    const logUser = (_user: User) => {};

    type State = {
        user: User | undefined;
    };

    const fn = function<Own extends {}>(p: Readonly<Own & State>) {
        const user: User | undefined = p.user;
        if (user !== undefined) {
            // No error when `user` is manually annotated
            logUser(user);
        }
    };
}

{
    type User = { name: string };
    const logUser = (_user: User) => {};

    type State = {
        user: User | undefined;
    };

    type Own = {};
    type P = Readonly<Own & State>
    const p = {} as any as P;

    const { user } = p;
    if (user !== undefined) {
        // No error if origin of `p` value and `Own` type is not from function
        logUser(user);
    }
}

Expected behavior:
(See comments in code.)

[mhegazy]

Seems to not produce errors in latest. can you give [email protected] a try.

[OliverJAsh]

@mhegazy Yup, it is fixed for 2.6.1-insiders.20171019.

[OliverJAsh]

I am still reproduce this on 2.6.1. Is it supposed to be fixed on that version?

[mhegazy]

I am not seeing any errors on [email protected]. can you share an updated repro?

[OliverJAsh]

@mhegazy

declare class Maybe<A> {
    static of<A>(value: A | undefined): Maybe<A>;
    map<B>(f: (a: A) => B): Maybe<B>;
}

{
    type User = { name: string };
    const logUser = (_user: User) => {};

    type State = {
        user: User | undefined;
    };

    const fn = function<Own extends {}>(p: Readonly<Own & State>) {
        const { user } = p;

        Maybe.of(user).map(
            user =>
                // Unexpected error: Object is possibly 'undefined'.
                user.name,
        );
    };
}

[mhegazy]

in this example user is a generic variable. it's type is (Own & { user: User | undefined; })["user"]. this will not be narrowed with the use of Maybe.of which relies on inference picking the | undefined form the type. I think what you are looking for here is #14366

[OliverJAsh]

I think what you are looking for here is #14366

Would this fix the above example so the correct types would be inferred, or would I still have to workaround this by annotating user?

[mhegazy]

depending on how it is implemented. but yes it would.