Type constraint checked fail when class mapped type defined by own member key

[Bacra]

Bug Report

🔎 Search Terms

class mapped type

🕗 Version & Regression Information

4.8.0-dev.20220615

⏯ Playground Link

Playground link with relevant code

💻 Code

const SubKeys = ['key1', 'key2'] as const

abstract class SubClass {
  public readonly Keys: typeof SubKeys = SubKeys
  setValue(obj: { [x in this['Keys'][number]]: number }) {
    console.log(obj)
  }
  setValue2(obj: { [x in typeof SubKeys[number]]: number }) {
    console.log(obj)
  }
}

abstract class MainClass<T extends SubClass> {
  protected abstract SubClass: { new(): T }
  protected get subInterface(): T {
    return new this.SubClass()
  }
}

abstract class MainClassError<T extends SubClass> extends MainClass<T> {
  protected setValue() {
    this.subInterface.setValue({
      //  ❌ check fail
      // Argument of type '{ key1: number; key2: number; }' is not assignable to parameter of type '{ [x in T["Keys"][number]]: number; }'.
      // Object literal may only specify known properties, and 'key1' does not exist in type '{ [x in T["Keys"][number]]: number; }'.
      key1: 1,
      key2: 2,
    })

    this.subInterface.setValue2({
      // ✔️ check success
      key1: 1,
      key2: 2,
    })
  }
}

abstract class MainClassOK extends MainClass<SubClass> {
  protected setValue() {
    this.subInterface.setValue({
      // ✔️ check success
      key1: 1,
      key2: 2,
    })

    this.subInterface.setValue2({
      // ✔️ check success
      key1: 1,
      key2: 2,
    })
  }
}

🙁 Actual behavior

Func setValue of MainClassError check failed when the param defined by class member key.

🙂 Expected behavior

[RyanCavanaugh]

Issuing an excess property error here is misleading since there's no literal value you can write here at all that would satisfy. The error should just be a top-level error on the expression indicating something more general about this value not being assignable to the target.

[Bacra]

abstract class MainClassOK extends MainClass<SubClass> {
  protected setValue() {
    this.subInterface.setValue({
      // ✔️ check success
      key1: 1,
      key2: 2,
    })

    this.subInterface.setValue2({
      // ✔️ check success
      key1: 1,
      key2: 2,
    })
  }
}

MainClassOK is OK when not used mapped type for class.

Scenes to be used (MainClassOK not satisfied):

abstract class SubClassB extends SubClass {}
abstract class MainClassErrorB<T extends SubClassB> extends MainClassError<T> {}