WP2: SSA & type inference (@analyzer subagent)

<file>
00001| /**
00002|  * Copyright (c) Meta Platforms, Inc. and affiliates.
00003|  *
00004|  * This source code is licensed under the MIT license found in the
00005|  * LICENSE file in the root directory of this source tree.
00006|  */
00007| 
00008| import {CompilerError} from '../CompilerError';
00009| import {Environment} from '../HIR/Environment';
00010| import {
00011|   BasicBlock,
00012|   BlockId,
00013|   GeneratedSource,
00014|   HIRFunction,
00015|   Identifier,
00016|   IdentifierId,
00017|   makeInstructionId,
00018|   makeType,
00019|   Phi,
00020|   Place,
00021| } from '../HIR/HIR';
00022| import {printIdentifier, printPlace} from '../HIR/PrintHIR';
00023| import {
00024|   eachTerminalSuccessor,
00025|   mapInstructionLValues,
00026|   mapInstructionOperands,
00027|   mapTerminalOperands,
00028| } from '../HIR/visitors';
00029| 
00030| type IncompletePhi = {
00031|   oldPlace: Place;
00032|   newPlace: Place;
00033| };
00034| 
00035| type State = {
00036|   defs: Map<Identifier, Identifier>;
00037|   incompletePhis: Array<IncompletePhi>;
00038| };
00039| 
00040| class SSABuilder {
00041|   #states: Map<BasicBlock, State> = new Map();
00042|   #current: BasicBlock | null = null;
00043|   unsealedPreds: Map<BasicBlock, number> = new Map();
00044|   #blocks: Map<BlockId, BasicBlock>;
00045|   #env: Environment;
00046|   #unknown: Set<Identifier> = new Set();
00047|   #context: Set<Identifier> = new Set();
00048| 
00049|   constructor(env: Environment, blocks: ReadonlyMap<BlockId, BasicBlock>) {
00050|     this.#blocks = new Map(blocks);
00051|     this.#env = env;
00052|   }
00053| 
00054|   get nextSsaId(): IdentifierId {
00055|     return this.#env.nextIdentifierId;
00056|   }
00057| 
00058|   defineFunction(func: HIRFunction): void {
00059|     for (const [id, block] of func.body.blocks) {
00060|       this.#blocks.set(id, block);
00061|     }
00062|   }
00063| 
00064|   enter(fn: () => void): void {
00065|     const current = this.#current;
000...

<file>
00001| /**
00002|  * Copyright (c) Meta Platforms, Inc. and affiliates.
00003|  *
00004|  * This source code is licensed under the MIT license found in the
00005|  * LICENSE file in the root directory of this source tree.
00006|  */
00007| 
00008| import {CompilerError} from '../CompilerError';
00009| import {
00010|   BlockId,
00011|   GeneratedSource,
00012|   HIRFunction,
00013|   Identifier,
00014|   Place,
00015| } from '../HIR/HIR';
00016| import {
00017|   eachInstructionLValue,
00018|   eachInstructionOperand,
00019|   eachTerminalOperand,
00020| } from '../HIR/visitors';
00021| 
00022| const DEBUG = false;
00023| 
00024| /*
00025|  * Pass to eliminate redundant phi nodes:
00026|  * - all operands are the same identifier, ie `x2 = phi(x1, x1, x1)`.
00027|  * - all operands are the same identifier *or* the output of the phi, ie `x2 = phi(x1, x2, x1, x2)`.
00028|  *
00029|  * In both these cases, the phi is eliminated and all usages of the phi identifier
00030|  * are replaced with the other operand (ie in both cases above, all usages of `x2` are replaced with `x1` .
00031|  *
00032|  * The algorithm is inspired by that in https://pp.ipd.kit.edu/uploads/publikationen/braun13cc.pdf
00033|  * but modified to reduce passes over the CFG. We visit the blocks in reverse postorder. Each time a redundant
00034|  * phi is encountered we add a mapping (eg x2 -> x1) to a rewrite table. Subsequent instructions, terminals,
00035|  * and phis rewrite all their identifiers based on this table. The algorithm loops over the CFG repeatedly
00036|  * until there are no new rewrites: for a CFG without back-edges it completes in a single pass.
00037|  */
00038| export function eliminateRedundantPhi(
00039|   fn: HIRFunction,
00040|   sharedRewrites?: Map<Identifier, Identifier>,
00041| ): void {
00042|   const ir = fn.body;
00043|   const rewrites: Map<Identifier, Identifier> =
00044|     sharedRewrites != null ? sharedRewrites : new Map();
00045| 
00046|   /*
00047|    * W...

<file>
00001| /**
00002|  * Copyright (c) Meta Platforms, Inc. and affiliates.
00003|  *
00004|  * This source code is licensed under the MIT license found in the
00005|  * LICENSE file in the root directory of this source tree.
00006|  */
00007| 
00008| import {CompilerError} from '../CompilerError';
00009| import {
00010|   DeclarationId,
00011|   GeneratedSource,
00012|   HIRFunction,
00013|   InstructionKind,
00014|   LValue,
00015|   LValuePattern,
00016|   Place,
00017| } from '../HIR/HIR';
00018| import {printPlace} from '../HIR/PrintHIR';
00019| import {eachPatternOperand} from '../HIR/visitors';
00020| 
00021| /**
00022|  * This pass rewrites the InstructionKind of instructions which declare/assign variables,
00023|  * converting the first declaration to a Const/Let depending on whether it is subsequently
00024|  * reassigned, and ensuring that subsequent reassignments are marked as a Reassign. Note
00025|  * that declarations which were const in the original program cannot become `let`, but the
00026|  * inverse is not true: a `let` which was reassigned in the source may be converted to a
00027|  * `const` if the reassignment is not used and was removed by dead code elimination.
00028|  *
00029|  * NOTE: this is a subset of the operations previously performed by the LeaveSSA pass.
00030|  */
00031| export function rewriteInstructionKindsBasedOnReassignment(
00032|   fn: HIRFunction,
00033| ): void {
00034|   const declarations = new Map<DeclarationId, LValue | LValuePattern>();
00035|   for (const param of fn.params) {
00036|     let place: Place = param.kind === 'Identifier' ? param : param.place;
00037|     if (place.identifier.name !== null) {
00038|       declarations.set(place.identifier.declarationId, {
00039|         kind: InstructionKind.Let,
00040|         place,
00041|       });
00042|     }
00043|   }
00044|   for (const place of fn.context) {
00045|     if (place.identifier.name !== null) {
00046|       declarations.set(place.identifier.declara...

<file>
00001| /**
00002|  * Copyright (c) Meta Platforms, Inc. and affiliates.
00003|  *
00004|  * This source code is licensed under the MIT license found in the
00005|  * LICENSE file in the root directory of this source tree.
00006|  */
00007| 
00008| import * as t from '@babel/types';
00009| import {CompilerError} from '../CompilerError';
00010| import {Environment} from '../HIR';
00011| import {lowerType} from '../HIR/BuildHIR';
00012| import {
00013|   GeneratedSource,
00014|   HIRFunction,
00015|   Identifier,
00016|   IdentifierId,
00017|   Instruction,
00018|   InstructionKind,
00019|   makePropertyLiteral,
00020|   makeType,
00021|   PropType,
00022|   Type,
00023|   typeEquals,
00024|   TypeId,
00025|   TypeVar,
00026| } from '../HIR/HIR';
00027| import {
00028|   BuiltInArrayId,
00029|   BuiltInEventHandlerId,
00030|   BuiltInFunctionId,
00031|   BuiltInJsxId,
00032|   BuiltInMixedReadonlyId,
00033|   BuiltInObjectId,
00034|   BuiltInPropsId,
00035|   BuiltInRefValueId,
00036|   BuiltInSetStateId,
00037|   BuiltInUseRefId,
00038| } from '../HIR/ObjectShape';
00039| import {eachInstructionLValue, eachInstructionOperand} from '../HIR/visitors';
00040| import {assertExhaustive} from '../Utils/utils';
00041| 
00042| function isPrimitiveBinaryOp(op: t.BinaryExpression['operator']): boolean {
00043|   switch (op) {
00044|     case '+':
00045|     case '-':
00046|     case '/':
00047|     case '%':
00048|     case '*':
00049|     case '**':
00050|     case '&':
00051|     case '|':
00052|     case '>>':
00053|     case '<<':
00054|     case '^':
00055|     case '>':
00056|     case '<':
00057|     case '>=':
00058|     case '<=':
00059|     case '|>':
00060|       return true;
00061|     default:
00062|       return false;
00063|   }
00064| }
00065| 
00066| export function inferTypes(func: HIRFunction): void {
00067|   const unifier = new Unifier(func.env);
00068|   for (const e of generate(func)) {
00069|     unifier.unify(e.left, e.right);
00070|   }
00071|  ...

<file>
00001| /**
00002|  * Copyright (c) Meta Platforms, Inc. and affiliates.
00003|  *
00004|  * This source code is licensed under the MIT license found in the
00005|  * LICENSE file in the root directory of this source tree.
00006|  */
00007| 
00008| import {BindingKind} from '@babel/traverse';
00009| import * as t from '@babel/types';
00010| import {
00011|   CompilerDiagnostic,
00012|   CompilerError,
00013|   ErrorCategory,
00014| } from '../CompilerError';
00015| import {assertExhaustive} from '../Utils/utils';
00016| import {Environment, ReactFunctionType} from './Environment';
00017| import type {HookKind} from './ObjectShape';
00018| import {Type, makeType} from './Types';
00019| import {z} from 'zod/v4';
00020| import type {AliasingEffect} from '../Inference/AliasingEffects';
00021| import {isReservedWord} from '../Utils/Keyword';
00022| import {Err, Ok, Result} from '../Utils/Result';
00023| 
00024| /*
00025|  * *******************************************************************************************
00026|  * *******************************************************************************************
00027|  * ************************************* Core Data Model *************************************
00028|  * *******************************************************************************************
00029|  * *******************************************************************************************
00030|  */
00031| 
00032| // AST -> (lowering) -> HIR -> (analysis) -> Reactive Scopes -> (codegen) -> AST
00033| 
00034| /*
00035|  * A location in a source file, intended to be used for providing diagnostic information and
00036|  * transforming code while preserving source information (ie to emit source maps).
00037|  *
00038|  * `GeneratedSource` indicates that there is no single source location from which the code derives.
00039|  */
00040| export const GeneratedSource = Symbol();
00041| export type SourceLocation = t.SourceLocation | typeof Generate...

<file>
00001| /**
00002|  * Copyright (c) Meta Platforms, Inc. and affiliates.
00003|  *
00004|  * This source code is licensed under the MIT license found in the
00005|  * LICENSE file in the root directory of this source tree.
00006|  */
00007| 
00008| import {CompilerError} from '../CompilerError';
00009| import {GeneratedSource, PropertyLiteral} from './HIR';
00010| 
00011| export type BuiltInType = PrimitiveType | FunctionType | ObjectType;
00012| 
00013| export type Type =
00014|   | BuiltInType
00015|   | PhiType
00016|   | TypeVar
00017|   | PolyType
00018|   | PropType
00019|   | ObjectMethod;
00020| export type PrimitiveType = {kind: 'Primitive'};
00021| 
00022| /*
00023|  * An {@link FunctionType} or {@link ObjectType} (also a JS object) may be associated with an
00024|  * inferred "object shape", i.e. a known property (key -> Type) map. This is
00025|  * subtly different from JS language semantics - `shape` represents both
00026|  * OwnPropertyDescriptors and properties present in the prototype chain.
00027|  *
00028|  * {@link ObjectShape.functionType} is always present on the shape of a {@link FunctionType},
00029|  * and it represents the call signature of the function. Note that Forget thinks of a
00030|  * {@link FunctionType} as any "callable object" (not to be confused with objects that
00031|  *   extend the global `Function`.)
00032|  *
00033|  * If `shapeId` is present, it is a key into the ShapeRegistry used to infer this
00034|  * FunctionType or ObjectType instance (i.e. from an Environment).
00035|  */
00036| 
00037| export type FunctionType = {
00038|   kind: 'Function';
00039|   shapeId: string | null;
00040|   return: Type;
00041|   isConstructor: boolean;
00042| };
00043| 
00044| export type ObjectType = {
00045|   kind: 'Object';
00046|   shapeId: string | null;
00047| };
00048| 
00049| export type TypeVar = {
00050|   kind: 'Type';
00051|   id: TypeId;
00052| };
00053| export type PolyType = {
00054|   kind: 'Poly';
00055| };
00056| e...

<file>
00001| /**
00002|  * Copyright (c) Meta Platforms, Inc. and affiliates.
00003|  *
00004|  * This source code is licensed under the MIT license found in the
00005|  * LICENSE file in the root directory of this source tree.
00006|  */
00007| 
00008| import * as t from '@babel/types';
00009| import {ZodError, z} from 'zod/v4';
00010| import {fromZodError} from 'zod-validation-error/v4';
00011| import {CompilerError} from '../CompilerError';
00012| import {CompilerOutputMode, Logger, ProgramContext} from '../Entrypoint';
00013| import {Err, Ok, Result} from '../Utils/Result';
00014| import {
00015|   DEFAULT_GLOBALS,
00016|   DEFAULT_SHAPES,
00017|   Global,
00018|   GlobalRegistry,
00019|   getReanimatedModuleType,
00020|   installTypeConfig,
00021| } from './Globals';
00022| import {
00023|   BlockId,
00024|   BuiltInType,
00025|   Effect,
00026|   FunctionType,
00027|   GeneratedSource,
00028|   HIRFunction,
00029|   IdentifierId,
00030|   NonLocalBinding,
00031|   PolyType,
00032|   ScopeId,
00033|   SourceLocation,
00034|   Type,
00035|   ValidatedIdentifier,
00036|   ValueKind,
00037|   getHookKindForType,
00038|   makeBlockId,
00039|   makeIdentifierId,
00040|   makeIdentifierName,
00041|   makeScopeId,
00042| } from './HIR';
00043| import {
00044|   BuiltInMixedReadonlyId,
00045|   DefaultMutatingHook,
00046|   DefaultNonmutatingHook,
00047|   FunctionSignature,
00048|   ShapeRegistry,
00049|   addHook,
00050| } from './ObjectShape';
00051| import {Scope as BabelScope, NodePath} from '@babel/traverse';
00052| import {TypeSchema} from './TypeSchema';
00053| import {FlowTypeEnv} from '../Flood/Types';
00054| import {defaultModuleTypeProvider} from './DefaultModuleTypeProvider';
00055| import {assertExhaustive} from '../Utils/utils';
00056| 
00057| export const ReactElementSymbolSchema = z.object({
00058|   elementSymbol: z.union([
00059|     z.literal('react.element'),
00060|     z.literal('react.transitional.element'),
00061|   ]),
00062|   globalDevVar: z...

<file>
00001| (** Scope analysis for TypeScript ESTree AST.
00002| 
00003|     Two-pass analysis: 1. Declaration pass: collect all module-scope const/let
00004|     bindings, noting which are mutable state (new Map/Set) and which are
00005|     functions. 2. Reference pass: for each arrow function body, collect
00006|     Identifier references that are not locally declared -> these are free
00007|     variables. *)
00008| 
00009| type error = Expected_program_node
00010| 
00011| let error_to_string = function
00012|   | Expected_program_node -> "expected Program node"
00013| 
00014| type var_info = { name : string; is_mutable_state : bool; is_function : bool }
00015| 
00016| type closure_info = {
00017|   name : string;
00018|   free_vars : string list;
00019|   called_functions : string list;
00020|   captures_mutable : string list;
00021| }
00022| 
00023| type analysis_result = {
00024|   closures : closure_info list;
00025|   module_vars : var_info list;
00026|   exports : string list;
00027| }
00028| 
00029| (** Check whether an init expression is [new Map(...)], [new Set(...)], etc. *)
00030| let is_mutable_init = function
00031|   | Ast.NewExpression { callee = Ast.Identifier { name }; _ }
00032|     when name = "Map" || name = "Set" || name = "Array" ->
00033|       true
00034|   | _ -> false
00035| 
00036| (** Check whether an init expression is an arrow function. *)
00037| let is_arrow_init = function
00038|   | Ast.ArrowFunctionExpression _ -> true
00039|   | _ -> false
00040| 
00041| let option_exists predicate = function
00042|   | Some value -> predicate value
00043|   | None -> false
00044| 
00045| (** Extract parameter names from an arrow function's param list. *)
00046| let param_names params =
00047|   List.filter_map
00048|     (function Ast.Identifier { name } -> Some name | _ -> None)
00049|     params
00050| 
00051| (** Collect all identifiers referenced in an expression/statement, excluding
00052|     property names on the right side of member ...

<file>
00001| (** Scope analysis for TypeScript ESTree AST.
00002| 
00003|     Walks the AST to build a scope tree, identify variable declarations, and
00004|     compute free variables for each arrow function (closure). *)
00005| 
00006| (** Analysis errors. *)
00007| type error =
00008|   | Expected_program_node
00009|       (** The [analyze] entry point was called with a non-[Program] AST node. *)
00010| 
00011| val error_to_string : error -> string
00012| (** [error_to_string err] is a human-readable message for [err]. *)
00013| 
00014| type var_info = {
00015|   name : string;
00016|   is_mutable_state : bool;
00017|       (** [true] when the initialiser is [new Map()], [new Set()], etc. *)
00018|   is_function : bool;
00019|       (** [true] when the initialiser is an [ArrowFunctionExpression]. *)
00020| }
00021| (** Information about a declared variable. *)
00022| 
00023| type closure_info = {
00024|   name : string;  (** The [const] name this arrow function is assigned to. *)
00025|   free_vars : string list;  (** Variables referenced from outer scopes. *)
00026|   called_functions : string list;
00027|       (** Names of other module-level functions called in the body. *)
00028|   captures_mutable : string list;
00029|       (** Subset of [free_vars] that are mutable state variables. *)
00030| }
00031| (** Per-closure analysis result. *)
00032| 
00033| type analysis_result = {
00034|   closures : closure_info list;
00035|   module_vars : var_info list;  (** All module-scope variable declarations. *)
00036|   exports : string list;
00037|       (** Names appearing in [export { ... }] declarations. *)
00038| }
00039| (** Complete analysis result for a program. *)
00040| 
00041| val analyze : Ast.node -> (analysis_result, error) result
00042| 

(End of file - total 42 lines)
</file>

All 9 tools executed successfully.

Keep using the batch tool for optimal performance in your next response!

<file>
00001| # React Compiler SSA Conversion and Type Inference Analysis
00002| 
00003| > Analysis of React Compiler's SSA construction and type inference passes for adaptation to CloudLang
00004| > Analysis Date: 2026-02-10
00005| > Target: OCaml compiler decomposing TypeScript closures into Cloudflare Workers
00006| 
00007| ---
00008| 
00009| # Table of Contents
00010| 
00011| 1. [SSA Construction (EnterSSA)](#1-ssa-construction-enterssats)
00012| 2. [Phi Node Elimination (EliminateRedundantPhi)](#2-phi-node-elimination-eliminateredundantphits)
00013| 3. [Instruction Kind Rewriting (RewriteInstructionKindsBasedOnReassignment)](#3-instruction-kind-rewriting-rewriteinstructionkindsbasedonreassignmentts)
00014| 4. [Type Inference (InferTypes)](#4-type-inference-infertypes)
00015| 5. [CloudLang SSA Strategy](#5-cloudlang-ssa-strategy)
00016| 6. [Detailed SSA Algorithm Analysis](#6-detailed-ssa-algorithm-analysis)
00017| 7. [Mapping to CloudLang](#7-mapping-to-cloudlang)
00018| 
00019| ---
00020| 
00021| # 1. SSA Construction (EnterSSA)
00022| 
00023| ## File
00024| `SSA/EnterSSA.ts` (330 lines)
00025| 
00026| ## Purpose
00027| Converts a HIR (High-Level Intermediate Representation) function from non-SSA form to Static Single Assignment (SSA) form. Each assignment creates a new version of a variable, eliminating the need to track multiple possible values for a single variable across control flow.
00028| 
00029| ## Input Invariants
00030| - HIRFunction with CFG in `func.body.blocks` (Map<BlockId, BasicBlock>)
00031| - Blocks are in **reverse postorder** (predecessors before successors in map)
00032| - Each BasicBlock has:
00033|   - `instructions`: Array of instructions
00034|   - `terminal`: Terminal node (branch, return, goto, etc.)
00035|   - `preds`: Set<BlockId> of predecessor blocks
00036|   - `phis`: Empty Set initially (phis are added during SSA conversion)
00037| - Identifiers have `id` field that equals `declarationId` before SSA conversion
00038| - All varia...