Pass callables as arguments end-to-end through defunctionalization by idavis · Pull Request #3410 · microsoft/qdk

idavis · 2026-06-29T22:52:28Z

Summary

In Q#, you can hand one operation or function to another as a value - for example passing AllH into InvokeWithQubits, or building a little function on the fly like Rz(theta, _) and passing that.

Hardware and the QIR output format can't deal with "a function as a value at runtime" - every call has to point at a specific, known target. So the compiler has a stage called defunctionalization whose job is to look at each place a function-value is used and rewrite it into a plain, direct call to the real target. This branch makes that stage dramatically more capable and fixes a pile of cases where it previously produced wrong code, crashed, or gave up.

The bugs fixed

1. Only one function-argument at a time.
When an operation took several function arguments (e.g. InvokeThree(first, second, third)), the compiler couldn't resolve them all together if there was captured state. This branch handles multiple function-arguments to the same call in a single pass.

2. Closures and "partially applied" functions didn't survive.
Things like Rz(theta, _) or x -> x + inc capture a value (theta, inc) and carry it around. Passing these, especially a closure that wraps another closure, often failed or lost the captured value. Now the captured values are correctly threaded through as extra arguments, including nested cases.

3. Passing a function from Python as a top-level argument produced broken QIR/circuits.
When you called qsharp.compile(InvokeWithQubits, 3, AllH) from Python, the function-value created by the interpreter carried stale internal type information. Once that value became part of the program to compile, it violated the compiler's own consistency checks. The fix normalizes those type signatures before compiling, so QIR generation and circuit drawing now work from Python-supplied callables.

4. Generic functions behind a closure weren't specialized.
A closure like Rz(theta, _) points at a generic library operation. Monomorphization only fixed up direct calls, not closures. It now also rewrites closure targets, so the concrete version actually gets created.

5. Arrays of functions and index-based dispatch.
Selecting a function out of an array (ops[i]) - including arrays of closures, tuples, and functions stored in record fields, now correctly turns into an if/else that dispatches to the right target, evaluating the index only once.

6. Wrong answers from reassignment and control-flow tracking.
The stage tracks "which function does this variable actually hold at this point." Several cases were wrong:

A reassignment (f = Bar;) buried inside a sub-expression wasn't noticed in the right order.
Reassignments on the never-executed side of and/or/and= short-circuits were wrongly applied.
w/ update expressions were evaluated in the wrong order.
Reassignment inside a loop is now correctly treated as "unknown," producing a clear error instead of silently mis-specializing.
A function chosen conditionally (if cond { X } else { Y }) now becomes proper branch-by-branch dispatch instead of dropping a branch.

7. Side effects running twice.
When a function was selected by a condition that itself did something (e.g. a measurement), that side effect could be emitted more than once. Coordinating with the condition-normalization stage ensures each side effect runs exactly once.

8. Dynamic Angle return in std lib.
The angle calculations for custom gates in OpenQASM hit an issue where partial evaluation cannot lower a dynamic branch that returns an Angle struct. The calculation is now done inline eliminating the dynamic Angle return during construction.

The Fixes

Rather than the textbook approach using dispatch tables and dynamic dispatch, we must use specialization: for each call site where it can figure out the concrete function being passed, it makes a dedicated copy of the higher-order operation with the function-argument baked in as a direct call. Apply(q => Y(q), target) becomes a call to a generated Apply_specialized_Y. This is required for QIR profiles as they don't support runtime resloved calls.

To do that reliably, the branch:

Analyzes data flow more precisely - it tracks, at each program point and even inside sub-expressions, which concrete function a variable holds, correctly accounting for reassignments, branches, loops, and short-circuit evaluation.
Threads captured values through - a closure's captured data is passed as ordinary extra arguments to the specialized copy, and consumed closures are blanked out so the pass knows it's finished (this is what lets it converge).
Resolves indirect sources - functions coming from array indices, record fields, function return values, and partial applications are traced back to their concrete target.
Fixes the surrounding pipeline - monomorphization now specializes generic closure targets, argument-promotion keeps closure-call signatures stable, and the interpreter-to-QIR path normalizes callable type signatures so entry-point function arguments compile cleanly to QIR and circuits.

The large test additions (Rust snapshot tests plus a new test_callable_passing.py) lock in every scenario above: Python<=>Q# callables, closures with distinct captures, nested closures, and end-to-end QIR/circuit output.

github-actions · 2026-07-05T16:04:31Z