Compile does not produce an error when parameters in overriding class method in child class have narrower type than the parameters of this method in the parent class #58122

// The code below is compiled without error even with --strictFunctionTypes
// although it produces an error while being executed

interface I {
    a: number;
}

interface J extends I {
    b: string;
}

class A {
    public m(x: I): number {
        return x.a;
    };
}

class B extends A {

    // This overrides method "m" in class "A".
    // Such override must be forbidden,
    // because it narrows down the parameter type of method "m" compared to parent class,
    // which causes an error when object of class "B" is used instead of object of class "A".
    public m(x: J): number {
        return x.a + x.b.length;
    };
}

function f(x: A): number {
    const p: I = {a: 1};
    return x.m(p);
}

const b: B = new B();

// Function "f" accepts argument of class "B" also because "B" is a subclass of "A",
// but it produces "Cannot read properties of undefined (reading 'length')"
const x: number = f(b);

// The code below has compilation error with --strictFunctionTypes
// and has no compilation error without --strictFunctionTypes
// This is expected behaviour.
//
// Error witht --strictFunctionTypes:
// Property 'm' in type 'B' is not assignable to the same property in base type 'A'.
//   Type '(x: J) => number' is not assignable to type '(x: I) => number'.
//     Types of parameters 'x' and 'x' are incompatible.
//       Property 'b' is missing in type 'I' but required in type 'J'.

interface I {
    a: number;
}

interface J extends I {
    b: string;
}

class A {
    public m = (x: I) => {
        return x.a;
    };
}

class B extends A {
    public m = (x: J) => { // <-- here is a compilation error
        return x.a + x.b.length;
    };
}