[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: 5b9c88a5f1
Pull Request resolved: https://github.com/facebook/react/pull/33346
This commit is contained in:
Joe Savona committed 2025-06-09 11:10:33 -07:00
1 parent 77d33803e2
commit 0688114941
9 files changed
+1592 -20

No files matched your search

@@ -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) {
@@ -101,6 +101,7 @@ export type ReactiveInstruction = {
id: InstructionId;
lvalue: Place | null;
value: ReactiveValue;
effects?: Array<AliasingEffect> | null; // TODO make non-optional
loc: SourceLocation;
};
@@ -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,
}),
],
[
@@ -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);
}
@@ -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;
}
@@ -0,0 +1,75 @@
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
import {HIRFunction, Identifier, makeInstructionId} from '../HIR/HIR';
import DisjointSet from '../Utils/DisjointSet';
import {inferMutableRangesForAlias} from './InferMutableRangesForAlias';
export function inferMutationAliasingRanges(fn: HIRFunction): void {
/**
* Part 1
* Infer ranges for transitive mutations, which includes mutations that affect
* captured references and not just direct aliases. We build a distjoing set
* that tracks capturing and direct aliasing, and look at transitive mutations
* only.
*/
const captures = new DisjointSet<Identifier>();
for (const block of fn.body.blocks.values()) {
for (const phi of block.phis) {
captures.union([
phi.place.identifier,
...[...phi.operands.values()].map(place => place.identifier),
]);
}
for (const instr of block.instructions) {
if (instr.effects == null) continue;
for (const effect of instr.effects) {
if (
effect.kind === 'Alias' ||
effect.kind === 'CreateFrom' ||
effect.kind === 'Capture'
) {
captures.union([effect.from.identifier, effect.into.identifier]);
} else if (effect.kind === 'MutateTransitive') {
const value = effect.value;
value.identifier.mutableRange.end = makeInstructionId(instr.id + 1);
}
}
}
}
inferMutableRangesForAlias(fn, captures);
/**
* Part 2
* Infer ranges for local (non-transitive) mutations. We build a disjoint set
* that only tracks direct value aliasing, and look only at local mutations
* to extend ranges
*/
const aliases = new DisjointSet<Identifier>();
for (const block of fn.body.blocks.values()) {
for (const phi of block.phis) {
aliases.union([
phi.place.identifier,
...[...phi.operands.values()].map(place => place.identifier),
]);
}
for (const instr of block.instructions) {
if (instr.effects == null) continue;
for (const effect of instr.effects) {
if (effect.kind === 'Alias' || effect.kind === 'CreateFrom') {
aliases.union([effect.from.identifier, effect.into.identifier]);
} else if (effect.kind === 'Mutate') {
const value = effect.value;
value.identifier.mutableRange.end = makeInstructionId(instr.id + 1);
}
}
}
}
inferMutableRangesForAlias(fn, aliases);
}
@@ -48,7 +48,7 @@ import {
eachTerminalOperand,
eachTerminalSuccessor,
} from '../HIR/visitors';
import {assertExhaustive, retainWhere} from '../Utils/utils';
import {assertExhaustive, retainWhere, Set_isSuperset} from '../Utils/utils';
import {
inferTerminalFunctionEffects,
inferInstructionFunctionEffects,
@@ -790,7 +790,7 @@ function inferParam(
* │ Mutable │───┘
* └──────────────────────────┘
*/
function mergeValues(a: ValueKind, b: ValueKind): ValueKind {
export function mergeValueKinds(a: ValueKind, b: ValueKind): ValueKind {
if (a === b) {
return a;
} else if (a === ValueKind.MaybeFrozen || b === ValueKind.MaybeFrozen) {
@@ -832,28 +832,16 @@ function mergeValues(a: ValueKind, b: ValueKind): ValueKind {
}
}
/**
* @returns `true` if `a` is a superset of `b`.
*/
function isSuperset<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean {
for (const v of b) {
if (!a.has(v)) {
return false;
}
}
return true;
}
function mergeAbstractValues(
a: AbstractValue,
b: AbstractValue,
): AbstractValue {
const kind = mergeValues(a.kind, b.kind);
const kind = mergeValueKinds(a.kind, b.kind);
if (
kind === a.kind &&
kind === b.kind &&
isSuperset(a.reason, b.reason) &&
isSuperset(a.context, b.context)
Set_isSuperset(a.reason, b.reason) &&
Set_isSuperset(a.context, b.context)
) {
return a;
}
@@ -121,6 +121,21 @@ export function Set_intersect<T>(sets: Array<ReadonlySet<T>>): Set<T> {
return result;
}
/**
* @returns `true` if `a` is a superset of `b`.
*/
export function Set_isSuperset<T>(
a: ReadonlySet<T>,
b: ReadonlySet<T>,
): boolean {
for (const v of b) {
if (!a.has(v)) {
return false;
}
}
return true;
}
export function Iterable_some<T>(
iter: Iterable<T>,
pred: (item: T) => boolean,