Conditional typing for `this["key1"]` is not possible because neither branch will be executed

[Valerionn]

Bug Report

🔎 Search Terms

"this" key typing, conditional types on "this"

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about this

⏯ Playground Link

Playground link with relevant code

💻 Code

class Test {
  public key1: string = "abc";
  public doSomethingThis(): void {
    const wrongVariableOfTypeKey1: this["key1"] = 5; // ✔This should be a typing error and it is
    const correctVariableOfTypeKey1: this["key1"] = "string"; // ✔ This should not be a typing error and it's not

    type ConditionalThisType = this["key1"] extends string ? number : string;
    const a: ConditionalThisType = "string"; // ✔This should be a typing error and it is
    const b: ConditionalThisType = 5; // ❌This should NOT be a typing error BUT it is
    console.log(a, b);
  }

  public doSomethingThisClass(): void {
    type ConditionalClassType = Test["key1"] extends string ? number : string;
    const a: ConditionalClassType = "string"; // ✔ This should be a typing error and it is
    const b: ConditionalClassType = 5; // ✔ This should not be a typing error and it's not
    console.log(a, b);
  }
}

🙁 Actual behavior

this["key1"] extends string is neither true nor false and no path of the conditional type is returned. It's not possible to assign either a string or a number to a variable with the type.

🙂 Expected behavior

this["key1"] extends string should be true in the example above and therefore the first part of the conditional typing should get returned and the ConditionalThisType should be number. In all cases, it should be possible to assign at least either a string or a number because the documentation for conditional types states that either the first branch or the second branch will be returned:

When the type on the left of the extends is assignable to the one on the right, then you’ll get the type in the first branch (the “true” branch); otherwise you’ll get the type in the latter branch (the “false” branch).

[MartinJohns]

It's probably a design limitation, because conditional types are deferred when the type is not known, and this can also be a subclass.

Is there any reason to write code like this?

[Valerionn]

The reason for this is the following code (which should allow all public properties of this which are a string):

class Test {
  public key1: string = 'abc';
  public key2: string|null = null;

  public doSomething(): void {
    setSomething(this, 'key1'); // doesn't work because it will call `setSomething<this>`, and then `this['key1']` doesn't fulfill the `extends string` condition
  }
}

function setSomething<T>(a: T, b: KeysForTypeInContext<string, T>): void {

}

type KeysForTypeInContext<T, TContext> = {
  [key in keyof TContext]: TContext[key] extends T ? key : never;
}[keyof TContext];

If there is a different way of doing this (without having to specify the this-type by e.g. using public doSomething(this: Test): void), then I would be happy too :)

However, I found the Typescript behavior in this case very strange - but thanks for the hint that this could be a subclass which could in theory change the type. That explains the behavior at least

[RyanCavanaugh]

The sort of logic you want to represent here isn't possible today. See #48992

[KenjiTakahashi]

I'd like to chime in here, as I think I'm seeing a very similar problem. Except that it is not with this, but with a generic type.
I.e.

interface Ev<T> {
    e: T;
}

interface Test {
    finally: Ev<{status: "done"}>;
}

type Extends<T> = T extends Ev<infer E> ? number : string;

class C<T extends Test> {
    constructor() {
        const s1: Extends<T["finally"]> = "";
        const s2: Extends<T["finally"]> = 1;
    }
}

[Playground link]

The real life case is that interfaces Ev and Test come from a third party library, but I need to retrieve only the inside of the finally type.

Honestly, I find it a bit hard to grasp the concept of applying a ternary operator and getting neither of the branches evaluated. Wonder how that would work in "actual" language ;-)?