React Compiler はどのように値のメモ化を決定しているのか(InferMutationAliasingEffects 篇)

/**
 * Computes an effect signature for the instruction _without_ looking at the inference state,
 * and only using the semantics of the instructions and the inferred types. The idea is to make
 * it easy to check that the semantics of each instruction are preserved by describing only the
 * effects and not making decisions based on the inference state.
 *
 * Then in applySignature(), above, we refine this signature based on the inference state.
 *
 * NOTE: this function is designed to be cached so it's only computed once upon first visiting
 * an instruction.
 */
function computeSignatureForInstruction(
  context: Context,
  env: Environment,
  instr: Instruction,
): InstructionSignature {
  const {lvalue, value} = instr;
  const effects: Array<AliasingEffect> = [];
  switch (value.kind) {
    case 'ArrayExpression': {
			// 新しい可変の配列を作る
      effects.push({
        kind: 'Create',
        into: lvalue,
        value: ValueKind.Mutable,
        reason: ValueReason.Other,
      });
			// 各要素は配列に Capture されうる
      for (const element of value.elements) {
        if (element.kind === 'Identifier') {
          effects.push({
            kind: 'Capture',
            from: element,
            into: lvalue,
          });
        }
				/* Spread も同様に Capture + 条件付きで Mutate */
      }
      break;
    }
    case 'CallExpression': {
      const signature = getFunctionCallSignature(env, value.callee.identifier.type);
			// 関数呼び出しは Apply にまとめる
      effects.push({
        kind: 'Apply',
        receiver: value.callee,
        function: value.callee,
        mutatesFunction: true,
        args: value.args,
        into: lvalue,
        signature,
        loc: value.loc,
      });
      break;
    }
		// ... 他多数の構文があるが省略 ...
	}
}

switch () {
	case 'Capture': {
	  const intoKind = state.kind(effect.into).kind;   // 目的地の抽象の種別
	  const fromKind = state.kind(effect.from).kind;   // ソースの抽象の種別

	  // ソースが Frozen なら不変参照として扱う
	  if (fromKind === ValueKind.Frozen) {
	    applyEffect(context, state, {
	      kind: 'ImmutableCapture',   // Capture → ImmutableCapture へ格下げ
	      from: effect.from,
	      into: effect.into,
	    }, initialized, effects);
	    break;
	  }

	  // destination が可変 かつ ソースが可変参照型なら Capture を残す
	  if (isMutableDesination && isMutableReferenceType) {
	    effects.push(effect);
	  }
	  break;
	}
}