Method _dry_run_compile

marimo/_code_mode/_context.py:1542–1644

Compile and graph-check every op before mutating real state. For each op with code: 1. `compile_cell` — validates syntax, extracts defs/refs. 2. Temporarily register in the graph to detect multiply-defined names and cycles. 3. Always clean up so the graph

(self, ops: list[_Op])

    # ------------------------------------------------------------------

    def _dry_run_compile(self, ops: list[_Op]) -> None:
        """Compile and graph-check every op before mutating real state.

        For each op with code:
        1. `compile_cell` — validates syntax, extracts defs/refs.
        2. Temporarily register in the graph to detect multiply-defined
           names and cycles.
        3. Always clean up so the graph is left unchanged.

        Raises `SyntaxError` for invalid code or `RuntimeError` for
        graph conflicts (multiply-defined names, cycles).
        """
        graph = self.graph
        registered: list[CellId_t] = []
        # For updates we must evict the old cell first; remember it
        # so we can restore on cleanup.
        evicted: dict[CellId_t, CellImpl] = {}

        # Snapshot cell order before any mutations so we can restore it.
        # The evict/re-register cycle appends cells to the end of the
        # dict, which corrupts the ordering that _apply_ops relies on.
        original_order = list(graph.cells.keys())

        # Snapshot existing problems so we only flag *new* ones.
        existing_multiply_defined = set(graph.get_multiply_defined())
        existing_cycles = set(graph.cycles)

        try:
            for op in ops:
                # For deletes, evict the cell so its defs don't conflict
                # with later adds/updates that reuse the same names.
                if isinstance(op, _DeleteOp):
                    cell_id = op.cell_id
                    if cell_id in graph.cells:
                        evicted[cell_id] = graph.cells[cell_id]
                        graph.delete_cell(cell_id)
                    continue

                code: str | None = getattr(op, "code", None)
                if code is None:
                    continue

                cell_id = op.cell_id

                # For updates, temporarily remove the existing cell so the
                # new version can be registered in its place.
                if isinstance(op, _UpdateOp) and cell_id in graph.cells:
                    evicted[cell_id] = graph.cells[cell_id]
                    graph.delete_cell(cell_id)

                cell = compile_cell(code, cell_id=cell_id)
                graph.register_cell(cell_id, cell)
                registered.append(cell_id)

            # Only error on problems *introduced* by these ops.
            new_multiply_defined = (
                set(graph.get_multiply_defined()) - existing_multiply_defined
            )