{"parents":["46024acb8203aacbaafe20404205fa16e259804e"],"files":[{"path":"compiler\/forget\/src\/HIR\/ReactiveFunctionVisitor.ts","status":"A"},{"path":"compiler\/forget\/src\/ReactiveScopes\/BuildReactiveFunctionWithoutScopes.ts","status":"M"}],"commit":{"shortRevision":"9e549e9417","subject":"Fork HIRTreeVisitor to specialize it for ReactiveFunction conversion","revision":"9e549e9417698a8a12fb04917461e7a20b0b3000","authorName":"Joe Savona","authorEmail":"joesavona@fb.com","authoredAt":"2023-01-12T09:11:54-08:00"},"body":"","patch":"diff --git a\/compiler\/forget\/src\/HIR\/ReactiveFunctionVisitor.ts b\/compiler\/forget\/src\/HIR\/ReactiveFunctionVisitor.ts\nnew file mode 100644\nindex 0000000000..579c462a03\n--- \/dev\/null\n+++ b\/compiler\/forget\/src\/HIR\/ReactiveFunctionVisitor.ts\n@@ -0,0 +1,958 @@\n+\/**\n+ * Copyright (c) Facebook, Inc. and its affiliates.\n+ *\n+ * This source code is licensed under the MIT license found in the\n+ * LICENSE file in the root directory of this source tree.\n+ *\/\n+\n+import invariant from \"invariant\";\n+import todo from \"..\/Utils\/todo\";\n+import { assertExhaustive } from \"..\/Utils\/utils\";\n+import {\n+ BasicBlock,\n+ BlockId,\n+ GotoVariant,\n+ HIR,\n+ HIRFunction,\n+ Instruction,\n+ InstructionId,\n+ InstructionValue,\n+ Place,\n+ SourceLocation,\n+} from \".\/HIR\";\n+\n+\/**\n+ * Function to visit HIR as a tree of high-level constructs rather than as a sequence\n+ * of lower-level basic blocks. Intended for use in codegen and reactive scope\n+ * construction which need to see the original \"shape\" of the code.\n+ *\n+ * See the {@link Visitor} interface for more about implementing a visitor.\n+ *\/\n+export function visitTreeForReactiveFunction<\n+ TBlockBuilder,\n+ TBlock,\n+ TInit,\n+ TValueBlock,\n+ TValue,\n+ TStatement,\n+ TCase\n+>(\n+ fn: HIRFunction,\n+ visitor: Visitor<\n+ TBlockBuilder,\n+ TBlock,\n+ TInit,\n+ TValueBlock,\n+ TValue,\n+ TStatement,\n+ TCase\n+ >\n+): TBlock {\n+ const cx = new Context(fn.body);\n+ const driver = new Driver(cx, visitor);\n+ return driver.traverseBlock(cx.block(fn.body.entry));\n+}\n+\n+class Driver<\n+ TBlockBuilder,\n+ TBlock,\n+ TInit,\n+ TValueBlock,\n+ TValue,\n+ TStatement,\n+ TCase\n+> {\n+ cx: Context;\n+ visitor: Visitor<\n+ TBlockBuilder,\n+ TBlock,\n+ TInit,\n+ TValueBlock,\n+ TValue,\n+ TStatement,\n+ TCase\n+ >;\n+\n+ constructor(\n+ cx: Context,\n+ visitor: Visitor<\n+ TBlockBuilder,\n+ TBlock,\n+ TInit,\n+ TValueBlock,\n+ TValue,\n+ TStatement,\n+ TCase\n+ >\n+ ) {\n+ this.cx = cx;\n+ this.visitor = visitor;\n+ }\n+\n+ traverseBlock(block: BasicBlock): TBlock {\n+ const blockValue = this.visitor.enterBlock();\n+ this.visitBlock(block, blockValue);\n+ return this.visitor.leaveBlock(blockValue);\n+ }\n+\n+ visitBlock(block: BasicBlock, blockValue: TBlockBuilder): void {\n+ invariant(\n+ !this.cx.emitted.has(block.id),\n+ `Cannot emit the same block twice: bb${block.id}`\n+ );\n+ this.cx.emitted.add(block.id);\n+ for (const instr of block.instructions) {\n+ this.visitInstr(instr, blockValue);\n+ }\n+\n+ const terminal = block.terminal;\n+ const scheduleIds = [];\n+ switch (terminal.kind) {\n+ case \"return\": {\n+ const value =\n+ terminal.value != null\n+ ? this.visitPlace(terminal.value, terminal.id)\n+ : null;\n+ this.visitor.visitTerminalId(terminal.id);\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"return\",\n+ loc: terminal.loc,\n+ value,\n+ id: terminal.id,\n+ })\n+ );\n+ break;\n+ }\n+ case \"throw\": {\n+ const value = this.visitPlace(terminal.value, terminal.id);\n+ this.visitor.visitTerminalId(terminal.id);\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"throw\",\n+ value,\n+ id: terminal.id,\n+ })\n+ );\n+ break;\n+ }\n+ case \"if\": {\n+ const test = this.visitPlace(terminal.test, terminal.id);\n+ const fallthroughId =\n+ terminal.fallthrough !== null &&\n+ !this.cx.isScheduled(terminal.fallthrough)\n+ ? terminal.fallthrough\n+ : null;\n+ const alternateId =\n+ terminal.alternate !== terminal.fallthrough\n+ ? terminal.alternate\n+ : null;\n+\n+ if (fallthroughId !== null) {\n+ const scheduleId = this.cx.schedule(fallthroughId, \"if\");\n+ scheduleIds.push(scheduleId);\n+ }\n+\n+ this.visitor.visitTerminalId(terminal.id);\n+ let consequent: TBlock | null = null;\n+ if (this.cx.isScheduled(terminal.consequent)) {\n+ const break_ = this.visitBreak(terminal.consequent, null);\n+ if (break_ !== null) {\n+ const builder = this.visitor.enterBlock();\n+ this.visitor.appendBlock(builder, break_);\n+ consequent = this.visitor.leaveBlock(builder);\n+ }\n+ } else {\n+ consequent = this.traverseBlock(\n+ this.cx.ir.blocks.get(terminal.consequent)!\n+ );\n+ }\n+\n+ let alternate: TBlock | null = null;\n+ if (alternateId !== null) {\n+ if (this.cx.isScheduled(alternateId)) {\n+ const break_ = this.visitBreak(alternateId, null);\n+ if (break_ !== null) {\n+ const builder = this.visitor.enterBlock();\n+ this.visitor.appendBlock(builder, break_);\n+ alternate = this.visitor.leaveBlock(builder);\n+ }\n+ } else {\n+ alternate = this.traverseBlock(this.cx.ir.blocks.get(alternateId)!);\n+ }\n+ }\n+\n+ this.cx.unscheduleAll(scheduleIds);\n+ if (fallthroughId !== null) {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"if\",\n+ test,\n+ consequent: consequent ?? this.emptyBlock(),\n+ alternate: alternate,\n+ id: terminal.id,\n+ }),\n+ fallthroughId\n+ );\n+ this.visitBlock(this.cx.ir.blocks.get(fallthroughId)!, blockValue);\n+ } else {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"if\",\n+ test,\n+ consequent: consequent ?? this.emptyBlock(),\n+ alternate: alternate,\n+ id: terminal.id,\n+ })\n+ );\n+ }\n+ break;\n+ }\n+ case \"switch\": {\n+ const test = this.visitPlace(terminal.test, terminal.id);\n+ const fallthroughId =\n+ terminal.fallthrough !== null &&\n+ !this.cx.isScheduled(terminal.fallthrough)\n+ ? terminal.fallthrough\n+ : null;\n+ if (fallthroughId !== null) {\n+ const scheduleId = this.cx.schedule(fallthroughId, \"switch\");\n+ scheduleIds.push(scheduleId);\n+ }\n+\n+ this.visitor.visitTerminalId(terminal.id);\n+ const cases: Array = [];\n+ [...terminal.cases].reverse().forEach((case_, index) => {\n+ const test =\n+ case_.test !== null\n+ ? this.visitPlace(case_.test, terminal.id)\n+ : null;\n+\n+ let consequent;\n+ if (this.cx.isScheduled(case_.block)) {\n+ \/\/ cases which are empty or contain only a `break` may point to blocks\n+ \/\/ that are already scheduled. emit as follows:\n+ \/\/ - if the block is for another case branch, don't emit a break and fall-through\n+ \/\/ - else, emit an explicit break.\n+ const break_ = this.visitBreak(case_.block, null);\n+ if (\n+ index === 0 &&\n+ break_ === null &&\n+ case_.block === terminal.fallthrough &&\n+ case_.test === null\n+ ) {\n+ \/\/ If the last case statement (first in reverse order) is a default that\n+ \/\/ jumps to the fallthrough, then we would emit a useless `default: {}`,\n+ \/\/ so instead skip this case.\n+ return;\n+ }\n+ const block = this.visitor.enterBlock();\n+ if (break_ !== null) {\n+ this.visitor.appendBlock(block, break_);\n+ }\n+ consequent = this.visitor.leaveBlock(block);\n+ } else {\n+ consequent = this.traverseBlock(\n+ this.cx.ir.blocks.get(case_.block)!\n+ );\n+ const scheduleId = this.cx.schedule(case_.block, \"case\");\n+ scheduleIds.push(scheduleId);\n+ }\n+ cases.push(this.visitor.visitCase(test, consequent));\n+ });\n+ cases.reverse();\n+\n+ this.cx.unscheduleAll(scheduleIds);\n+ if (fallthroughId !== null) {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"switch\",\n+ test,\n+ cases,\n+ id: terminal.id,\n+ }),\n+ fallthroughId\n+ );\n+ this.visitBlock(this.cx.ir.blocks.get(fallthroughId)!, blockValue);\n+ } else {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"switch\",\n+ test,\n+ cases,\n+ id: terminal.id,\n+ })\n+ );\n+ }\n+ break;\n+ }\n+ case \"while\": {\n+ const fallthroughId =\n+ terminal.fallthrough !== null &&\n+ !this.cx.isScheduled(terminal.fallthrough)\n+ ? terminal.fallthrough\n+ : null;\n+ const loopId =\n+ !this.cx.isScheduled(terminal.loop) &&\n+ terminal.loop !== terminal.fallthrough\n+ ? terminal.loop\n+ : null;\n+ const scheduleId = this.cx.scheduleLoop(\n+ terminal.fallthrough,\n+ terminal.test,\n+ terminal.loop\n+ );\n+ scheduleIds.push(scheduleId);\n+\n+ this.visitor.visitTerminalId(terminal.id);\n+ const testBlock = this.cx.ir.blocks.get(terminal.test)!;\n+ const testTerminal = testBlock.terminal;\n+ invariant(\n+ testTerminal.kind === \"if\",\n+ \"Expected while loop test block to end in an if\"\n+ );\n+ const testValue = this.visitValueBlock(blockValue, testBlock, {\n+ value: testTerminal.test,\n+ id: testTerminal.id,\n+ });\n+ let loopBody: TBlock;\n+ if (loopId) {\n+ loopBody = this.traverseBlock(this.cx.ir.blocks.get(loopId)!);\n+ } else {\n+ const break_ = this.visitBreak(terminal.loop, null);\n+ invariant(\n+ break_ !== null,\n+ \"If loop body is already scheduled it must be a break\"\n+ );\n+ const body = this.visitor.enterBlock();\n+ this.visitor.appendBlock(body, break_);\n+ loopBody = this.visitor.leaveBlock(body);\n+ }\n+\n+ this.cx.unscheduleAll(scheduleIds);\n+ if (fallthroughId !== null) {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"while\",\n+ loc: terminal.loc,\n+ test: testValue,\n+ loop: loopBody,\n+ id: terminal.id,\n+ }),\n+ fallthroughId\n+ );\n+ this.visitBlock(this.cx.ir.blocks.get(fallthroughId)!, blockValue);\n+ } else {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"while\",\n+ loc: terminal.loc,\n+ test: testValue,\n+ loop: loopBody,\n+ id: terminal.id,\n+ })\n+ );\n+ }\n+ break;\n+ }\n+ case \"for\": {\n+ const loopId =\n+ !this.cx.isScheduled(terminal.loop) &&\n+ terminal.loop !== terminal.fallthrough\n+ ? terminal.loop\n+ : null;\n+\n+ const fallthroughId =\n+ terminal.fallthrough !== null &&\n+ !this.cx.isScheduled(terminal.fallthrough)\n+ ? terminal.fallthrough\n+ : null;\n+\n+ const scheduleId = this.cx.scheduleLoop(\n+ terminal.fallthrough,\n+ terminal.update,\n+ terminal.loop\n+ );\n+ scheduleIds.push(scheduleId);\n+\n+ this.visitor.visitTerminalId(terminal.id);\n+\n+ const initBlock = this.cx.ir.blocks.get(terminal.init)!;\n+ const initTerminal = initBlock.terminal;\n+ invariant(\n+ initTerminal.kind === \"goto\",\n+ \"Expected for loop init block to end in a goto\"\n+ );\n+ const initValue = this.visitInitBlock(blockValue, initBlock);\n+\n+ const testBlock = this.cx.ir.blocks.get(terminal.test)!;\n+ const testTerminal = testBlock.terminal;\n+ invariant(\n+ testTerminal.kind === \"if\",\n+ \"Expected for loop test block to end in an if\"\n+ );\n+ const testValue = this.visitValueBlock(blockValue, testBlock, {\n+ value: testTerminal.test,\n+ id: testTerminal.id,\n+ });\n+\n+ const updateBlock = this.cx.ir.blocks.get(terminal.update)!;\n+ const updateTerminal = updateBlock.terminal;\n+ invariant(\n+ updateTerminal.kind === \"goto\",\n+ \"Expected for loop update block to end in a goto\"\n+ );\n+ const updateValue = this.visitValueBlock(blockValue, updateBlock);\n+\n+ let loopBody: TBlock;\n+ if (loopId) {\n+ loopBody = this.traverseBlock(this.cx.ir.blocks.get(loopId)!);\n+ } else {\n+ const break_ = this.visitBreak(terminal.loop, null);\n+ invariant(\n+ break_ !== null,\n+ \"If loop body is already scheduled it must be a break\"\n+ );\n+ const body = this.visitor.enterBlock();\n+ this.visitor.appendBlock(body, break_);\n+ loopBody = this.visitor.leaveBlock(body);\n+ }\n+\n+ this.cx.unscheduleAll(scheduleIds);\n+ if (fallthroughId !== null) {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"for\",\n+ init: initValue,\n+ test: testValue,\n+ update: updateValue,\n+ loop: loopBody,\n+ id: terminal.id,\n+ }),\n+ fallthroughId\n+ );\n+ this.visitBlock(this.cx.ir.blocks.get(fallthroughId)!, blockValue);\n+ } else {\n+ this.visitor.appendBlock(\n+ blockValue,\n+ this.visitor.visitTerminal({\n+ kind: \"for\",\n+ init: initValue,\n+ test: testValue,\n+ update: updateValue,\n+ loop: loopBody,\n+ id: terminal.id,\n+ })\n+ );\n+ }\n+ break;\n+ }\n+ case \"logical\": {\n+ todo(\"Implement tree visitor for logical terminal\");\n+ }\n+ case \"goto\": {\n+ this.visitor.visitTerminalId(terminal.id);\n+ switch (terminal.variant) {\n+ case GotoVariant.Break: {\n+ const break_ = this.visitBreak(terminal.block, terminal.id);\n+ if (break_ !== null) {\n+ this.visitor.appendBlock(blockValue, break_);\n+ }\n+ break;\n+ }\n+ case GotoVariant.Continue: {\n+ const continue_ = this.visitContinue(terminal.block, terminal.id);\n+ if (continue_ !== null) {\n+ this.visitor.appendBlock(blockValue, continue_);\n+ }\n+ break;\n+ }\n+ default: {\n+ assertExhaustive(\n+ terminal.variant,\n+ `Unexpected goto variant '${terminal.variant}'`\n+ );\n+ }\n+ }\n+ break;\n+ }\n+ default: {\n+ assertExhaustive(terminal, \"Unexpected terminal\");\n+ }\n+ }\n+ }\n+\n+ visitInitBlock(parent: TBlockBuilder, block: BasicBlock): TInit {\n+ const initBlock = this.visitor.enterInitBlock(parent);\n+ for (const instr of block.instructions) {\n+ const value = this.visitor.visitValue(instr.value, instr.id);\n+ const item = this.visitor.visitInstruction(instr, value);\n+ this.visitor.appendInitBlock(initBlock, item);\n+ }\n+ return this.visitor.leaveInitBlock(initBlock);\n+ }\n+\n+ visitValueBlock(\n+ parent: TBlockBuilder,\n+ block: BasicBlock,\n+ terminalValue?: { value: InstructionValue; id: InstructionId }\n+ ): TValue {\n+ const valueBlock = this.visitor.enterValueBlock(parent);\n+ const instructions = [...block.instructions];\n+ let lastValue: { value: InstructionValue; id: InstructionId } | null = null;\n+ if (terminalValue != null) {\n+ lastValue = terminalValue;\n+ }\n+ for (const instr of instructions) {\n+ const value = this.visitor.visitValue(instr.value, instr.id);\n+ const item = this.visitor.visitInstruction(instr, value);\n+ this.visitor.appendValueBlock(valueBlock, item);\n+ }\n+ const value =\n+ lastValue !== null\n+ ? this.visitor.visitValue(lastValue.value, lastValue.id)\n+ : null;\n+ return this.visitor.leaveValueBlock(valueBlock, value);\n+ }\n+\n+ emptyBlock(): TBlock {\n+ const block = this.visitor.enterBlock();\n+ return this.visitor.leaveBlock(block);\n+ }\n+\n+ visitBreak(block: BlockId, id: InstructionId | null): TStatement | null {\n+ const target = this.cx.getBreakTarget(block);\n+ if (target === null) {\n+ \/\/ TODO: we should always have a target\n+ return null;\n+ }\n+ switch (target.type) {\n+ case \"implicit\": {\n+ return this.visitor.visitImplicitTerminal();\n+ }\n+ case \"unlabeled\": {\n+ return this.visitor.visitTerminal({ kind: \"break\", label: null, id });\n+ }\n+ case \"labeled\": {\n+ return this.visitor.visitTerminal({\n+ kind: \"break\",\n+ label: target.block,\n+ id,\n+ });\n+ }\n+ }\n+ }\n+\n+ visitContinue(block: BlockId, id: InstructionId): TStatement | null {\n+ const target = this.cx.getContinueTarget(block);\n+ invariant(\n+ target !== null,\n+ `Expected continue target to be scheduled for bb${block}`\n+ );\n+ switch (target.type) {\n+ case \"labeled\": {\n+ return this.visitor.visitTerminal({\n+ kind: \"continue\",\n+ label: target.block,\n+ id,\n+ });\n+ }\n+ case \"unlabeled\": {\n+ return this.visitor.visitTerminal({\n+ kind: \"continue\",\n+ label: null,\n+ id,\n+ });\n+ }\n+ case \"implicit\": {\n+ return this.visitor.visitImplicitTerminal();\n+ }\n+ default: {\n+ assertExhaustive(\n+ target.type,\n+ `Unexpected continue target kind '${(target as any).type}'`\n+ );\n+ }\n+ }\n+ }\n+\n+ visitInstr(instr: Instruction, blockValue: TBlockBuilder): void {\n+ const value = this.visitor.visitValue(instr.value, instr.id);\n+ const item = this.visitor.visitInstruction(instr, value);\n+ this.visitor.appendBlock(blockValue, item);\n+ }\n+\n+ visitPlace(place: Place, id: InstructionId): TValue {\n+ return this.visitor.visitValue(place, id);\n+ }\n+}\n+\n+class Context {\n+ ir: HIR;\n+ #nextScheduleId: number = 0;\n+\n+ \/**\n+ * Used to track which blocks *have been* generated already in order to\n+ * abort if a block is generated a second time. This is an error catching\n+ * mechanism for debugging purposes, and is not used by the codegen algorithm\n+ * to drive decisions about how to emit blocks.\n+ *\/\n+ emitted: Set = new Set();\n+\n+ \/**\n+ * A set of blocks that are already scheduled to be emitted by eg a parent.\n+ * This allows child nodes to avoid re-emitting the same block and emit eg\n+ * a break instead.\n+ *\/\n+ #scheduled: Set = new Set();\n+\n+ \/**\n+ * Represents which control flow operations are currently in scope, with the innermost\n+ * scope last. Roughly speaking, the last ControlFlowTarget on the stack indicates where\n+ * control will implicitly transfer, such that gotos to that block can be elided. Gotos\n+ * targeting items higher up the stack may need labeled break or continue; see\n+ * getBreakTarget() and getContinueTarget() for more details.\n+ *\/\n+ #controlFlowStack: Array = [];\n+\n+ constructor(ir: HIR) {\n+ this.ir = ir;\n+ }\n+\n+ block(id: BlockId): BasicBlock {\n+ return this.ir.blocks.get(id)!;\n+ }\n+\n+ \/**\n+ * Record that the given block will be emitted (eg by the codegen of a parent node)\n+ * so that child nodes can avoid re-emitting it.\n+ *\/\n+ schedule(block: BlockId, type: \"if\" | \"switch\" | \"case\"): number {\n+ const id = this.#nextScheduleId++;\n+ invariant(\n+ !this.#scheduled.has(block),\n+ `Break block is already scheduled: bb${block}`\n+ );\n+ this.#scheduled.add(block);\n+ this.#controlFlowStack.push({ block, id, type });\n+ return id;\n+ }\n+\n+ scheduleLoop(\n+ fallthroughBlock: BlockId,\n+ continueBlock: BlockId,\n+ loopBlock: BlockId | null\n+ ): number {\n+ const id = this.#nextScheduleId++;\n+ const ownsBlock = !this.#scheduled.has(fallthroughBlock);\n+ this.#scheduled.add(fallthroughBlock);\n+ invariant(\n+ !this.#scheduled.has(continueBlock),\n+ `Continue block is already scheduled: bb${continueBlock}`\n+ );\n+ this.#scheduled.add(continueBlock);\n+ let ownsLoop = false;\n+ if (loopBlock !== null) {\n+ ownsLoop = !this.#scheduled.has(loopBlock);\n+ this.#scheduled.add(loopBlock);\n+ }\n+\n+ this.#controlFlowStack.push({\n+ block: fallthroughBlock,\n+ ownsBlock,\n+ id,\n+ type: \"loop\",\n+ continueBlock,\n+ loopBlock,\n+ ownsLoop,\n+ });\n+ return id;\n+ }\n+\n+ \/**\n+ * Removes a block that was scheduled; must be called after that block is emitted.\n+ *\/\n+ unschedule(scheduleId: number): void {\n+ const last = this.#controlFlowStack.pop();\n+ invariant(\n+ last !== undefined && last.id === scheduleId,\n+ \"Can only unschedule the last target\"\n+ );\n+ if (last.type !== \"loop\" || last.ownsBlock !== null) {\n+ this.#scheduled.delete(last.block);\n+ }\n+ if (last.type === \"loop\") {\n+ this.#scheduled.delete(last.continueBlock);\n+ if (last.ownsLoop && last.loopBlock !== null) {\n+ this.#scheduled.delete(last.loopBlock);\n+ }\n+ }\n+ }\n+\n+ \/**\n+ * Helper to unschedule multiple scheduled blocks. The ids should be in\n+ * the order in which they were scheduled, ie most recently scheduled last.\n+ *\/\n+ unscheduleAll(scheduleIds: Array): void {\n+ for (let i = scheduleIds.length - 1; i >= 0; i--) {\n+ this.unschedule(scheduleIds[i]!);\n+ }\n+ }\n+\n+ \/**\n+ * Check if the given @param block is scheduled or not.\n+ *\/\n+ isScheduled(block: BlockId): boolean {\n+ return this.#scheduled.has(block);\n+ }\n+\n+ \/**\n+ * Given the current control flow stack, determines how a `break` to the given @param block\n+ * must be emitted. Returns as follows:\n+ * - 'implicit' if control would implicitly transfer to that block\n+ * - 'labeled' if a labeled break is required to transfer control to that block\n+ * - 'unlabeled' if an unlabeled break would transfer to that block\n+ * - null if there is no information for this block\n+ *\n+ * The returned 'block' value should be used as the label if necessary.\n+ *\/\n+ getBreakTarget(\n+ block: BlockId\n+ ): { block: BlockId; type: ControlFlowKind } | null {\n+ let hasPrecedingLoop = false;\n+ for (let i = this.#controlFlowStack.length - 1; i >= 0; i--) {\n+ const target = this.#controlFlowStack[i]!;\n+ if (target.block === block) {\n+ let type: ControlFlowKind;\n+ if (target.type === \"loop\") {\n+ \/\/ breaking out of a loop requires an explicit break,\n+ \/\/ but only requires a label if breaking past the innermost loop.\n+ type = hasPrecedingLoop ? \"labeled\" : \"unlabeled\";\n+ } else if (i === this.#controlFlowStack.length - 1) {\n+ \/\/ breaking to the last break point, which is where control will transfer\n+ \/\/ implicitly\n+ type = \"implicit\";\n+ } else {\n+ \/\/ breaking somewhere else requires an explicit break\n+ type = \"labeled\";\n+ }\n+ return {\n+ block: target.block,\n+ type,\n+ };\n+ }\n+ hasPrecedingLoop ||= target.type === \"loop\";\n+ }\n+ return null;\n+ }\n+\n+ \/**\n+ * Given the current control flow stack, determines how a `continue` to the given @param block\n+ * must be emitted. Returns as follows:\n+ * - 'implicit' if control would implicitly continue to that block\n+ * - 'labeled' if a labeled continue is required to continue to that block\n+ * - 'unlabeled' if an unlabeled continue would transfer to that block\n+ * - null if there is no information for this block\n+ *\n+ * The returned 'block' value should be used as the label if necessary.\n+ *\/\n+ getContinueTarget(\n+ block: BlockId\n+ ): { block: BlockId; type: ControlFlowKind } | null {\n+ let hasPrecedingLoop = false;\n+ for (let i = this.#controlFlowStack.length - 1; i >= 0; i--) {\n+ const target = this.#controlFlowStack[i]!;\n+ if (target.type == \"loop\" && target.continueBlock === block) {\n+ let type: ControlFlowKind;\n+ if (hasPrecedingLoop) {\n+ \/\/ continuing to a loop that is not the innermost loop always requires\n+ \/\/ a label\n+ type = \"labeled\";\n+ } else if (i === this.#controlFlowStack.length - 1) {\n+ \/\/ continuing to the last break point, which is where control will\n+ \/\/ transfer to naturally\n+ type = \"implicit\";\n+ } else {\n+ \/\/ the continue is inside some conditional logic, requires an explicit\n+ \/\/ continue\n+ type = \"unlabeled\";\n+ }\n+ return {\n+ block: target.block,\n+ type,\n+ };\n+ }\n+ hasPrecedingLoop ||= target.type === \"loop\";\n+ }\n+ return null;\n+ }\n+\n+ debugBreakTargets(): Array {\n+ return this.#controlFlowStack.map((target) => ({ ...target }));\n+ }\n+}\n+\n+type ControlFlowKind = \"implicit\" | \"labeled\" | \"unlabeled\";\n+\n+type ControlFlowTarget =\n+ | { type: \"if\"; block: BlockId; id: number }\n+ | { type: \"switch\"; block: BlockId; id: number }\n+ | { type: \"case\"; block: BlockId; id: number }\n+ | {\n+ type: \"loop\";\n+ block: BlockId;\n+ ownsBlock: boolean;\n+ continueBlock: BlockId;\n+ loopBlock: BlockId | null;\n+ ownsLoop: boolean;\n+ id: number;\n+ };\n+\n+\/**\n+ * An object that can receive structured callbacks to visit HIR as a tree,\n+ * and convert it to an alternate format.\n+ *\n+ * TBlock = representation of a list of statements\n+ * TValue = represenation of an InstructionValue\n+ * TStatement = representation of an Instruction\n+ * TCase = representation of a switch case\n+ *\/\n+export interface Visitor<\n+ TBlockBuilder,\n+ TBlock,\n+ TInit,\n+ TValueBlock,\n+ TValue,\n+ TStatement,\n+ TCase\n+> {\n+ \/**\n+ * Must create an \"empty\" instance of the visitor's represenation for\n+ * the contents of a block.\n+ *\/\n+ enterBlock(): TBlockBuilder;\n+\n+ \/**\n+ * Appends an item onto the given block, with an optional label. The label\n+ * indicates that a break\/continue will proceed to code *after* the given item.\n+ *\/\n+ appendBlock(block: TBlockBuilder, item: TStatement, label?: BlockId): void;\n+\n+ \/**\n+ * Converts the visitor's block representation into the representation of a\n+ * block item, simultaneously \"closing\" the given block. The block will no\n+ * longer be modified by the visitor driver.\n+ *\/\n+ leaveBlock(block: TBlockBuilder): TBlock;\n+\n+ \/**\n+ * Must create an \"empty\" instance of the visitor's representation for a value\n+ * block, which can generally contain only expressions but not statements. The\n+ * currently active parent block is passed as an argument.\n+ *\n+ * The exception is the for initializer, which may contain declarations but not\n+ * other statement types.\n+ *\/\n+ enterValueBlock(block: TBlockBuilder): TValueBlock;\n+\n+ \/**\n+ * Appends an item onto the given value block.\n+ *\/\n+ appendValueBlock(block: TValueBlock, item: TStatement): void;\n+\n+ \/**\n+ * Converts the visitor's value block (and final value) to the visitor's\n+ * value representation.\n+ *\/\n+ leaveValueBlock(block: TValueBlock, value: TValue | null): TValue;\n+\n+ enterInitBlock(block: TBlockBuilder): TValueBlock;\n+\n+ appendInitBlock(block: TValueBlock, item: TStatement): void;\n+\n+ leaveInitBlock(block: TValueBlock): TInit;\n+\n+ \/**\n+ * Convert an InstructionValue into the visitor's own representation\n+ * of a value.\n+ *\/\n+ visitValue(value: InstructionValue, id: InstructionId): TValue;\n+\n+ \/**\n+ * Convert an Instruction into the visitor's own representation of\n+ * a block item.\n+ *\/\n+ visitInstruction(instruction: Instruction, value: TValue): TStatement;\n+\n+ \/**\n+ * Called when a terminal is reached, before processing any of its\n+ * possible branches.\n+ *\/\n+ visitTerminalId(id: InstructionId): void;\n+\n+ \/**\n+ * Converts a break\/continue that is implicit — that does not strictly\n+ * have to be emitted — to the visitor's representation. The visitor\n+ * can choose to return null if this does not need to be represented.\n+ *\/\n+ visitImplicitTerminal(): TStatement | null;\n+\n+ \/**\n+ * Converts a terminal into the visitor's own representation of a block\n+ * item. Note that the terminal differs from HIR Terminals, because\n+ * values and block ids will have already been converted into the visitor's\n+ * own representations.\n+ *\/\n+ visitTerminal(\n+ terminal: BlockTerminal\n+ ): TStatement;\n+\n+ \/**\n+ * Visits a switch case statement, which is collected into a switch terminal\n+ * variant.\n+ *\/\n+ visitCase(test: TValue | null, block: TBlock): TCase;\n+}\n+\n+export type BlockTerminal =\n+ | {\n+ kind: \"return\";\n+ loc: SourceLocation;\n+ value: TValue | null;\n+ id: InstructionId;\n+ }\n+ | { kind: \"throw\"; value: TValue; id: InstructionId }\n+ | {\n+ kind: \"if\";\n+ test: TValue;\n+ consequent: TBlock;\n+ alternate: TBlock | null;\n+ id: InstructionId;\n+ }\n+ | { kind: \"switch\"; test: TValue; cases: Array; id: InstructionId }\n+ | {\n+ kind: \"while\";\n+ loc: SourceLocation;\n+ test: TValue;\n+ loop: TBlock;\n+ id: InstructionId;\n+ }\n+ | {\n+ kind: \"for\";\n+ init: TInit;\n+ test: TValue;\n+ update: TValue;\n+ loop: TBlock;\n+ id: InstructionId;\n+ }\n+ | { kind: \"break\"; label: BlockId | null; id: InstructionId | null }\n+ | { kind: \"continue\"; label: BlockId | null; id: InstructionId };\ndiff --git a\/compiler\/forget\/src\/ReactiveScopes\/BuildReactiveFunctionWithoutScopes.ts b\/compiler\/forget\/src\/ReactiveScopes\/BuildReactiveFunctionWithoutScopes.ts\nindex fb489370fb..690c932d0b 100644\n--- a\/compiler\/forget\/src\/ReactiveScopes\/BuildReactiveFunctionWithoutScopes.ts\n+++ b\/compiler\/forget\/src\/ReactiveScopes\/BuildReactiveFunctionWithoutScopes.ts\n@@ -19,7 +19,11 @@ import {\n ReactiveTerminal,\n ReactiveValueBlock,\n } from \"..\/HIR\/HIR\";\n-import { BlockTerminal, Visitor, visitTree } from \"..\/HIR\/HIRTreeVisitor\";\n+import {\n+ BlockTerminal,\n+ Visitor,\n+ visitTreeForReactiveFunction as visitTree,\n+} from \"..\/HIR\/ReactiveFunctionVisitor\";\n import { assertExhaustive } from \"..\/Utils\/utils\";\n \n export function buildReactiveFunction(fn: HIRFunction): ReactiveFunction {\n"}

dillon1000/react

Files changed