classiq 0.63.1__py3-none-any.whl → 0.64.0__py3-none-any.whl

classiq/analyzer/url_utils.py

@@ -1,6 +1,5 @@
 import urllib
 from urllib.parse import urljoin
-from uuid import UUID
 
 from classiq.interface.server import routes
 
@@ -21,7 +20,7 @@ def versioned_url_params(circuit_version: str) -> str:
     )
 
 
-def circuit_page_uri(circuit_id: UUID, circuit_version: str) -> str:
-    url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", str(circuit_id))
+def circuit_page_uri(circuit_id: str, circuit_version: str) -> str:
+    url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", circuit_id)
     url += versioned_url_params(circuit_version=circuit_version)
     return url

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.63.1'
+SEMVER_VERSION = '0.64.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/result.py

@@ -1,5 +1,4 @@
 from typing import Annotated, Literal, Optional, Union
-from uuid import UUID
 
 import pydantic
 from pydantic import Field
@@ -34,7 +33,7 @@ class RbResults(VersionedModel):
 
 
 class DataID(pydantic.BaseModel):
-    id: UUID
+    id: str
 
 
 class QasmCode(pydantic.BaseModel):

classiq/interface/executor/result.py

@@ -20,7 +20,7 @@ from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.complex_type import Complex
 from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
-from classiq.interface.helpers.dotdict import get_recursive_dotdict
+from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 _ILLEGAL_QUBIT_ERROR_MSG: str = "Illegal qubit index requested"
@@ -51,8 +51,11 @@ class SampledState(BaseModel):
 
     @pydantic.field_validator("state", mode="after")
     @classmethod
-    def _convert_state_to_dotdict(cls, state: ParsedState) -> DotAccessParsedState:
-        return {name: get_recursive_dotdict(value) for name, value in state.items()}
+    def _make_state_sdk_compatible(cls, state: ParsedState) -> DotAccessParsedState:
+        return {
+            name: get_sdk_compatible_python_object(value)
+            for name, value in state.items()
+        }
 
 
 ParsedCounts: TypeAlias = list[SampledState]

classiq/interface/helpers/datastructures.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+
+class DotDict(dict):
+    def __getattr__(self, key: str) -> Any:
+        return super().get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        super().__setitem__(key, value)
+
+    def __delattr__(self, key: str) -> None:
+        super().__delitem__(key)
+
+
+class LenList(list):
+    @property
+    def len(self) -> int:
+        return len(self)
+
+
+def get_sdk_compatible_python_object(obj: Any) -> Any:
+    if isinstance(obj, list):
+        return LenList([get_sdk_compatible_python_object(item) for item in obj])
+    if isinstance(obj, dict):
+        return DotDict({k: get_sdk_compatible_python_object(v) for k, v in obj.items()})
+    return obj

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "6"
+INTERFACE_VERSION = "7"

classiq/interface/model/handle_binding.py

@@ -243,15 +243,23 @@ class SlicedHandleBinding(NestedHandleBinding):
     def _get_collapsed_stop(self) -> Expression:
         if TYPE_CHECKING:
             assert isinstance(self.base_handle, SlicedHandleBinding)
-        if self.end.is_evaluated() and self.base_handle.end.is_evaluated():
+        if self._is_evaluated() and self.base_handle.start.is_evaluated():
             return Expression(
-                expr=str(self.base_handle.end.to_int_value() - self.end.to_int_value())
+                expr=str(
+                    self.end.to_int_value()
+                    - self.start.to_int_value()
+                    + self.base_handle.start.to_int_value()
+                )
             )
-        return Expression(expr=f"({self.base_handle.end})-({self.end})")
+        return Expression(
+            expr=f"({self.end})-({self.start})+({self.base_handle.start})"
+        )
 
     def replace_prefix(
         self, prefix: HandleBinding, replacement: HandleBinding
     ) -> HandleBinding:
+        if self == prefix:
+            return replacement
         if (
             isinstance(prefix, SlicedHandleBinding)
             and self.base_handle == prefix.base_handle

classiq/interface/server/routes.py

@@ -24,12 +24,16 @@ TASKS_SUFFIX = "/tasks"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"
 ANALYZER_QASM_TASK = f"{TASKS_SUFFIX}/qasm"
+ANALYZER_GET_VISUAL_MODEL = "/get_visual_model"
+ANALYZER_GET_IDE_DATA = "/get_ide_data"
 IDE_EVENT_TASK = f"{TASKS_SUFFIX}/event"
 DATA_DOG_EVENT_TASK = f"{TASKS_SUFFIX}/data_dog_event"
 
 ANALYZER_DATA_TASK_UPLOAD_FILE = f"{TASKS_SUFFIX}/data/file_upload"
 ANALYZER_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_DATA_TASK}"
 ANALYZER_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_QASM_TASK}"
+ANALYZER_GET_VISUAL_MODEL_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_VISUAL_MODEL}"
+ANALYZER_GET_IDE_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_IDE_DATA}"
 IDE_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_EVENT_TASK}"
 DATA_DOG_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{DATA_DOG_EVENT_TASK}"
 

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -33,7 +33,6 @@ from classiq.interface.generator.functions.type_name import TypeName
 from classiq.model_expansions.model_tables import (
     HandleIdentifier,
     HandleTable,
-    SymbolTable,
 )
 from classiq.model_expansions.sympy_conversion.arithmetics import (
     BitwiseAnd,
@@ -48,13 +47,14 @@ from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     sympy_to_python,
 )
+from classiq.qmod.model_state_container import QMODULE
 
 
 def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
     if isinstance(qmod_type, TypeName):
         if (
             isinstance(val, QmodStructInstance)
-            and val.struct_declaration == SymbolTable.type_table[qmod_type.name]
+            and val.struct_declaration == QMODULE.type_decls[qmod_type.name]
         ):
             return {
                 field_name: qmod_val_to_python(val.fields[field_name], field_type)
@@ -97,10 +97,10 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
 
 def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
     if isinstance(qmod_type, TypeName):
-        if qmod_type.name in SymbolTable.enum_table:
+        if qmod_type.name in QMODULE.enum_decls:
             return val
 
-        struct_decl = SymbolTable.type_table[qmod_type.name]
+        struct_decl = QMODULE.type_decls[qmod_type.name]
         if not isinstance(val, Mapping):
             raise ClassiqInternalExpansionError(
                 f"Bad value for struct {struct_decl.name}"
@@ -138,7 +138,7 @@ def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
 
 def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
     return QmodStructInstance(
-        SymbolTable.type_table[struct_type_symbol.name],
+        QMODULE.type_decls[struct_type_symbol.name],
         {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
     )
 
@@ -179,7 +179,7 @@ def get_field(
 
 
 def get_type(struct_type: Symbol) -> TypeProxy:
-    return TypeProxy(SymbolTable.type_table[struct_type.name])
+    return TypeProxy(QMODULE.type_decls[struct_type.name])
 
 
 def _unwrap_sympy_numeric(n: Any) -> Any:

classiq/model_expansions/capturing/captured_vars.py

@@ -34,6 +34,10 @@ if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
 
+ALREADY_ALLOCATED_MESSAGE = "Cannot allocate variable '{}', it is already initialized"
+ALREADY_FREED_MESSAGE = "Cannot free variable '{}', it is already uninitialized"
+
+
 class PortDirection(StrEnum):
     Input = "input"
     Inout = "inout"
@@ -141,7 +145,14 @@ class CapturedVars:
             isinstance(captured_handle.handle, NestedHandleBinding)
             and captured_handle.direction != PortDirection.Inout
         ):
-            raise ClassiqInternalExpansionError("Captured nested handles must be inout")
+            verb = (
+                "free"
+                if captured_handle.direction == PortDirection.Input
+                else "allocate"
+            )
+            raise ClassiqExpansionError(
+                f"Cannot partially {verb} variable {captured_handle.handle.name}"
+            )
 
         new_captured_handles = []
         for existing_captured_handle in self._captured_handles:
@@ -174,7 +185,9 @@ class CapturedVars:
                 return captured_handle.change_direction(PortDirection.Inout)
             if captured_handle.direction == PortDirection.Outin:
                 return captured_handle.change_direction(PortDirection.Input)
-            raise ClassiqInternalExpansionError("Captured handle is already freed")
+            raise ClassiqExpansionError(
+                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+            )
         if existing_captured_handle.direction == PortDirection.Output:
             if captured_handle.direction == PortDirection.Input:
                 return captured_handle.change_direction(PortDirection.Outin)
@@ -182,8 +195,8 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError(
-                    "Captured handle is already allocated"
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle.change_direction(PortDirection.Output)
         if existing_captured_handle.direction == PortDirection.Inout:
@@ -191,14 +204,16 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError(
-                    "Captured handle is already allocated"
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
                 )
         elif captured_handle.direction in (
             PortDirection.Input,
             PortDirection.Inout,
         ):
-            raise ClassiqInternalExpansionError("Captured handle is already freed")
+            raise ClassiqExpansionError(
+                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+            )
         return captured_handle
 
     def _intersect_handles(
@@ -211,7 +226,9 @@ class CapturedVars:
                 PortDirection.Input,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError("Captured handle is already freed")
+                raise ClassiqExpansionError(
+                    ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+                )
             return existing_captured_handle
 
         if existing_captured_handle.handle in captured_handle.handle:
@@ -219,8 +236,8 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError(
-                    "Captured handle is already allocated"
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle
 

classiq/model_expansions/evaluators/arg_type_match.py

@@ -25,8 +25,8 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.type_type_match import check_signature_match
-from classiq.model_expansions.model_tables import SymbolTable
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CInt, get_qmod_type
 
 
@@ -122,11 +122,11 @@ def _check_classical_type_match(
     type_name = _resolve_type_name(classical_type)
     type_is_struct = (
         isinstance(classical_type, TypeName)
-        and classical_type.name in SymbolTable.type_table
+        and classical_type.name in QMODULE.type_decls
     )
     type_is_enum = (
         isinstance(classical_type, TypeName)
-        and classical_type.name in SymbolTable.enum_table
+        and classical_type.name in QMODULE.enum_decls
     )
     arg_is_qvar = isinstance(argument, QmodSizedProxy)
     arg_is_builtin = argument.__class__.__module__ == "builtins"
@@ -153,9 +153,6 @@ def _resolve_type_name(classical_type: ConcreteClassicalType) -> str:
         type_name = get_qmod_type(classical_type).__name__
     if not isinstance(classical_type, TypeName):
         return type_name
-    if (
-        type_name not in SymbolTable.type_table
-        and type_name not in SymbolTable.enum_table
-    ):
+    if type_name not in QMODULE.type_decls and type_name not in QMODULE.enum_decls:
         raise ClassiqExpansionError(f"Undefined type {type_name}")
     return type_name

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -10,10 +10,12 @@ from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.inplace_binary_operation import BinaryOperation
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
     QuantumNumeric,
+    QuantumScalar,
     QuantumType,
 )
 
@@ -209,14 +211,19 @@ def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
         )
 
 
-def validate_inplace_binary_op_vars(
-    value_var: QuantumSymbol, target_var: QuantumSymbol, operation_name: str
-) -> None:
-    if not isinstance(value_var.quantum_type, QuantumNumeric):
+def get_inplace_op_scalar_as_numeric(
+    var: QuantumSymbol, operation: BinaryOperation, var_kind: str
+) -> QuantumNumeric:
+    if not isinstance(var.quantum_type, QuantumScalar):
         raise ClassiqExpansionError(
-            f"Cannot perform `{operation_name}` operation with non numeric value {value_var.handle}"
+            f"Cannot perform inplace {operation.name.lower()} with non-scalar {var_kind} {var.handle}"
         )
-    if not isinstance(target_var.quantum_type, QuantumNumeric):
-        raise ClassiqExpansionError(
-            f"Cannot perform `{operation_name}` operation with non numeric target {target_var.handle}"
+    if isinstance(var.quantum_type, QuantumNumeric):
+        return var.quantum_type
+    if isinstance(var.quantum_type, QuantumBit):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
         )
+    raise ClassiqInternalExpansionError(f"Unexpected scalar type {var.quantum_type}")

classiq/model_expansions/expression_evaluator.py

@@ -24,12 +24,13 @@ from classiq.model_expansions.atomic_expression_functions_defs import (
     ATOMIC_EXPRESSION_FUNCTIONS,
     qmod_val_to_python,
 )
-from classiq.model_expansions.model_tables import SymbolTable
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     translate_to_sympy,
 )
 from classiq.model_expansions.sympy_conversion.sympy_to_python import sympy_to_python
 from classiq.qmod import symbolic
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
 
 
 def evaluate_constants(constants: list[Constant]) -> dict[str, EvaluatedExpression]:
@@ -56,7 +57,12 @@ def evaluate(
 ) -> EvaluatedExpression:
     model_locals: dict[str, ExpressionValue] = {}
     model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
-    model_locals.update(SymbolTable.enum_table.enums)
+    model_locals.update(
+        {
+            enum_decl.name: enum_decl.create_enum()
+            for enum_decl in (QMODULE.enum_decls | BUILTIN_ENUM_DECLARATIONS).values()
+        }
+    )
     # locals override builtin-functions
     model_locals.update({name: expr.value for name, expr in locals_dict.items()})
     uninitialized_locals = uninitialized_locals or set()

classiq/model_expansions/generative_functions.py

@@ -34,7 +34,7 @@ from classiq.qmod.semantics.static_semantics_visitor import resolve_function_cal
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
 class LenList(list):
@@ -94,7 +94,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
 
 
 class _InterpreterExpandable(QFunc):
-    def __init__(self, interpreter: "Interpreter"):
+    def __init__(self, interpreter: "BaseInterpreter"):
         super().__init__(lambda: None)
         self._interpreter = interpreter
 
@@ -137,7 +137,7 @@ class _InterpreterExpandable(QFunc):
 
 
 def emit_generative_statements(
-    interpreter: "Interpreter",
+    interpreter: "BaseInterpreter",
     operation: GenerativeClosure,
     args: list[Evaluated],
 ) -> None:

classiq/model_expansions/{interpreter.py → interpreters/base_interpreter.py}

@@ -1,3 +1,4 @@
+from abc import abstractmethod
 from collections import defaultdict
 from collections.abc import Sequence
 from contextlib import nullcontext
@@ -15,30 +16,15 @@ from classiq.interface.exceptions import (
 )
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.builtins.internal_operators import (
-    CONTROL_OPERATOR_NAME,
-    INVERT_OPERATOR_NAME,
-    WITHIN_APPLY_NAME,
-)
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
-from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.classical_if import ClassicalIf
-from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.phase_operation import PhaseOperation
-from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumAssignmentOperation,
-)
 from classiq.interface.model.quantum_function_call import (
     QuantumFunctionCall,
 )
@@ -51,11 +37,6 @@ from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
-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.model_expansions.closure import (
     Closure,
@@ -74,21 +55,6 @@ from classiq.model_expansions.function_builder import (
     OperationContext,
 )
 from classiq.model_expansions.generative_functions import emit_generative_statements
-from classiq.model_expansions.quantum_operations import (
-    BindEmitter,
-    ClassicalIfEmitter,
-    ControlEmitter,
-    InplaceBinaryOperationEmitter,
-    InvertEmitter,
-    PowerEmitter,
-    QuantumAssignmentOperationEmitter,
-    QuantumFunctionCallEmitter,
-    RepeatEmitter,
-    VariableDeclarationStatementEmitter,
-    WithinApplyEmitter,
-)
-from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
-from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -96,25 +62,24 @@ from classiq.model_expansions.scope_initialization import (
     add_functions_to_scope,
     add_generative_functions_to_scope,
     get_main_renamer,
+    init_builtin_types,
     init_top_level_scope,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.functions import permute
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
 
-class Interpreter:
+class BaseInterpreter:
     def __init__(
         self,
         model: Model,
         generative_functions: Optional[list[GenerativeQFunc]] = None,
-        is_normalizer: bool = False,
-        is_shallow: bool = False,
     ) -> None:
-        self._is_normalizer = is_normalizer
-        self._is_shallow = is_shallow
         self._model = model
         self._top_level_scope = Scope()
         self._counted_name_allocator = CountedNameAllocator()
@@ -123,12 +88,8 @@ class Interpreter:
         )
         self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
 
+        init_builtin_types()
         init_top_level_scope(model, generative_functions or [], self._top_level_scope)
-        self._main_renamer: Optional[ExpressionRenamer] = (
-            get_main_renamer(self._get_function_declarations())
-            if self._is_normalizer
-            else None
-        )
         self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
             self._model.functions_compilation_metadata
         )
@@ -138,6 +99,13 @@ class Interpreter:
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
+    @property
+    def is_shallow(self) -> bool:
+        return False
+
+    def get_main_renamer(self) -> Optional[ExpressionRenamer]:
+        return get_main_renamer(self._get_function_declarations())
+
     def _expand_main_func(self) -> None:
         main_func = self._top_level_scope[MAIN_FUNCTION_NAME].value
         closure_constructor: Any
@@ -153,7 +121,7 @@ class Interpreter:
             name=main_func.name,
             positional_arg_declarations=main_func.positional_arg_declarations,
             scope=Scope(parent=self._top_level_scope),
-            expr_renamer=self._main_renamer,
+            expr_renamer=self.get_main_renamer(),
             _depth=0,
             **extra_args,
         )
@@ -189,8 +157,16 @@ class Interpreter:
             execution_preferences=self._model.execution_preferences,
             functions=list(self._expanded_functions.values()),
             constants=self._model.constants,
-            enums=list(QMODULE.enum_decls.values()),
-            types=list(QMODULE.type_decls.values()),
+            enums=[
+                enum_decl
+                for name, enum_decl in QMODULE.enum_decls.items()
+                if name not in BUILTIN_ENUM_DECLARATIONS
+            ],
+            types=[
+                struct_decl
+                for name, struct_decl in QMODULE.type_decls.items()
+                if name not in BUILTIN_STRUCT_DECLARATIONS
+            ],
             qstructs=list(QMODULE.qstruct_decls.values()),
             debug_info=self._model.debug_info,
             functions_compilation_metadata=self._expanded_functions_compilation_metadata,
@@ -282,96 +258,9 @@ class Interpreter:
         base_value = self.evaluate(field_access.base_handle)
         return Evaluated(value=base_value.value.fields[field_access.field])
 
-    @singledispatchmethod
+    @abstractmethod
     def emit(self, statement: QuantumStatement) -> None:
-        raise NotImplementedError(f"Cannot emit {statement!r}")
-
-    @emit.register
-    def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
-        QuantumFunctionCallEmitter(self).emit(call)
-
-    @emit.register
-    def emit_bind(self, bind: BindOperation) -> None:
-        BindEmitter(self).emit(bind)
-
-    @emit.register
-    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
-        if self._is_normalizer:
-            ShallowEmitter(
-                self, "assignment_operation", components=["expression", "result_var"]
-            ).emit(op)
-        else:
-            QuantumAssignmentOperationEmitter(self).emit(op)
-
-    @emit.register
-    def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
-        if self._is_normalizer:
-            ShallowEmitter(
-                self, "inplace_binary_operation", components=["target", "value"]
-            ).emit(op)
-        else:
-            InplaceBinaryOperationEmitter(self).emit(op)
-
-    @emit.register
-    def emit_variable_declaration(
-        self, variable_declaration: VariableDeclarationStatement
-    ) -> None:
-        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
-
-    @emit.register
-    def emit_classical_if(self, classical_if: ClassicalIf) -> None:
-        ClassicalIfEmitter(self).emit(classical_if)
-
-    @emit.register
-    def emit_within_apply(self, within_apply: WithinApply) -> None:
-        if self._is_normalizer:
-            ShallowEmitter(
-                self,
-                WITHIN_APPLY_NAME,
-                components=["within", "apply", "compute", "action"],
-            ).emit(within_apply)
-        else:
-            WithinApplyEmitter(self).emit(within_apply)
-
-    @emit.register
-    def emit_invert(self, invert: Invert) -> None:
-        if self._is_normalizer:
-            ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
-        else:
-            InvertEmitter(self).emit(invert)
-
-    @emit.register
-    def emit_repeat(self, repeat: Repeat) -> None:
-        RepeatEmitter(self).emit(repeat)
-
-    @emit.register
-    def emit_control(self, control: Control) -> None:
-        if self._is_normalizer:
-            ShallowEmitter(
-                self,
-                CONTROL_OPERATOR_NAME,
-                components=["expression", "body", "else_block"],
-            ).emit(control)
-        else:
-            ControlEmitter(self).emit(control)
-
-    @emit.register
-    def emit_power(self, power: Power) -> None:
-        if self._is_normalizer:
-            ShallowEmitter(
-                self, CONTROL_OPERATOR_NAME, components=["power", "body"]
-            ).emit(power)
-        else:
-            PowerEmitter(self).emit(power)
-
-    @emit.register
-    def emit_phase(self, phase: PhaseOperation) -> None:
-        if self._is_normalizer:
-            ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(
-                phase
-            )
-        else:
-            PhaseEmitter(self).emit(phase)
+        pass
 
     def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
         with self._builder.block_context(block_name):