Наследование и подтипирование в TypeScript — ошибка?

Кажется, что «это функция, а не ошибка», как объясняется здесь:

https://github.com/microsoft/TypeScript/issues/22156

Мне очень грустно: значит, даже со всеми строгими флагами (strict, strictFunctionTypes) у вас может быть безошибочный код, который просто не работает из-за ошибки типа.

Чтобы TypeScript был действительно надежным или типобезопасным, ему нужно было бы контравариантно сравнивать все параметры функций и методов, чтобы переопределения методов могли только расширять, но не сужать типы параметров. (См. Разница между дисперсией, ковариацией, контравариантностью и бивариантностью в TypeScript для более подробного обсуждения дисперсии.)

Но TypeScript не совсем надежен и не предназначен; см. Дизайн TypeScript, не являющийся целью # 3, где говорится, что целью не является «применить надежную или «доказуемо правильную» систему типов», а фактическая цель состоит в том, чтобы «найти баланс между правильностью и производительностью».

В TypeScript параметры методов на самом деле сравниваются бивариантно , поэтому при переопределении методов можно как расширять, так и сужать типы параметров. Первоначально это было верно для всех типов функций, но введение параметра компилятора --strictFunctionTypes сделало строгими типы функций, не являющихся методами. Но независимо от того, включена эта опция или нет, параметры метода по-прежнему сравниваются бивариантно.

Это по нескольким причинам. Одна из причин заключается в том, что большинство разработчиков хотят рассматривать Array<T> как ковариантный в T, поэтому Array<Dog> также является Array<Animal>:

interface Animal { move(): void; }
interface Dog extends Animal { bark(): void; }
const dogs: Dog[] = [];
const animals: Animal[] = dogs; // okay
animals.forEach(a => a.move()); // okay

Это неправильно, потому что если вы push() a Cat на Array<Animal>, который на самом деле является псевдонимом Array<Dog>, вы что-то сломали:

interface Cat extends Animal { meow(): void; }
const cat: Cat = { move() { }, meow() { } };
animals.push(cat); // okay
dogs.forEach(d => d.bark()) // ERROR AT RUNTIME

Но такая несостоятельность уже является частью того, как TypeScript работает со свойствами. Свойства ковариантны, хотя вы можете писать в них, поэтому то же самое происходит и без массивов:

const dog: Dog = { move() { }, bark() { } };
const dogCage = { resident: dog };
const animalCage: { resident: Animal } = dogCage; // okay
animalCage.resident = cat; // switcharoo
dogCage.resident.bark(); // ERROR AT RUNTIME AGAIN

Таким образом, заставить методы быть правильными, когда свойства не являются чем-то вроде «слишком мало, слишком поздно» для системы типов. Можно было бы ужесточить ситуацию, заставив свойства быть инвариантными или разрешив ковариацию только для свойств readonly и т. д., но это оказывается очень раздражающим для подавляющего большинства случаев использования, когда люди поступают правильно.

Тем не менее, они рассматривали возможность применения этого для методов с --strictFunctionTypes. Но, к сожалению, согласно документации, «при разработке этой фичи мы обнаружили большое количество изначально небезопасных иерархий классов, в том числе и в DOM». Таким образом, некоторые существующие иерархии нативного JavaScript class нарушают это правило, и его принудительное применение поставит TypeScript в неблагоприятное положение, так или иначе аннулировав нативный JavaScript.

Вместо этого они приняли прагматичное решение оставить небезопасные переопределения методов, запретив при этом небезопасные автономные функции и типы функций обратного вызова.

Поэтому, если вам нужен обходной путь, вы можете реорганизовать свой код, чтобы использовать свойства с функциональным значением вместо методов, по крайней мере, синтаксически в ваших определениях типов. Например:

interface A {
    do: (x: number | string) => number;
}

class B implements A {
    do(x: number): number { // error!
        return x;
    }
}

Здесь я превратил A в interface, потому что вам не разрешено переопределять функциональное свойство class с помощью метода, даже если это abstract (см. microsoft/TypeScript#51261). Если вам нужно, чтобы родитель был классом, вы могли бы просто использовать свойства с функциональным значением вместо методов, хотя они меняются независимо от того, существуют ли они в экземплярах или прототипе:

abstract class A {
    abstract do: (x: number | string) => number;
}

class B extends A {
    override do = function (x: number) { // error            
        return x;
    }
}

Площадка ссылка на код