TypeScriptにおける配列の共変性

type Animal = {
  animal: string;
};

type Dog = {
  animal: string;
  dog: string;
};

const animal: Animal = {
  animal: "string",
};

const dog: Dog = {
  animal: "string",
  dog: "string",
};

// できる
const animalVariable: Animal = dog;

const dogArray: Dog[] = [dog];

// これはできる？
const animalArray: Animal[] = dogArray;

interface Array<T> {
  /**
   * Gets or sets the length of the array. This is a number one higher than the highest index in the array.
   */
  length: number;
  /**
   * Returns a string representation of an array.
   */
  toString(): string;
  /**
   * Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
   */
  toLocaleString(): string;
  // ...
}

  /**
   * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
   * @param searchElement The value to locate in the array.
   * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
   */
  indexOf(searchElement: T, fromIndex?: number): number;

(searchElement: Dog, fromIndex?: number): number

<:

(searchElement: Animal, fromIndex?: number): number

const dogArray: Dog[] = [dog];

// dogArrayのindexOfを独自の関数に置き換える
dogArray.indexOf = (dog: Dog) => {
  // Dog型の値を受け取り，Animal型にはないプロパティをわざと触る
  dog.dog.charAt(0);
  // 適当に返す
  return -1;
};
// 以上の置き換え自体は問題ない
// dogArray.indexOfでDogの入力を期待することは正当

// 問題はこの行．dogArrayをanimalArrayに代入できるなら……
const animalArray: Animal[] = dogArray;

// そのあと例のindexOfにanimalを渡せてしまう
animalArray.indexOf(animal);

$ npx tsc
$ # パス

$ node index.js
/home/sititou70/ts-array-variant/index.js:11
    dog.dog.charAt(0);
            ^

TypeError: Cannot read properties of undefined (reading 'charAt')
    at dogArray.indexOf (/home/sititou70/ts-array-variant/index.js:11:13)
    at Object.<anonymous> (/home/sititou70/ts-array-variant/index.js:15:13)
    at Module._compile (node:internal/modules/cjs/loader:1159:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1213:10)
    at Module.load (node:internal/modules/cjs/loader:1037:32)
    at Module._load (node:internal/modules/cjs/loader:878:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
    at node:internal/main/run_main_module:23:47

interface MyArray1<T> {
  indexOf(elem: T): number;
}

interface MyArray2<T> {
  indexOf: (elem: T) => number;
}

// これはできる
const myDogArray1: MyArray1<Dog> = [dog];
const myAnimalArray1: MyArray1<Animal> = myDogArray1;

// これは型エラー
const myDogArray2: MyArray2<Dog> = [dog];
const myAnimalArray2: MyArray2<Animal> = myDogArray2;
//    ^^^^^^^^^^^^^^
// 型 'MyArray2<Dog>' を型 'MyArray2<Animal>' に割り当てることはできません。
//   プロパティ 'dog' は型 'Animal' にありませんが、型 'Dog' では必須です。ts(2322)

interface Array<T> {
  /**
   * Gets or sets the length of the array. This is a number one higher than the highest index in the array.
   */
  length: number;
  /**
   * Returns a string representation of an array.
   */
  toString(): string;
  /**
   * Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
   */
  toLocaleString(): string;
  // ...
}

  /**
   * Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
   * @param searchElement The value to locate in the array.
   * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
   */
-  indexOf(searchElement: T, fromIndex?: number): number;
+  indexOf: (searchElement: T, fromIndex?: number) => number;

$ npx tsc
$ # パス？？？

/**
 * Checks if 'source' is related to 'target' (e.g.: is a assignable to).
 * @param source The left-hand-side of the relation.
 * @param target The right-hand-side of the relation.
 * @param relation The relation considered. One of 'identityRelation', 'subtypeRelation', 'assignableRelation', or 'comparableRelation'.
 * Used as both to determine which checks are performed and as a cache of previously computed results.
 * @param errorNode The suggested node upon which all errors will be reported, if defined. This may or may not be the actual node used.
 * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used.
 * @param containingMessageChain A chain of errors to prepend any new errors found.
 * @param errorOutputContainer Return the diagnostic. Do not log if 'skipLogging' is truthy.
 */
function checkTypeRelatedTo(
  source: Type,
  target: Type,
  relation: Map<string, RelationComparisonResult>,
  errorNode: Node | undefined,
  headMessage?: DiagnosticMessage,
  containingMessageChain?: () => DiagnosticMessageChain | undefined,
  errorOutputContainer?: { errors?: Diagnostic[]; skipLogging?: boolean }
): boolean {

// ただし今回のケースに関係のない部分を一部省略しています
// ダンプ：source === Array<Dog>
// ダンプ：target === Array<Animal>
if (
  getObjectFlags(source) & ObjectFlags.Reference &&
  getObjectFlags(target) & ObjectFlags.Reference &&
  (source as TypeReference).target === (target as TypeReference).target &&
  !isTupleType(source) &&
  !(isMarkerType(source) || isMarkerType(target))
) {
  // We have type references to the same generic type, and the type references are not marker
  // type references (which are intended by be compared structurally). Obtain the variance
  // information for the type parameters and relate the type arguments accordingly.
  // 訳すと：
  //   同じジェネリクス型に対する2つの型があり，（Array<Dog>とArray<Animal>，今回はどちらもArrayに対する型）
  //   それらはマーカータイプではなく（？　わからん）
  //   構造的に比較されることを意図しています
  //   型パラメタの引数に対する変性の情報を計算し（たぶんArray<T>のTの変性を計算するということ）
  //   それによって型引数を関連付けます（なるほど？）

  // getVariancesが，さっき言っていた「Array<T>のTの変性を計算する」やつと思われる
  // ダンプ：(source as TypeReference).target === Array
  const variances = getVariances((source as TypeReference).target);
  // ダンプ：variances === [VarianceFlags.Covariant]
  // これはおそらくArrayの1つ目の型パラメタTが共変であることを表している

  // relateVariancesは，[Dog]と[Animal]の関係を[VarianceFlags.Covariant]で検査すると思われる
  // したがって結局Dog <: Animalが検査される（共変）
  const varianceResult = relateVariances(
    getTypeArguments(source as TypeReference), // ダンプ：getTypeArguments(sourge) === [Dog]
    getTypeArguments(target as TypeReference), // ダンプ：getTypeArguments(target) === [Animal]
    variances, // [VarianceFlags.Covariant]
    intersectionState // なぞ．たぶん今回関係なし
  );
  if (varianceResult !== undefined) {
    return varianceResult;
  }
}

function getVariances(type: GenericType): VarianceFlags[] {
  // Arrays and tuples are known to be covariant, no need to spend time computing this.
  return type === globalArrayType ||
    type === globalReadonlyArrayType ||
    type.objectFlags & ObjectFlags.Tuple
    ? arrayVariances
    : getVariancesWorker(type.symbol, type.typeParameters);
}

// ここでarrayVariancesは
const arrayVariances = [VarianceFlags.Covariant];

function getVariances(type) {
- return type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & 8 ?
+ return false ?
    arrayVariances :
    getVariancesWorker(type.symbol, type.typeParameters);
}

$ npx tsc
index.ts:20:7 - error TS2322: Type 'Dog[]' is not assignable to type 'Animal[]'.
  Types of property 'indexOf' are incompatible.
    Type '(searchElement: Dog, fromIndex?: number | undefined) => number' is not assignable to type '(searchElement: Animal, fromIndex?: number | undefined) => number'.
      Types of parameters 'searchElement' and 'searchElement' are incompatible.
        Type 'Animal' is not assignable to type 'Dog'.

20 const animalArray: Animal[] = dogArray;
         ~~~~~~~~~~~


Found 1 error in index.ts:20

// @flow

type Animal = // ...省略...
type Dog = // ...省略...

const animal = // ...省略...
const dog = // ...省略...

const dogArray: Dog[] = [dog];
const animalArray: Animal[] = dogArray;

$ npx flow --version
Flow, a static type checker for JavaScript, version 0.195.1
$ npx flow check
Error ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ index.js:22:31

Cannot assign dogArray to animalArray because property dog is missing in Animal [1] but exists in Dog [2] in array
element. [prop-missing]

     19│ };
     20│
 [2] 21│ const dogArray: Dog[] = [dog];
 [1] 22│ const animalArray: Animal[] = dogArray;
     23│



Found 1 error

class Animal {}
class Dog extends Animal {}

class Main {
  public static void main(String[] args) {
    Animal animalArray[] = new Dog[1];
    animalArray[0] = new Animal();
  }
}

$ java --version
openjdk 17.0.5 2022-10-18
OpenJDK Runtime Environment Temurin-17.0.5+8 (build 17.0.5+8)
OpenJDK 64-Bit Server VM Temurin-17.0.5+8 (build 17.0.5+8, mixed mode, sharing)
$ javac main.java
$ # 型検査をパスするが
$ java Main
Exception in thread "main" java.lang.ArrayStoreException: Animal
        at Main.main(main.java:7)
$ # ランタイムエラーになる