collectNonNullsInBlocks() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/HIR/CollectHoistablePropertyLoads.ts lines 380–485

function collectNonNullsInBlocks(
  fn: HIRFunction,
  context: CollectHoistablePropertyLoadsContext,
): ReadonlyMap<BlockId, BlockInfo> {
  /**
   * Known non-null objects such as functional component props can be safely
   * read from any block.
   */
  const knownNonNullIdentifiers = new Set<PropertyPathNode>();
  if (
    fn.fnType === 'Component' &&
    fn.params.length > 0 &&
    fn.params[0].kind === 'Identifier'
  ) {
    const identifier = fn.params[0].identifier;
    knownNonNullIdentifiers.add(
      context.registry.getOrCreateIdentifier(identifier, true),
    );
  }
  const nodes = new Map<
    BlockId,
    {
      block: BasicBlock;
      assumedNonNullObjects: Set<PropertyPathNode>;
    }
  >();
  for (const [_, block] of fn.body.blocks) {
    const assumedNonNullObjects = new Set<PropertyPathNode>(
      knownNonNullIdentifiers,
    );

    const maybeOptionalChain = context.hoistableFromOptionals.get(block.id);
    if (maybeOptionalChain != null) {
      assumedNonNullObjects.add(
        context.registry.getOrCreateProperty(maybeOptionalChain),
      );
    }
    for (const instr of block.instructions) {
      const maybeNonNull = getMaybeNonNullInInstruction(instr.value, context);
      if (
        maybeNonNull != null &&
        isImmutableAtInstr(maybeNonNull.fullPath.identifier, instr.id, context)
      ) {
        assumedNonNullObjects.add(maybeNonNull);
      }
      if (instr.value.kind === 'FunctionExpression') {
        const innerFn = instr.value.loweredFunc;
        if (context.assumedInvokedFns.has(innerFn)) {
          const innerHoistableMap = collectHoistablePropertyLoadsImpl(
            innerFn.func,
            {
              ...context,
              nestedFnImmutableContext:
                context.nestedFnImmutableContext ??
                new Set(
                  innerFn.func.context
                    .filter(place =>
                      isImmutableAtInstr(place.identifier, instr.id, context),
                    )
                    .map(place => place.identifier.id),
                ),
            },
          );
          const innerHoistables = assertNonNull(
            innerHoistableMap.get(innerFn.func.body.entry),
          );
          for (const entry of innerHoistables.assumedNonNullObjects) {
            assumedNonNullObjects.add(entry);
          }
        }
      } else if (
        fn.env.config.enablePreserveExistingMemoizationGuarantees &&
        instr.value.kind === 'StartMemoize' &&
        instr.value.deps != null
      ) {
        for (const dep of instr.value.deps) {
          if (dep.root.kind === 'NamedLocal') {
            if (
              !isImmutableAtInstr(dep.root.value.identifier, instr.id, context)
            ) {
              continue;