TypeUtils.ts — react Source File

Source Code

import {GeneratedSource} from '../HIR';
import {assertExhaustive} from '../Utils/utils';
import {unsupportedLanguageFeature} from './TypeErrors';
import {
  ConcreteType,
  ResolvedType,
  TypeParameter,
  TypeParameterId,
  DEBUG,
  printConcrete,
  printType,
} from './Types';

export function substitute(
  type: ConcreteType<ResolvedType>,
  typeParameters: Array<TypeParameter<ResolvedType>>,
  typeArguments: Array<ResolvedType>,
): ResolvedType {
  const substMap = new Map<TypeParameterId, ResolvedType>();
  for (let i = 0; i < typeParameters.length; i++) {
    // TODO: Length checks to make sure type params match up with args
    const typeParameter = typeParameters[i];
    const typeArgument = typeArguments[i];
    substMap.set(typeParameter.id, typeArgument);
  }
  const substitutionFunction = (t: ResolvedType): ResolvedType => {
    // TODO: We really want a stateful mapper or visitor here so that we can model nested polymorphic types
    if (t.type.kind === 'Generic' && substMap.has(t.type.id)) {
      const substitutedType = substMap.get(t.type.id)!;
      return substitutedType;
    }

    return {
      kind: 'Concrete',
      type: mapType(substitutionFunction, t.type),
      platform: t.platform,
    };
  };

  const substituted = mapType(substitutionFunction, type);

  if (DEBUG) {
    let substs = '';
    for (let i = 0; i < typeParameters.length; i++) {
      const typeParameter = typeParameters[i];
      const typeArgument = typeArguments[i];
      substs += `[${typeParameter.name}${typeParameter.id} := ${printType(typeArgument)}]`;
    }
    console.log(
      `${printConcrete(type, printType)}${substs} = ${printConcrete(substituted, printType)}`,
    );
  }

  return {kind: 'Concrete', type: substituted, platform: /* TODO */ 'shared'};
}

export function mapType<T, U>(
  f: (t: T) => U,
  type: ConcreteType<T>,
): ConcreteType<U> {
// ... (253 more lines)