guppylang-internals 0.21.0__py3-none-any.whl

guppylang_internals/std/_internal/debug.py

@@ -0,0 +1,95 @@
+import ast
+from dataclasses import dataclass
+from typing import ClassVar, cast
+
+from guppylang_internals.ast_util import with_loc
+from guppylang_internals.checker.errors.generic import ExpectedError
+from guppylang_internals.checker.errors.type_errors import WrongNumberOfArgsError
+from guppylang_internals.checker.expr_checker import (
+    ExprChecker,
+    ExprSynthesizer,
+    synthesize_call,
+)
+from guppylang_internals.definition.custom import CustomCallChecker
+from guppylang_internals.definition.ty import TypeDef
+from guppylang_internals.diagnostic import Error
+from guppylang_internals.error import GuppyTypeError
+from guppylang_internals.nodes import StateResultExpr
+from guppylang_internals.std._internal.checker import TAG_MAX_LEN, TooLongError
+from guppylang_internals.tys.builtin import (
+    get_array_length,
+    get_element_type,
+    is_array_type,
+    string_type,
+)
+from guppylang_internals.tys.ty import (
+    FuncInput,
+    FunctionType,
+    InputFlags,
+    NoneType,
+    Type,
+)
+
+
+class StateResultChecker(CustomCallChecker):
+    """Call checker for the `state_result` function."""
+
+    @dataclass(frozen=True)
+    class MissingQubitsError(Error):
+        title: ClassVar[str] = "Missing qubit inputs"
+        span_label: ClassVar[str] = (
+            "Qubits whose state should be reported must be passed explicitly"
+        )
+
+    def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
+        tag, _ = ExprChecker(self.ctx).check(args[0], string_type())
+        if not isinstance(tag, ast.Constant) or not isinstance(tag.value, str):
+            raise GuppyTypeError(ExpectedError(tag, "a string literal"))
+        if len(tag.value.encode("utf-8")) > TAG_MAX_LEN:
+            err: Error = TooLongError(tag)
+            err.add_sub_diagnostic(TooLongError.Hint(None))
+            raise GuppyTypeError(err)
+        syn_args: list[ast.expr] = [tag]
+
+        if len(args) < 2:
+            raise GuppyTypeError(self.MissingQubitsError(self.node))
+
+        from guppylang.defs import GuppyDefinition
+        from guppylang.std.quantum import qubit
+
+        assert isinstance(qubit, GuppyDefinition)
+        qubit_ty = cast(TypeDef, qubit.wrapped).check_instantiate([])
+
+        array_len = None
+        arg, ty = ExprSynthesizer(self.ctx).synthesize(args[1])
+        if is_array_type(ty):
+            if len(args) > 2:
+                err = WrongNumberOfArgsError(args[2], 2, len(args))
+                raise GuppyTypeError(err)
+            element_ty = get_element_type(ty)
+            if not element_ty == qubit_ty:
+                raise GuppyTypeError(ExpectedError(arg, "an array of qubits"))
+            syn_args.append(arg)
+            func_ty = FunctionType(
+                [
+                    FuncInput(string_type(), InputFlags.NoFlags),
+                    FuncInput(ty, InputFlags.Inout),
+                ],
+                NoneType(),
+            )
+            array_len = get_array_length(ty)
+        else:
+            for arg in args[1:]:
+                qbt, _ = ExprChecker(self.ctx).check(arg, qubit_ty)
+                syn_args.append(qbt)
+            func_ty = FunctionType(
+                [FuncInput(string_type(), InputFlags.NoFlags)]
+                + [FuncInput(qubit_ty, InputFlags.Inout)] * len(args[1:]),
+                NoneType(),
+            )
+        args, ret_ty, inst = synthesize_call(func_ty, syn_args, self.node, self.ctx)
+        assert len(inst) == 0, "func_ty is not generic"
+        node = StateResultExpr(
+            tag=tag.value, args=args, func_ty=func_ty, array_len=array_len
+        )
+        return with_loc(self.node, node), ret_ty

guppylang_internals/std/_internal/util.py

@@ -0,0 +1,271 @@
+"""Utilities for defining builtin functions.
+
+Note: These custom definitions will be replaced with direct extension operation
+definitions from the hugr library.
+"""
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+import hugr.std.collections.list
+import hugr.std.float
+import hugr.std.int
+import hugr.std.logic
+from hugr import ext as he
+from hugr import ops
+from hugr import tys as ht
+
+from guppylang_internals.compiler.hugr_extension import UnsupportedOp
+from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool
+from guppylang_internals.std._internal.compiler.tket_exts import (
+    BOOL_EXTENSION,
+    QUANTUM_EXTENSION,
+)
+from guppylang_internals.tys.common import ToHugrContext
+from guppylang_internals.tys.subst import Inst
+from guppylang_internals.tys.ty import NumericType
+
+if TYPE_CHECKING:
+    from guppylang_internals.tys.arg import Argument
+
+
+def int_arg(n: int = NumericType.INT_WIDTH) -> ht.TypeArg:
+    """A bounded int type argument."""
+    return ht.BoundedNatArg(n=n)
+
+
+def type_arg(idx: int = 0, bound: ht.TypeBound = ht.TypeBound.Linear) -> ht.TypeArg:
+    """A generic type argument."""
+    return ht.VariableArg(idx=idx, param=ht.TypeTypeParam(bound=bound))
+
+
+def make_concrete_arg(
+    arg: ht.TypeArg,
+    inst: Inst,
+    ctx: ToHugrContext,
+    variable_remap: dict[int, int] | None = None,
+) -> ht.TypeArg:
+    """Makes a concrete hugr type argument using a guppy instantiation.
+
+    Args:
+        arg: The hugr type argument to make concrete, containing variable arguments.
+        inst: The guppy instantiation of the type arguments.
+        ctx: Context for the Guppy to Hugr type conversion.
+        variable_remap: A mapping from the hugr param variable indices to
+            de Bruijn indices in the guppy type. Defaults to identity.
+    """
+    remap = variable_remap or {}
+
+    if isinstance(arg, ht.VariableArg) and remap.get(arg.idx, arg.idx) < len(inst):
+        concrete_arg: Argument = inst[remap.get(arg.idx, arg.idx)]
+        return concrete_arg.to_hugr(ctx)
+    return arg
+
+
+def external_op(
+    name: str,
+    args: list[ht.TypeArg],
+    ext: he.Extension,
+    *,
+    variable_remap: dict[int, int] | None = None,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Custom hugr operation
+
+    Args:
+        op_name: The name of the operation.
+        args: The type arguments of the operation.
+        ext: The extension of the operation.
+        variable_remap: A mapping from the hugr param variable indices to
+            de Bruijn indices in the guppy type. Defaults to identity.
+
+    Returns:
+        A function that takes an instantiation of the type arguments as well as
+        the inferred input and output types and returns a concrete HUGR op.
+    """
+    op_def = ext.get_op(name)
+
+    def op(ty: ht.FunctionType, inst: Inst, ctx: ToHugrContext) -> ops.DataflowOp:
+        concrete_args = [
+            make_concrete_arg(arg, inst, ctx, variable_remap) for arg in args
+        ]
+        return op_def.instantiate(concrete_args, ty)
+
+    return op
+
+
+def float_op(
+    op_name: str,
+    ext: he.Extension = hugr.std.float.FLOAT_OPS_EXTENSION,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Utility method to create Hugr float arithmetic ops.
+
+    Args:
+        op_name: The name of the operation.
+        ext: The extension of the operation.
+
+    Returns:
+        A function that takes an instantiation of the type arguments and returns
+        a concrete HUGR op.
+    """
+    return external_op(op_name, args=[], ext=ext, variable_remap=None)
+
+
+def int_op(
+    op_name: str,
+    ext: he.Extension = hugr.std.int.INT_OPS_EXTENSION,
+    n_vars: int = 1,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Utility method to create Hugr integer arithmetic ops.
+
+    Args:
+        op_name: The name of the operation.
+        ext: The extension of the operation.
+        n_vars: The number of type arguments. Defaults to 1.
+
+    Returns:
+        A function that takes an instantiation of the type arguments and returns
+        a concrete HUGR op.
+    """
+    # Ideally we'd be able to derive the arguments from the input/output types,
+    # but the amount of variables does not correlate with the signature for the
+    # integer ops in hugr :/
+    # https://github.com/CQCL/hugr/blob/bfa13e59468feb0fc746677ea3b3a4341b2ed42e/hugr-core/src/std_extensions/arithmetic/int_ops.rs#L116
+    #
+    # For now, we just instantiate every type argument to a 64-bit integer.
+    args: list[ht.TypeArg] = [int_arg() for _ in range(n_vars)]
+
+    return external_op(
+        op_name,
+        args=args,
+        ext=ext,
+        variable_remap=None,
+    )
+
+
+def logic_op(
+    op_name: str,
+    parametric_size: bool = False,
+    ext: he.Extension = hugr.std.logic.EXTENSION,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Utility method to create Hugr logic ops.
+
+    If `parametric_size` is True, the generated operations has a single argument
+    encoding the number of boolean inputs to the operation.
+
+    args:
+        op_name: The name of the operation.
+        parametric_size: Whether the input count is a parameter to the operation.
+        ext: The extension of the operation.
+
+    Returns:
+        A function that takes an instantiation of the type arguments and returns
+        a concrete HUGR op.
+    """
+    op_def = ext.get_op(op_name)
+
+    def op(ty: ht.FunctionType, inst: Inst, ctx: ToHugrContext) -> ops.DataflowOp:
+        args = [int_arg(len(ty.input))] if parametric_size else []
+        return ops.ExtOp(
+            op_def,
+            ty,
+            args,
+        )
+
+    return op
+
+
+def list_op(
+    op_name: str,
+    ext: he.Extension = hugr.std.collections.list.EXTENSION,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Utility method to create Hugr list ops.
+
+    Args:
+        op_name: The name of the operation.
+        ext: The extension of the operation.
+
+    Returns:
+        A function that takes an instantiation of the type arguments and returns
+        a concrete HUGR op.
+    """
+    op_def = ext.get_op(op_name)
+
+    def op(ty: ht.FunctionType, inst: Inst, ctx: ToHugrContext) -> ops.DataflowOp:
+        return ops.ExtOp(
+            op_def,
+            ty,
+            [arg.to_hugr(ctx) for arg in inst],
+        )
+
+    return op
+
+
+def quantum_op(
+    op_name: str,
+    ext: he.Extension = QUANTUM_EXTENSION,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Utility method to create Hugr quantum ops.
+
+    args:
+        op_name: The name of the operation.
+        ext: The extension of the operation.
+
+    Returns:
+        A function that takes an instantiation of the type arguments and returns
+        a concrete HUGR op.
+    """
+    op_def = ext.get_op(op_name)
+
+    def op(ty: ht.FunctionType, inst: Inst, ctx: ToHugrContext) -> ops.DataflowOp:
+        return ops.ExtOp(
+            op_def,
+            ty,
+            args=[],
+        )
+
+    return op
+
+
+def unsupported_op(
+    op_name: str,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Utility method to define not-yet-implemented operations.
+
+    Args:
+        op_name: The name of the operation to define.
+
+    Returns:
+        A function that takes an instantiation of the type arguments as well as
+        the inferred input and output types and returns a concrete HUGR op.
+    """
+
+    def op(ty: ht.FunctionType, inst: Inst, ctx: ToHugrContext) -> ops.DataflowOp:
+        return UnsupportedOp(
+            op_name=op_name,
+            inputs=ty.input,
+            outputs=ty.output,
+        )
+
+    return op
+
+
+def bool_logic_op(
+    op_name: str,
+) -> Callable[[ht.FunctionType, Inst, ToHugrContext], ops.DataflowOp]:
+    """Utility method to create binary `tket.bool` logic ops.
+
+    args:
+        op_name: The name of the operation.
+
+    Returns:
+        A function that takes an instantiation of the type arguments and returns
+        a concrete HUGR op.
+    """
+
+    def op(ty: ht.FunctionType, inst: Inst, ctx: ToHugrContext) -> ops.DataflowOp:
+        return ops.ExtOp(
+            BOOL_EXTENSION.get_op(op_name),
+            ht.FunctionType([OpaqueBool, OpaqueBool], [OpaqueBool]),
+        )
+
+    return op

guppylang_internals/tracing/builtins_mock.py

@@ -0,0 +1,62 @@
+"""Mocks for a number of builtin functions to be used during tracing.
+
+For example, the builtin `int(x)` function tries calling `x.__int__()` and raises a
+`TypeError` if this call doesn't return an `int`. During tracing however, we also want
+to allow `int(x)` if `x` is an abstract `GuppyObject`. To allow this, we need to mock
+the builtins to avoid raising the `TypeError` in that case.
+"""
+
+import builtins
+from collections.abc import Callable
+from typing import Any
+
+from guppylang_internals.tracing.object import GuppyObject, GuppyStructObject
+
+
+def _mock_meta(cls: type) -> type:
+    """Returns a metaclass that replicates the behaviour of the provided class.
+
+    The only way to distinguishing a `_mock_meta(T)` from an actual `T` is via checking
+    reference equality using the `is` operator.
+    """
+
+    class MockMeta(type):
+        def __instancecheck__(self, instance: Any) -> bool:
+            return cls.__instancecheck__(instance)
+
+        def __subclasscheck__(self, subclass: type) -> bool:
+            return cls.__subclasscheck__(subclass)
+
+        def __eq__(self, other: object) -> Any:
+            return other == cls
+
+        def __ne__(self, other: object) -> Any:
+            return other != cls
+
+    MockMeta.__name__ = type.__name__
+    MockMeta.__qualname__ = type.__qualname__
+    return MockMeta
+
+
+class float(builtins.float, metaclass=_mock_meta(builtins.float)):  # type: ignore[misc]
+    def __new__(cls, x: Any = 0.0, /) -> Any:
+        if isinstance(x, GuppyObject):
+            return x.__float__()
+        return builtins.float(x)
+
+
+class int(builtins.int, metaclass=_mock_meta(builtins.int)):  # type: ignore[misc]
+    def __new__(cls, x: Any = 0, /, **kwargs: Any) -> Any:
+        if isinstance(x, GuppyObject):
+            return x.__int__(**kwargs)
+        return builtins.int(x, **kwargs)
+
+
+def len(x: Any) -> Any:
+    if isinstance(x, GuppyObject | GuppyStructObject):
+        return x.__len__()
+    return builtins.len(x)
+
+
+def mock_builtins(f: Callable[..., Any]) -> None:
+    f.__globals__.update({"float": float, "int": int, "len": len})

guppylang_internals/tracing/frozenlist.py

@@ -0,0 +1,57 @@
+from typing import Any
+
+from typing_extensions import Self
+
+from guppylang_internals.error import GuppyComptimeError
+
+ERROR_MSG = (
+    "This list is an owned function argument. Therefore, this mutation won't be "
+    "visible to the caller. Consider calling `copy()` to obtain a mutable local copy "
+    "of this list."
+)
+
+
+class frozenlist(list):  # type: ignore[type-arg]
+    """An immutable list subclass.
+
+    Raises a `GuppyComptimeError` for any operation that would mutate the list.
+    """
+
+    def append(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def copy(self) -> Any:
+        return list(self)
+
+    def clear(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def extend(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def insert(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def pop(self, *args: Any, **kwargs: Any) -> Any:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def remove(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def reverse(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def sort(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def __delitem__(self, *args: Any, **kwargs: Any) -> None:
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def __iadd__(self, *args: Any, **kwargs: Any) -> Self:  # type: ignore[misc]
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def __imul__(self, *args: Any, **kwargs: Any) -> Self:  # type: ignore[misc]
+        raise GuppyComptimeError(ERROR_MSG)
+
+    def __setitem__(self, key: Any, value: Any) -> Any:
+        raise GuppyComptimeError(ERROR_MSG)

guppylang_internals/tracing/function.py

@@ -0,0 +1,186 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from hugr import ops
+from hugr.build.dfg import DfBase
+
+from guppylang_internals.ast_util import AstNode, with_loc, with_type
+from guppylang_internals.cfg.builder import tmp_vars
+from guppylang_internals.checker.core import ComptimeVariable, Context, Locals, Variable
+from guppylang_internals.checker.errors.type_errors import TypeMismatchError
+from guppylang_internals.compiler.core import CompilerContext, DFContainer
+from guppylang_internals.compiler.expr_compiler import ExprCompiler
+from guppylang_internals.definition.value import CallableDef
+from guppylang_internals.diagnostic import Error
+from guppylang_internals.error import GuppyComptimeError, GuppyError, exception_hook
+from guppylang_internals.nodes import PlaceNode
+from guppylang_internals.tracing.builtins_mock import mock_builtins
+from guppylang_internals.tracing.object import GuppyObject
+from guppylang_internals.tracing.state import (
+    TracingState,
+    get_tracing_state,
+    set_tracing_state,
+)
+from guppylang_internals.tracing.unpacking import (
+    P,
+    guppy_object_from_py,
+    unpack_guppy_object,
+    update_packed_value,
+)
+from guppylang_internals.tracing.util import capture_guppy_errors, tracing_except_hook
+from guppylang_internals.tys.ty import FunctionType, InputFlags, type_to_row, unify
+
+if TYPE_CHECKING:
+    import ast
+
+    from hugr import Wire
+
+
+@dataclass(frozen=True)
+class TracingReturnError(Error):
+    title: ClassVar[str] = "Error in comptime function return"
+    message: ClassVar[str] = "{msg}"
+    msg: str
+
+
+def trace_function(
+    python_func: Callable[..., Any],
+    ty: FunctionType,
+    builder: DfBase[P],
+    ctx: CompilerContext,
+    node: AstNode,
+) -> None:
+    """Kicks off tracing of a function.
+
+    Invokes the passed Python callable and constructs the corresponding Hugr using the
+    passed builder.
+    """
+    state = TracingState(ctx, DFContainer(builder, ctx, {}), node)
+    with set_tracing_state(state):
+        inputs = [
+            unpack_guppy_object(
+                GuppyObject(inp.ty, wire),
+                builder,
+                # Function inputs are only allowed to be mutable if they are borrowed.
+                # For owned arguments, mutation wouldn't be observable by the caller,
+                # thus breaking the semantics expected from Python.
+                frozen=InputFlags.Inout not in inp.flags,
+            )
+            for wire, inp in zip(builder.inputs(), ty.inputs, strict=True)
+        ]
+
+        with exception_hook(tracing_except_hook):
+            mock_builtins(python_func)
+            py_out = python_func(*inputs)
+
+        try:
+            out_obj = guppy_object_from_py(py_out, builder, node, ctx)
+        except GuppyComptimeError as err:
+            # Error in the return statement. For example, this happens if users
+            # try to return a struct with invalid field values or there is a linearity
+            # violation.
+            raise GuppyError(TracingReturnError(node, str(err))) from None
+
+        # Check that the output type is correct
+        if unify(out_obj._ty, ty.output, {}) is None:
+            raise GuppyError(
+                TypeMismatchError(node, ty.output, out_obj._ty, "return value")
+            )
+
+        # Unpack regular returns
+        out_tys = type_to_row(out_obj._ty)
+        if len(out_tys) > 1:
+            regular_returns: list[Wire] = list(
+                builder.add_op(ops.UnpackTuple(), out_obj._use_wire(None)).outputs()
+            )
+        elif len(out_tys) > 0:
+            regular_returns = [out_obj._use_wire(None)]
+        else:
+            regular_returns = []
+
+        # Compute the inout extra outputs
+        inout_returns = []
+        assert ty.input_names is not None
+        for inout_obj, inp, name in zip(inputs, ty.inputs, ty.input_names, strict=True):
+            if InputFlags.Inout in inp.flags:
+                err_prefix = (
+                    f"Argument `{name}` is borrowed, so it is implicitly returned to "
+                    f"the caller. "
+                )
+                try:
+                    obj = guppy_object_from_py(inout_obj, builder, node, ctx)
+                    inout_returns.append(obj._use_wire(None))
+                except GuppyComptimeError as err:
+                    msg = str(err)
+                    if not msg.endswith("."):
+                        msg += "."
+                    e = TracingReturnError(node, err_prefix + msg)
+                    raise GuppyError(e) from None
+                # Also check that the type hasn't changed (for example, the user could
+                # have changed the length of an array, thus changing its type)
+                if obj._ty != inp.ty:
+                    msg = (
+                        f"{err_prefix}Expected it to have type `{inp.ty}`, but got "
+                        f"`{obj._ty}`."
+                    )
+                    e = TracingReturnError(node, msg)
+                    raise GuppyError(e) from None
+
+    # Check that all allocated linear objects have been used
+    if state.unused_undroppable_objs:
+        _, unused = state.unused_undroppable_objs.popitem()
+        msg = f"Value with non-droppable type `{unused._ty}` is leaked by this function"
+        raise GuppyError(TracingReturnError(node, msg)) from None
+
+    builder.set_outputs(*regular_returns, *inout_returns)
+
+
+@capture_guppy_errors
+def trace_call(func: CallableDef, *args: Any) -> Any:
+    """Handles calls to Guppy functions during tracing.
+
+    Checks that the passed arguments match the signature of the function and also
+    handles inout arguments.
+    """
+    state = get_tracing_state()
+
+    # Try to turn args into `GuppyObjects`
+    args_objs = [
+        guppy_object_from_py(arg, state.dfg.builder, state.node, state.ctx)
+        for arg in args
+    ]
+
+    # Create dummy variables and bind the objects to them
+    arg_vars: list[Variable] = [
+        ComptimeVariable(next(tmp_vars), obj._ty, None, static_value=arg)
+        for (obj, arg) in zip(args_objs, args, strict=True)
+    ]
+    locals = Locals({var.name: var for var in arg_vars})
+    for obj, var in zip(args_objs, arg_vars, strict=True):
+        state.dfg[var] = obj._use_wire(func)
+
+    # Check call
+    arg_exprs: list[ast.expr] = [
+        with_loc(state.node, with_type(var.ty, PlaceNode(var))) for var in arg_vars
+    ]
+    call_node, ret_ty = func.synthesize_call(
+        arg_exprs, state.node, Context(state.globals, locals, {})
+    )
+
+    # Compile call
+    ret_wire = ExprCompiler(state.ctx).compile(call_node, state.dfg)
+
+    # Update inouts
+    # If the input types of the function aren't known, we can't check this.
+    # This is the case for functions with a custom checker and no type annotations.
+    if len(func.ty.inputs) != 0:
+        for inp, arg, var in zip(func.ty.inputs, args, arg_vars, strict=True):
+            if InputFlags.Inout in inp.flags:
+                inout_wire = state.dfg[var]
+                update_packed_value(
+                    arg, GuppyObject(inp.ty, inout_wire), state.dfg.builder
+                )
+
+    ret_obj = GuppyObject(ret_ty, ret_wire)
+    return unpack_guppy_object(ret_obj, state.dfg.builder)