FlowTypeEnv Class — react Architecture

Source Code

compiler/packages/babel-plugin-react-compiler/src/Flood/Types.ts lines 695–808

export class FlowTypeEnv implements ITypeEnv {
  moduleEnv: Map<string, ResolvedType> = new Map();
  #nextNominalId: number = 0;
  #nextTypeParameterId: number = 0;

  #types: Map<IdentifierId, ResolvedType> = new Map();
  #bindings: Map<t.Identifier, ResolvedType> = new Map();
  #generics: Array<[string, TypeParameter<ResolvedType>]> = [];
  #flowTypes: Map<string, ResolvedType> = new Map();

  init(env: Environment, source: string): void {
    // TODO: use flow-js only for web environments (e.g. playground)
    CompilerError.invariant(env.config.flowTypeProvider != null, {
      reason: 'Expected flowDumpTypes to be defined in environment config',
      loc: GeneratedSource,
    });
    let stdout: any;
    if (source === lastFlowSource) {
      stdout = lastFlowResult;
    } else {
      lastFlowSource = source;
      lastFlowResult = env.config.flowTypeProvider(source);
      stdout = lastFlowResult;
    }
    const flowTypes = buildTypeEnvironment(stdout);
    const resolvedFlowTypes = new Map<string, ResolvedType>();
    for (const [loc, type] of flowTypes) {
      if (typeof loc === 'symbol') continue;
      resolvedFlowTypes.set(loc, convertFlowType(JSON.parse(type), loc));
    }
    // =console.log(resolvedFlowTypes);
    this.#flowTypes = resolvedFlowTypes;
  }

  setType(identifier: Identifier, type: ResolvedType): void {
    if (
      typeof identifier.loc !== 'symbol' &&
      this.#flowTypes.has(serializeLoc(identifier.loc))
    ) {
      return;
    }
    this.#types.set(identifier.id, type);
  }

  getType(identifier: Identifier): ResolvedType {
    const result = this.getTypeOrNull(identifier);
    if (result == null) {
      throw new Error(
        `Type not found for ${identifier.id}, ${typeof identifier.loc === 'symbol' ? 'generated loc' : serializeLoc(identifier.loc)}`,
      );
    }
    return result;
  }

  getTypeOrNull(identifier: Identifier): ResolvedType | null {
    const result = this.#types.get(identifier.id) ?? null;
    if (result == null && typeof identifier.loc !== 'symbol') {
      const flowType = this.#flowTypes.get(serializeLoc(identifier.loc));
      return flowType ?? null;
    }
    return result;
  }

  getTypeByLoc(loc: SourceLocation): ResolvedType | null {
    if (typeof loc === 'symbol') {
      return null;
    }
    const flowType = this.#flowTypes.get(serializeLoc(loc));
    return flowType ?? null;
  }

  nextNominalId(): NominalId {
    return makeNominalId(this.#nextNominalId++);
  }

  nextTypeParameterId(): TypeParameterId {
    return makeTypeParameterId(this.#nextTypeParameterId++);
  }

  addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void {
    this.#bindings.set(bindingIdentifier, type);