当函数的参数是具有所述方法的对象时，为什么 Typescript 不能推断方法调用，该方法的输入是对象的属性？

Question

Why isn't Typescript smart enough to figure out that the example below can't have an error in practice:

interface M1 {
  props: {
    color: 'red' | 'blue';
    transparency: 0 | 1;
  },
  f: (props: M1['props']) => string
}

interface M2 {
  props: {
    age: number;
    country: string;
  },
  f: (props: M2['props']) => string
} 

const myFunc = (param: M1 | M2) => {
  return param.f(param.props)
}

myFunc 's parameter will either be M1 or M2, but not both; so whichever it is, when you call param.f(params.props) , you know that params.props is of the same type as the input of param.f .

Is this logic incorrect or why can't TS infer this?

Answer 1

One way to work around that limitation would be to create a superinterface M , and define the method on M using a polymorphic this type :

interface M { 
  props: { [name: string]: any };
  f: (props: this['props']) => string;
}

interface M1 extends M {
  props: {
    color: 'red' | 'blue';
    transparency: 0 | 1;
  }
}

interface M2 extends M {
  props: {
    age: number;
    country: string;
  }
} 

const myFunc = (param: M) => {
  return param.f(param.props);
}