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 TS@2.6 a try.

[OliverJAsh]

Mohamed Hegazy (@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 typescript@2.6.1. can you share an updated repro?

[OliverJAsh]

Mohamed Hegazy (@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.