[compiler] Foundation of new mutability and aliasing (alternate take)

Alternate take at a new mutability and alising model, aiming to replace `InferReferenceEffects` and `InferMutableRanges`. My initial passes at this were more complicated than necessary, and I've iterated to refine and distill this down to the core concepts. There are two effects that track information flow: `capture` and `alias`:

* Given distinct values A and B. After capture A -> B, mutate(B) does *not* modify A. This more precisely captures the semantic of the previous `Store` effect. As an example, `array.push(item)` has the effect `capture item -> array` and `mutate(array)`. The array is modified, not the item.
* Given distinct values A and B. After alias A -> B, mutate(B) *does* modify A. This is because B now refers to the same value as A.
* Given distinct values A and B, after *either* capture A -> B *or* alias A -> B, transitiveMutate(B) counts as a mutation of A.

Conceptually "capture A -> B" means that a reference to A was "captured" (or stored) within A, but there is not a directly aliasing. Whereas "alias A -> B" means literal value aliasing.

The idea is that our previous sequential fixpoint loops in InferMutableRanges can instead work by first looking at transitive mutations, then look at non-transitive mutations. And aliasing groups can be built purely based on the `alias` effect.

Lots more to do here but the structure is coming together.

ghstack-source-id: 5b9c88a
Pull Request resolved: #33346

Author: josephsavona

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts

@@ -104,6 +104,8 @@ import {validateNoImpureFunctionsInRender} from '../Validation/ValidateNoImpureF
 import {CompilerError} from '..';
 import {validateStaticComponents} from '../Validation/ValidateStaticComponents';
 import {validateNoFreezingKnownMutableFunctions} from '../Validation/ValidateNoFreezingKnownMutableFunctions';
+import {inferMutationAliasingEffects} from '../Inference/InferMutationAliasingEffects';
+import {inferMutationAliasingRanges} from '../Inference/InferMutationAliasingRanges';
 
 export type CompilerPipelineValue =
   | {kind: 'ast'; name: string; value: CodegenFunction}
@@ -226,6 +228,16 @@ function runWithEnvironment(
   analyseFunctions(hir);
   log({kind: 'hir', name: 'AnalyseFunctions', value: hir});
 
+  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
+  log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
+  if (env.isInferredMemoEnabled) {
+    if (mutabilityAliasingErrors.isErr()) {
+      throw mutabilityAliasingErrors.unwrapErr();
+    }
+  }
+  inferMutationAliasingRanges(hir);
+  log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
+
   const fnEffectErrors = inferReferenceEffects(hir);
   if (env.isInferredMemoEnabled) {
     if (fnEffectErrors.length > 0) {

compiler/packages/babel-plugin-react-compiler/src/HIR/HIR.ts

@@ -101,6 +101,7 @@ export type ReactiveInstruction = {
   id: InstructionId;
   lvalue: Place | null;
   value: ReactiveValue;
+  effects?: Array<AliasingEffect> | null; // TODO make non-optional
   loc: SourceLocation;
 };
 

compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts

@@ -6,6 +6,7 @@
  */
 
 import {CompilerError} from '../CompilerError';
+import {AliasingSignature} from '../Inference/InferMutationAliasingEffects';
 import {Effect, ValueKind, ValueReason} from './HIR';
 import {
   BuiltInType,
@@ -179,6 +180,8 @@ export type FunctionSignature = {
   impure?: boolean;
 
   canonicalName?: string;
+
+  aliasing?: AliasingSignature | null;
 };
 
 /*
@@ -332,6 +335,7 @@ addObject(BUILTIN_SHAPES, BuiltInArrayId, [
       returnValueKind: ValueKind.Mutable,
       noAlias: true,
       mutableOnlyIfOperandsAreMutable: true,
+      aliasing: null,
     }),
   ],
   [

compiler/packages/babel-plugin-react-compiler/src/HIR/PrintHIR.ts

@@ -35,6 +35,10 @@ import type {
   Type,
 } from './HIR';
 import {GotoVariant, InstructionKind} from './HIR';
+import {
+  AliasedPlace,
+  AliasingEffect,
+} from '../Inference/InferMutationAliasingEffects';
 
 export type Options = {
   indent: number;
@@ -151,7 +155,10 @@ export function printMixedHIR(
 
 export function printInstruction(instr: ReactiveInstruction): string {
   const id = `[${instr.id}]`;
-  const value = printInstructionValue(instr.value);
+  let value = printInstructionValue(instr.value);
+  if (instr.effects != null) {
+    value += `\n    ${instr.effects.map(printAliasingEffect).join('\n    ')}`;
+  }
 
   if (instr.lvalue !== null) {
     return `${id} ${printPlace(instr.lvalue)} = ${value}`;
@@ -933,3 +940,46 @@ function getFunctionName(
       return defaultValue;
   }
 }
+
+export function printAliasingEffect(effect: AliasingEffect): string {
+  switch (effect.kind) {
+    case 'Alias': {
+      return `Alias ${printPlaceForAliasEffect(effect.from)} -> ${printPlaceForAliasEffect(effect.into)}`;
+    }
+    case 'Capture': {
+      return `Capture ${printPlaceForAliasEffect(effect.from)} -> ${printPlaceForAliasEffect(effect.into)}`;
+    }
+    case 'Create': {
+      return `Create ${printPlaceForAliasEffect(effect.into)} = ${effect.value}`;
+    }
+    case 'CreateFrom': {
+      return `Create ${printPlaceForAliasEffect(effect.into)} = kindOf(${printPlaceForAliasEffect(effect.from)})`;
+    }
+    case 'Apply': {
+      const params = effect.params.map(printAliasedPlace).join(', ');
+      const rest = effect.rest != null ? printAliasedPlace(effect.rest) : '';
+      const returns = printAliasedPlace(effect.returns);
+      return `Apply ${returns} = ${printAliasedPlace(effect.function)} as ${effect.receiver} ( ${params} ${params.length !== 0 && rest !== '' ? ', ...' : ''}${rest})`;
+    }
+    case 'Freeze': {
+      return `Freeze ${printPlaceForAliasEffect(effect.value)} ${effect.reason}`;
+    }
+    case 'Mutate':
+    case 'MutateConditionally':
+    case 'MutateTransitive':
+    case 'MutateTransitiveConditionally': {
+      return `${effect.kind} ${printPlaceForAliasEffect(effect.value)}`;
+    }
+    default: {
+      assertExhaustive(effect, `Unexpected kind '${(effect as any).kind}'`);
+    }
+  }
+}
+
+function printPlaceForAliasEffect(place: Place): string {
+  return printIdentifier(place.identifier);
+}
+
+function printAliasedPlace(place: AliasedPlace): string {
+  return place.kind + ' ' + printPlaceForAliasEffect(place.place);
+}

compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutableRanges.ts

@@ -119,7 +119,7 @@ export function debugAliases(aliases: DisjointSet<Identifier>): void {
  *
  * This ensures that we fixpoint the mutable ranges themselves and not just the alias sets.
  */
-function canonicalize(
+export function canonicalize(
   aliases: DisjointSet<Identifier>,
 ): Map<Identifier, string> {
   const entries = new Map<Identifier, string>();
@@ -132,7 +132,7 @@ function canonicalize(
   return entries;
 }
 
-function areEqualMaps<T, U>(a: Map<T, U>, b: Map<T, U>): boolean {
+export function areEqualMaps<T, U>(a: Map<T, U>, b: Map<T, U>): boolean {
   if (a.size !== b.size) {
     return false;
   }