classiq 0.74.0__py3-none-any.whl → 0.75.0__py3-none-any.whl

classiq/analyzer/show_interactive_hack.py

@@ -24,7 +24,7 @@ async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -
     )
 
     if display_url:
-        print(f"Opening: {app_url}")  # noqa: T201
+        print(f"Quantum program link: {app_url}")  # noqa: T201
 
     webbrowser.open_new_tab(app_url)
 

classiq/applications/qnn/qlayer.py

@@ -1,5 +1,6 @@
 import functools
 import inspect
+import os
 import typing
 from typing import Any, Callable, Optional, Union, overload
 
@@ -247,6 +248,14 @@ class QLayer(nn.Module):
     def _make_execute(
         self, quantum_program: SerializedQuantumProgram
     ) -> ExecuteFunction:
+        if os.environ.get("SDK_ENV") == "Studio":
+            try:
+                import classiq_studio_simulation
+
+                return classiq_studio_simulation.make_execute_qnn(quantum_program)
+            except ImportError:
+                pass
+
         session = ExecutionSession(quantum_program)
         self._session = session
 

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.74.0'
+SEMVER_VERSION = '0.75.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/debug_info/debug_info.py

@@ -7,7 +7,6 @@ from pydantic import BaseModel, Field
 from classiq.interface.debug_info import back_ref_util
 from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
-    OperationLevel,
     StatementType,
 )
 from classiq.interface.model.block import Block
@@ -18,21 +17,15 @@ ParameterValue = Union[float, int, str, None]
 
 class FunctionDebugInfo(BaseModel):
     name: str
-    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     statement_type: Union[StatementType, None] = None
-    is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
     release_by_inverse: bool = Field(default=False)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None
 
     @property
-    def is_allocate_or_free_(self) -> bool:
-        return (
-            back_ref_util.is_allocate_or_free(self.node)
-            if self.node is not None
-            else self.is_allocate_or_free
-        )
+    def is_allocate_or_free(self) -> bool:
+        return back_ref_util.is_allocate_or_free(self.node) if self.node else False
 
     def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
         new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
@@ -103,7 +96,5 @@ def new_function_debug_info_by_node(
 ) -> FunctionDebugInfo:
     return FunctionDebugInfo(
         name="",
-        parameters=dict(),
-        level=OperationLevel.QMOD_STATEMENT,
         node=node._as_back_ref(),
     )

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Union
 
 from sympy import Integer
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
@@ -51,9 +51,9 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
         start = int(slice_.start)
         stop = int(slice_.stop)
         if start >= stop:
-            raise ClassiqValueError("Array slice has non-positive length")
+            raise ClassiqIndexError("Array slice has non-positive length")
         if start < 0 or stop > self._length:
-            raise ClassiqValueError("Array slice is out of bounds")
+            raise ClassiqIndexError("Array slice is out of bounds")
         return ClassicalArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
@@ -67,11 +67,11 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
     def _get_subscript(self, index_: Union[int, Integer]) -> ClassicalProxy:
         index = int(index_)
         if index < 0:
-            raise ClassiqValueError(
+            raise ClassiqIndexError(
                 "Array index is out of bounds (negative indices are not supported)"
             )
         if index >= self._length:
-            raise ClassiqValueError("Array index is out of bounds")
+            raise ClassiqIndexError("Array index is out of bounds")
         return self._element_type.get_classical_proxy(
             SubscriptHandleBinding(
                 base_handle=self._handle, index=Expression(expr=str(index_))

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -15,7 +15,7 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalType,
 )
-from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_name import Struct
 
 
 def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
@@ -26,7 +26,7 @@ def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
             element_type=proxy._element_type, size=proxy.length
         )
     elif isinstance(proxy, ClassicalStructProxy):
-        classical_type = TypeName(name=proxy._decl.name)
+        classical_type = Struct(name=proxy._decl.name)
     else:
         raise ClassiqInternalExpansionError(
             f"Unrecognized classical proxy {type(proxy).__name__}"

classiq/interface/generator/functions/classical_type.py

@@ -5,6 +5,7 @@ from pydantic import ConfigDict, PrivateAttr
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
 )
@@ -39,9 +40,22 @@ class ClassicalType(HashableASTNode):
     def is_generative(self) -> bool:
         return self._is_generative
 
+    @property
+    def is_purely_declarative(self) -> bool:
+        return not self._is_generative
+
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalScalarProxy(handle, self)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def clear_flags(self) -> Self:
+        res = self.model_copy()
+        res._is_generative = False
+        return res
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -82,6 +96,14 @@ class ClassicalList(ClassicalType):
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         raise NotImplementedError
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.element_type.expressions
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        return super().is_purely_declarative and self.element_type.is_purely_declarative
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -108,6 +130,14 @@ class ClassicalArray(ClassicalType):
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalArrayProxy(handle, self.element_type, self.size)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.element_type.expressions
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        return super().is_purely_declarative and self.element_type.is_purely_declarative
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/type_name.py

@@ -115,12 +115,34 @@ class TypeName(ClassicalType, QuantumType):
 
     @property
     def expressions(self) -> list[Expression]:
-        return list(
-            chain.from_iterable(
-                field_type.expressions for field_type in self.fields.values()
+        if self.has_fields:
+            return list(
+                chain.from_iterable(
+                    field_type.expressions for field_type in self.fields.values()
+                )
             )
+        if self.has_classical_struct_decl:
+            return list(
+                chain.from_iterable(
+                    field_type.expressions
+                    for field_type in self.classical_struct_decl.variables.values()
+                )
+            )
+        return []
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        if self.is_enum:
+            return False
+        return super().is_purely_declarative and all(
+            field_type.is_purely_declarative
+            for field_type in self.classical_struct_decl.variables.values()
         )
 
+    @property
+    def is_enum(self) -> bool:
+        return not self.has_fields and not self.has_classical_struct_decl
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -40,6 +40,7 @@ IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
 QASM_SEPARATOR = "_"
 SPLIT_MARKER: str = "part"
+ARITH_ENGINE_PREFIX = "arith_eng__"
 PART_SUFFIX_REGEX = re.compile(
     rf".+{QASM_SEPARATOR}{SPLIT_MARKER}{QASM_SEPARATOR}(\d+)$"
 )
@@ -177,10 +178,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
     is_basis_gate: Optional[bool] = Field(default=None)
     is_inverse: bool = Field(default=False)
-    is_allocate_or_free: bool = Field(default=False)
     is_unitary: bool = Field(default=True, exclude=True)
     uuid: Optional[UUID] = Field(default=None, exclude=True)
-    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     port_to_passed_variable_map: dict[str, str] = Field(default={})
     release_by_inverse: bool = Field(default=False)
     back_refs: StatementBlock = Field(default_factory=list)
@@ -190,16 +189,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
     @property
-    def is_allocate_or_free_(self) -> bool:
-        """
-        temporary measure to handle the fact that in the current release we do not have
-        the backref, and therefore fallback to the old field of is_allocate_or_free
-        """
-        return (
-            is_allocate_or_free_by_backref(self.back_refs)
-            if bool(self.back_refs)
-            else self.is_allocate_or_free
-        )
+    def is_allocate_or_free(self) -> bool:
+        return is_allocate_or_free_by_backref(self.back_refs)
 
     @property
     def name(self) -> str:
@@ -215,10 +206,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if isinstance(back_ref, QuantumFunctionCall):
             name = generate_original_function_name(back_ref.func_name)
             if part_match := PART_SUFFIX_REGEX.match(generated_name):
-                suffix = f" [{part_match.group(1)}]"
-            else:
-                suffix = ""
-            return f"{name}{suffix}"
+                name += f" [{part_match.group(1)}]"
+            return name.removeprefix(ARITH_ENGINE_PREFIX)
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
@@ -230,19 +219,16 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return self.back_refs[0] if self.back_refs else None
 
     @property
-    def level_(self) -> OperationLevel:
+    def level(self) -> OperationLevel:
         # Temp fix for currently "supported" statements
         if self.name in {StatementType.CONTROL, StatementType.POWER}:
             return OperationLevel.QMOD_STATEMENT
 
-        back_ref = self.first_back_ref
-        if back_ref is None:
-            # This is the expected behavior for the case where there's not back ref.
-            # We will use it once we can rely on the existence of the back ref in
-            # all expected cases (non-engine calls)
-            # return OperationLevel.ENGINE_FUNCTION_CALL
-            return self.level
-        if isinstance(back_ref, QuantumFunctionCall):
+        if self.first_back_ref is None:
+            # we use ENGINE_FUNCTION_CALL in case where there's not back ref
+            return OperationLevel.ENGINE_FUNCTION_CALL
+
+        if isinstance(self.first_back_ref, QuantumFunctionCall):
             return OperationLevel.QMOD_FUNCTION_CALL
         return OperationLevel.QMOD_STATEMENT
 

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,10 +1,10 @@
+from itertools import chain
 from typing import Optional
 
 import pydantic
 import sympy
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
-from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.parameters import ParameterType
 
 
@@ -12,15 +12,10 @@ class FunctionExecutionData(pydantic.BaseModel):
     power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
 
     @property
-    def power_var(self) -> Optional[str]:
+    def power_vars(self) -> Optional[list[str]]:
         if self.power_parameter is None:
             return None
-        power_vars = sympy.sympify(self.power_parameter).free_symbols
-        if len(power_vars) != 1:
-            raise ClassiqValueError(
-                f"Power parameter expression: {self.power_parameter} must contain exactly one variable"
-            )
-        return str(list(power_vars)[0])
+        return list(map(str, sympy.sympify(self.power_parameter).free_symbols))
 
 
 class ExecutionData(pydantic.BaseModel):
@@ -32,8 +27,10 @@ class ExecutionData(pydantic.BaseModel):
     def execution_parameters(
         self,
     ) -> set[PydanticExecutionParameter]:
-        return {
-            function_execution_data.power_var
-            for function_execution_data in self.function_execution.values()
-            if function_execution_data.power_var is not None
-        }
+        return set(
+            chain.from_iterable(
+                function_execution_data.power_vars
+                for function_execution_data in self.function_execution.values()
+                if function_execution_data.power_vars is not None
+            )
+        )

classiq/interface/helpers/versioned_model.py

@@ -1,7 +1,19 @@
+from typing import Any
+
 import pydantic
 
 from classiq.interface._version import VERSION
+from classiq.interface.interface_version import INTERFACE_VERSION
 
 
 class VersionedModel(pydantic.BaseModel):
     version: str = pydantic.Field(default=VERSION)
+    interface_version: str = pydantic.Field(default="0")
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def set_interface_version(cls, values: dict[str, Any]) -> dict[str, Any]:
+        # We "override" the default value mechanism so that the schema does not depend on the version
+        if "interface_version" not in values:
+            values["interface_version"] = INTERFACE_VERSION
+        return values

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "9"
+INTERFACE_VERSION = "10"

classiq/interface/model/handle_binding.py

@@ -67,6 +67,9 @@ class HandleBinding(ASTNode):
     def is_constant(self) -> bool:
         return True
 
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -111,6 +114,9 @@ class NestedHandleBinding(HandleBinding):
     def is_constant(self) -> bool:
         return self.base_handle.is_constant()
 
+    def expressions(self) -> list[Expression]:
+        return self.base_handle.expressions()
+
 
 class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression
@@ -191,6 +197,9 @@ class SubscriptHandleBinding(NestedHandleBinding):
             and self.index.is_constant()
         )
 
+    def expressions(self) -> list[Expression]:
+        return super().expressions() + [self.index]
+
 
 class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
@@ -305,6 +314,9 @@ class SlicedHandleBinding(NestedHandleBinding):
             and self.end.is_constant()
         )
 
+    def expressions(self) -> list[Expression]:
+        return super().expressions() + [self.start, self.end]
+
 
 class FieldHandleBinding(NestedHandleBinding):
     field: str

classiq/interface/model/statement_block.py

@@ -24,7 +24,12 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.model.within_apply_operation import (
+    Action,
+    Compute,
+    Uncompute,
+    WithinApply,
+)
 
 ConcreteQuantumStatement = Annotated[
     Union[
@@ -43,6 +48,9 @@ ConcreteQuantumStatement = Annotated[
         WithinApply,
         PhaseOperation,
         Block,
+        Compute,
+        Action,
+        Uncompute,
     ],
     Field(..., discriminator="kind"),
 ]

classiq/interface/model/within_apply_operation.py

@@ -15,3 +15,15 @@ class WithinApply(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["compute", "action"])
+
+
+class Compute(QuantumOperation):
+    kind: Literal["Compute"]
+
+
+class Action(QuantumOperation):
+    kind: Literal["Action"]
+
+
+class Uncompute(QuantumOperation):
+    kind: Literal["Uncompute"]

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -15,6 +15,9 @@ from classiq.interface.generator.expressions.expression_types import (
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -170,7 +173,11 @@ def get_field(
         return AnyClassicalValue(f"({proxy}).{field}")
     if isinstance(proxy, type) and issubclass(proxy, Enum):
         return getattr(proxy, field)
-    if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
+    if (
+        isinstance(proxy, Symbol)
+        and not isinstance(proxy, QmodSizedProxy)
+        and not isinstance(proxy, ClassicalProxy)
+    ):
         raise ClassiqExpansionError(
             f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "
             f"initialized"
@@ -229,7 +236,9 @@ def _is_qmod_value(val: Any) -> bool:
 
 
 def do_subscript(value: Any, index: Any) -> Any:
-    if not isinstance(value, list) or not isinstance(index, QmodQNumProxy):
+    if not isinstance(value, (list, ClassicalArrayProxy)) or not isinstance(
+        index, QmodQNumProxy
+    ):
         if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
             raise ClassiqExpansionError(
                 f"Subscript {value}[{index}] is not supported. Supported subscripts "
@@ -251,15 +260,22 @@ def do_subscript(value: Any, index: Any) -> Any:
             "Quantum numeric subscript must be an unsigned integer (is_signed=False, "
             "fraction_digits=0)"
         )
-    if len(value) != 2**index.size:
+    if isinstance(value, ClassicalArrayProxy):
+        length = value.length
+    else:
+        length = len(value)
+    if length != 2**index.size:
         raise ClassiqExpansionError(
             f"Quantum numeric subscript size mismatch: The quantum numeric has "
-            f"{index.size} qubits but the list size is {len(value)} != 2**{index.size}"
+            f"{index.size} qubits but the list size is {length} != 2**{index.size}"
+        )
+    if isinstance(value, ClassicalArrayProxy):
+        return AnyClassicalValue(f"{value}[{index}]")
+    else:
+        return Piecewise(
+            *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
+            (value[-1], True),
         )
-    return Piecewise(
-        *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
-        (value[-1], True),
-    )
 
 
 def do_slice(value: Any, lower: Any, upper: Any) -> Any:

classiq/model_expansions/closure.py

@@ -8,6 +8,15 @@ from typing import Any, Optional
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
@@ -139,6 +148,10 @@ def _evaluated_arg_to_str(arg: Any) -> str:
         return _evaluated_one_operand_to_str(arg)
     if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
         return _evaluated_operands_list_to_str(arg)
+    if isinstance(arg, ClassicalProxy):
+        if isinstance(arg, ClassicalStructProxy):
+            return repr(arg.struct_declaration)
+        return repr(get_proxy_type(arg))
     return evaluated_classical_param_to_str(arg)
 
 

classiq/model_expansions/evaluators/argument_types.py

@@ -34,9 +34,10 @@ def add_information_from_output_arguments(
         if parameter.direction != PortDeclarationDirection.Output:
             continue
 
-        copy_type_information(
-            parameter.quantum_type,
-            argument_as_quantum_symbol.quantum_type,
-            str(argument_as_quantum_symbol.handle),
-        )
+        if parameter.quantum_type.is_evaluated:
+            copy_type_information(
+                parameter.quantum_type,
+                argument_as_quantum_symbol.quantum_type,
+                str(argument_as_quantum_symbol.handle),
+            )
     return args

classiq/model_expansions/evaluators/type_type_match.py

@@ -85,7 +85,7 @@ def _check_classical_type_match(
 ) -> None:
     if (
         not isinstance(op_param, AnonClassicalParameterDeclaration)
-        or decl_param.classical_type.set_generative()
-        != op_param.classical_type.set_generative()
+        or decl_param.classical_type.clear_flags()
+        != op_param.classical_type.clear_flags()
     ):
         raise ClassiqExpansionError(error_message)

classiq/model_expansions/generative_functions.py

@@ -81,11 +81,14 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
         ]
     classical_value = evaluated.value
     if isinstance(classical_value, QmodStructInstance):
-        return CParamStruct(
-            expr=param.name,
-            struct_type=Struct(name=classical_value.struct_declaration.name),
-            qmodule=QMODULE,
-        )
+        if param.classical_type.is_purely_declarative:
+            return CParamStruct(
+                expr=param.name,
+                struct_type=Struct(name=classical_value.struct_declaration.name),
+                qmodule=QMODULE,
+            )
+        else:
+            return get_sdk_compatible_python_object(dict(classical_value.fields))
     if isinstance(classical_value, ClassicalProxy):
         return create_param(
             str(classical_value.handle), get_proxy_type(classical_value), QMODULE
@@ -111,15 +114,18 @@ class _InterpreterExpandable(QFunc):
             for name, func in self._qmodule.native_defs.items()
             if name not in self._interpreter._top_level_scope
         }
+        generative_functions = self._qmodule.generative_functions
         self._interpreter.update_declarative_functions(
             declarative_functions, self._qmodule
         )
-        self._interpreter.update_generative_functions(
-            self._qmodule.generative_functions
-        )
+        self._interpreter.update_generative_functions(generative_functions)
         func_decls = self._get_function_declarations()
         for dec_func in declarative_functions.values():
             resolve_function_calls(dec_func, func_decls)
+        self._interpreter.infer_symbolic_parameters(
+            list(declarative_functions.values()),
+            [func.func_decl for func in generative_functions.values()],
+        )
         resolve_function_calls(dummy_function, func_decls)
         stmt = dummy_function.body[-1]
         with generative_mode_context(False):

classiq/model_expansions/interpreters/base_interpreter.py

@@ -9,14 +9,15 @@ from typing import Any, cast
 import sympy
 from pydantic import ValidationError
 
-from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.debug_info.debug_info import (
+    new_function_debug_info_by_node,
+)
 from classiq.interface.exceptions import (
     ClassiqError,
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
@@ -237,20 +238,16 @@ class BaseInterpreter:
             if source_ref is not None
             else nullcontext()
         )
-        if statement.uuid not in self._model.debug_info:
-            self._model.debug_info[statement.uuid] = FunctionDebugInfo(
-                name="",
-                parameters={},
-                level=OperationLevel.QMOD_STATEMENT,
-                statement_type=None,
-                is_allocate_or_free=False,
-                is_inverse=False,
-                port_to_passed_variable_map={},
-                node=statement._as_back_ref(),
-            )
+        self.add_to_debug_info(statement)
         with error_context, self._builder.source_ref_context(source_ref):
             self.emit(statement)
 
+    def add_to_debug_info(self, statement: QuantumStatement) -> None:
+        if statement.uuid not in self._model.debug_info:
+            self._model.debug_info[statement.uuid] = new_function_debug_info_by_node(
+                statement  # type: ignore[arg-type]
+            )
+
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
             if isinstance(operation, FunctionClosure) and (