property in generic conditional type not narrowed in nested conditional type

[DetachHead]

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

4.5.0-dev.20210930

⏯ Playground Link

Playground link with relevant code

💻 Code

interface Foo {
  foo: string|undefined
}

type Str<T extends string> = T

type Bar<T> = 
  T extends Foo
    ? T['foo'] extends string
      // Type 'T["foo"]' does not satisfy the constraint 'string'.
      //  Type 'string | undefined' is not assignable to type 'string'.
      //   Type 'undefined' is not assignable to type 'string'.(2344)
      ? Str<T['foo']>
      : never
    :never

🙁 Actual behavior

T['foo'] is not being narrowed to string

🙂 Expected behavior

T['foo'] is narrowed to string

[craigphicks]

@DetachHead
I agree it is not a correct compiler response.

However, if there are other paths that lead to the target, will that suffice?

E.g., if the redundant Str<...> is omitted it seems to work:

interface Foo {
  foo: string|undefined
}
// type Str<T extends string> = T
type Bar<T> = 
  T extends Foo
    ? T['foo'] extends string 
      ? T['foo']
      : "never1"
    :"never2"

const bar1:Bar<{foo:string}>="1";
const bar2:Bar<{foo:"1"}>="1";

type BarX1 = Bar<{}>; // type BarX1 = "never1"
type BarX2 = Bar<{foo:undefined}>; // type BarX2 = "never2"

Also, the output of Bar can be passed to Str as follows:

type Str<T extends string> = T

type Bar1<T> = 
  T extends Foo
    ? T['foo'] extends string 
      ? T['foo']
      : never
    :never


const str1:Str<Bar1<{foo:string}>>="1";
const str2:Str<Bar1<{foo:"1"}>>="1";

type StrX1 = Str<Bar1<{}>>; // type StrX1 = never
type StrX2 = Str<Bar1<{foo:undefined}> // type StrX2 = never

playground

Maybe your point is worth solving even if there are other paths to the target.
Or Maybe you simplified a bigger problem for posting and so the above isn't applicable to that bigger problem.

So please just consider this post to be lateral thoughts.

[DetachHead]

Or Maybe you simplified a bigger problem for posting and so the above isn't applicable to that bigger problem.

Yeah, here it is if you're curious https://github.com/DetachHead/typetime-json-schema/blob/master/src/index.ts#L45

[craigphicks]

As far a workaround goes you might try to manually extract the narrowed type:

interface Foo  {
  foo: string|undefined
};
type Str<T extends string> = T

// manually removing `undefined` from T['foo'] works
type Bar1<T> = 
  T extends Foo
    ? T['foo'] extends string 
      ?Str<Extract<T['foo'],string>>    // Extract
      : never
    :never

const str1:Str<Bar1<{foo:string}>>="1";
const str2:Str<Bar1<{foo:"1"}>>="1";
type BarX1 = Bar1<{}>; // type BarX1 = never
type BarX2 = Bar1<{foo:undefined}>; // type BarX2 = never

playground

But again, that's just a lateral comment. It doesn't deprecate the severity of your point.

[craigphicks]

Out of curiosity, I tried setting 'exactOptionalPropertyTypes' to true in TS Config and redefining Foo's foo property to be optional:

// exactOptionalPropertyTypes is set to true in TS Config
type Foo = {
  foo?: string
};
type Str<T extends string> = T

type Bar<T> = 
  T extends Foo
    ? T['foo'] extends string 
      // Type 'T["foo"]' does not satisfy the constraint 'string'.
      //  Type 'string | undefined' is not assignable to type 'string'.
      //   Type 'undefined' is not assignable to type 'string'.(2344)
      ?Str<T['foo']>
      : never
    :never

playground
The Error is still there. In this case it seems that 'undefined` got forcibly added at some point, because it wasn't there to begin with.

[andrewbranch]

I think this is a duplicate of #45651. I’m going to mark it that way and add this as an additional test when addressing that one.

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.