classiq 0.70.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

classiq/model_expansions/scope_initialization.py

@@ -7,6 +7,9 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
@@ -55,14 +58,18 @@ def add_functions_to_scope(
 
 
 def add_generative_functions_to_scope(
-    functions: Sequence[GenerativeQFunc], scope: Scope
+    functions: Sequence[GenerativeQFunc], scope: Scope, override_atomic: bool = False
 ) -> None:
     for function in functions:
         name = function.func_decl.name
-        if name == MAIN_FUNCTION_NAME or name not in scope:
-            scope[function.func_decl.name] = Evaluated(
+        if (
+            name == MAIN_FUNCTION_NAME
+            or name not in scope
+            or (override_atomic and scope[name].value.is_atomic)
+        ):
+            scope[name] = Evaluated(
                 value=GenerativeFunctionClosure.create(
-                    name=function.func_decl.name,
+                    name=name,
                     positional_arg_declarations=function.func_decl.positional_arg_declarations,
                     scope=Scope(parent=scope),
                     generative_blocks={"body": function},
@@ -102,17 +109,24 @@ def add_entry_point_params_to_scope(
     parameters: Sequence[PositionalArg], main_closure: FunctionClosure
 ) -> None:
     for parameter in parameters:
-        if not isinstance(parameter, PortDeclaration):
-            continue
-        main_closure.scope[parameter.name] = Evaluated(
-            value=QuantumSymbol(
-                handle=HandleBinding(name=parameter.name),
-                quantum_type=evaluate_type_in_quantum_symbol(
-                    parameter.quantum_type, main_closure.scope, parameter.name
+        if isinstance(parameter, PortDeclaration):
+            main_closure.scope[parameter.name] = Evaluated(
+                value=QuantumSymbol(
+                    handle=HandleBinding(name=parameter.name),
+                    quantum_type=evaluate_type_in_quantum_symbol(
+                        parameter.quantum_type, main_closure.scope, parameter.name
+                    ),
                 ),
-            ),
-            defining_function=main_closure,
-        )
+                defining_function=main_closure,
+            )
+        elif isinstance(parameter, ClassicalParameterDeclaration):
+            param_val = parameter.classical_type.get_classical_proxy(
+                handle=HandleBinding(name=parameter.name)
+            )
+            main_closure.scope[parameter.name] = Evaluated(
+                value=param_val,
+                defining_function=main_closure,
+            )
 
 
 def init_top_level_scope(model: Model, scope: Scope) -> None:
@@ -126,24 +140,6 @@ def init_builtin_types() -> None:
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
 
 
-def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
-    if model.execution_parameters is not None:
-        exec_params = model.execution_parameters
-    else:
-        exec_params = {
-            param.name: param.classical_type
-            for param in model.function_dict.get(
-                "_dec_main", model.main_func
-            ).param_decls
-        }
-    for param_name, param_type in exec_params.items():
-        param_val = param_type.get_classical_proxy(
-            handle=HandleBinding(name=param_name)
-        )
-        scope[param_name] = Evaluated(value=param_val)
-    return exec_params
-
-
 def _get_shape(classical_type: ConcreteClassicalType) -> tuple[int, ...]:
     if isinstance(classical_type, ClassicalList):
         raise ClassiqInternalExpansionError("Unexpected classical list")

classiq/model_expansions/transformers/model_renamer.py

@@ -36,72 +36,78 @@ class HandleRenaming:
 SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 
 
-class ModelRenamer:
-    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolRenaming) -> AST_NODE:
-        if len(symbol_mapping) == 0:
-            return subject
-        handle_replacements = {
-            part.source_handle: part.target_var_handle
-            for parts in symbol_mapping.values()
-            for part in parts
-        }
+def _rewrite_expression(
+    symbol_mapping: SymbolRenaming, expression: Expression
+) -> Expression:
+    vrc = VarRefCollector(
+        ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+    )
+    vrc.visit(ast.parse(expression.expr))
+
+    handle_names = {
+        part.source_handle: part.target_var_handle
+        for parts in symbol_mapping.values()
+        for part in parts
+    }
+    new_expr_str = expression.expr
+    for handle in vrc.var_handles:
+        new_handle = handle.collapse()
+        for handle_to_replace, replacement in handle_names.items():
+            new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+        new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
+        if handle.qmod_expr != str(handle):
+            new_expr_str = _replace_full_word(
+                str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
+            )
+
+    new_expr = Expression(expr=new_expr_str)
+    new_expr._evaluated_expr = expression._evaluated_expr
+    return new_expr
 
-        class ReplaceSplitVars(ModelTransformer):
-            @staticmethod
-            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
-                handle = handle.collapse()
-                for handle_to_replace, replacement in handle_replacements.items():
-                    handle = handle.replace_prefix(handle_to_replace, replacement)
-                return handle
-
-            @staticmethod
-            def visit_Expression(expr: Expression) -> Expression:
-                return self._rewrite_expression(symbol_mapping, expr)
-
-            def visit_QuantumExpressionOperation(
-                self, op: QuantumExpressionOperation
-            ) -> QuantumExpressionOperation:
-                op = cast(QuantumExpressionOperation, self.generic_visit(op))
-                previous_var_handles = list(op._var_handles)
-                op._var_handles = self.visit(op._var_handles)
-                op._var_types = {
-                    new_handle.name: op._var_types.get(
-                        new_handle.name, op._var_types[previous_handle.name]
-                    )
-                    for previous_handle, new_handle in zip(
-                        previous_var_handles, op._var_handles
-                    )
-                }
-                return op
-
-        return ReplaceSplitVars().visit(subject)
-
-    def _rewrite_expression(
-        self,
-        symbol_mapping: SymbolRenaming,
-        expression: Expression,
-    ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
-        vrc.visit(ast.parse(expression.expr))
-
-        handle_names = {
+
+class _ReplaceSplitVarsHandles(ModelTransformer):
+    def __init__(self, symbol_mapping: SymbolRenaming) -> None:
+        self._handle_replacements = {
             part.source_handle: part.target_var_handle
             for parts in symbol_mapping.values()
             for part in parts
         }
-        new_expr_str = expression.expr
-        for handle in vrc.var_handles:
-            new_handle = handle.collapse()
-            for handle_to_replace, replacement in handle_names.items():
-                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-            new_expr_str = _replace_full_word(
-                str(handle), str(new_handle), new_expr_str
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> HandleBinding:
+        handle = handle.collapse()
+        for handle_to_replace, replacement in self._handle_replacements.items():
+            handle = handle.replace_prefix(handle_to_replace, replacement)
+        return handle
+
+
+class _ReplaceSplitVarsExpressions(ModelTransformer):
+    def __init__(self, symbol_mapping: SymbolRenaming) -> None:
+        self._symbol_mapping = symbol_mapping
+
+    def visit_Expression(self, expr: Expression) -> Expression:
+        return _rewrite_expression(self._symbol_mapping, expr)
+
+    def visit_QuantumExpressionOperation(
+        self, op: QuantumExpressionOperation
+    ) -> QuantumExpressionOperation:
+        op = cast(QuantumExpressionOperation, self.generic_visit(op))
+        previous_var_handles = list(op._var_handles)
+        op._var_handles = self.visit(op._var_handles)
+        op._var_types = {
+            new_handle.name: op._var_types.get(
+                new_handle.name, op._var_types[previous_handle.name]
             )
-            if handle.qmod_expr != str(handle):
-                new_expr_str = _replace_full_word(
-                    str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
-                )
-
-        new_expr = Expression(expr=new_expr_str)
-        new_expr._evaluated_expr = expression._evaluated_expr
-        return new_expr
+            for previous_handle, new_handle in zip(
+                previous_var_handles, op._var_handles
+            )
+        }
+        return op
+
+
+class ModelRenamer:
+    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolRenaming) -> AST_NODE:
+        if len(symbol_mapping) == 0:
+            return subject
+        subject = _ReplaceSplitVarsHandles(symbol_mapping).visit(subject)
+        subject = _ReplaceSplitVarsExpressions(symbol_mapping).visit(subject)
+        return subject

classiq/model_expansions/utils/sympy_utils.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from sympy import Number
+
+
+def unwrap_sympy_numeric(n: Any) -> Any:
+    if not isinstance(n, Number) or not n.is_constant():
+        return n
+    if n.is_Integer:
+        return int(n)
+    return float(n)
+
+
+def is_constant_subscript(index: Any) -> bool:
+    if not isinstance(index, slice):
+        return isinstance(unwrap_sympy_numeric(index), int)
+    start = unwrap_sympy_numeric(index.start)
+    stop = unwrap_sympy_numeric(index.stop)
+    step = unwrap_sympy_numeric(index.step)
+    return (
+        (start is None or isinstance(start, int))
+        and (stop is None or isinstance(stop, int))
+        and (step is None or isinstance(step, int))
+    )

classiq/model_expansions/visitors/variable_references.py

@@ -58,6 +58,7 @@ class VarRefCollector(ast.NodeVisitor):
     def visit_Subscript(
         self, node: ast.Subscript
     ) -> Union[SubscriptHandleBinding, SlicedHandleBinding, None]:
+        self.visit(node.slice)
         with self.set_nested():
             base_handle = self.visit(node.value)
         if base_handle is None:

classiq/qmod/__init__.py

@@ -6,7 +6,7 @@ from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
-from .qmod_variable import Input, Output, QArray, QBit, QNum, QStruct
+from .qmod_variable import Const, Input, Output, QArray, QBit, QFree, QNum, QStruct
 from .quantum_callable import QCallable, QCallableList
 from .write_qmod import write_qmod
 
@@ -18,6 +18,8 @@ __all__ = [
     "CReal",
     "Input",
     "Output",
+    "Const",
+    "QFree",
     "QArray",
     "QBit",
     "QNum",

classiq/qmod/builtins/functions/__init__.py

@@ -50,7 +50,9 @@ CORE_LIB_DECLS = [
         SWAP,
         IDENTITY,
         prepare_state,
+        prepare_state_approx,
         prepare_amplitudes,
+        prepare_amplitudes_approx,
         unitary,
         add,
         modular_add,
@@ -62,7 +64,9 @@ CORE_LIB_DECLS = [
         free,
         randomized_benchmarking,
         inplace_prepare_state,
+        inplace_prepare_state_approx,
         inplace_prepare_amplitudes,
+        inplace_prepare_amplitudes_approx,
         single_pauli_exponent,
         commuting_paulis_exponent,
         suzuki_trotter,
@@ -114,7 +118,9 @@ __all__ = [  # noqa: RUF022
     "free",
     "gaussian_finance",
     "inplace_prepare_amplitudes",
+    "inplace_prepare_amplitudes_approx",
     "inplace_prepare_state",
+    "inplace_prepare_state_approx",
     "integer_xor",
     "log_normal_finance",
     "modular_add",
@@ -125,7 +131,9 @@ __all__ = [  # noqa: RUF022
     "pauli_feature_map",
     "permute",
     "prepare_amplitudes",
+    "prepare_amplitudes_approx",
     "prepare_state",
+    "prepare_state_approx",
     "qdrift",
     "randomized_benchmarking",
     "real_xor_constant",

classiq/qmod/builtins/functions/allocation.py

@@ -123,3 +123,39 @@ def inplace_prepare_amplitudes(
 
     """
     pass
+
+
+@qfunc(external=True)
+def inplace_prepare_amplitudes_approx(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def prepare_amplitudes_approx(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_state_approx(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def prepare_state_approx(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
+) -> None:
+    pass

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,7 +1,7 @@
 from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CArray, CReal
+from classiq.qmod.qmod_parameter import CArray, CBool, CReal
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 
 
@@ -24,13 +24,18 @@ def unitary(
 
 @qfunc(external=True)
 def add(
-    left: QArray[QBit],
-    right: QArray[QBit],
+    left: QNum,
+    right: QNum,
     result: Output[
-        QArray[
-            QBit, Literal["Max(get_field(left, 'len'), get_field(right, 'len')) + 1"]
+        QNum[
+            Literal["result_size"],
+            Literal["result_is_signed"],
+            Literal["result_fraction_places"],
         ]
     ],
+    result_size: CReal,
+    result_is_signed: CBool,
+    result_fraction_places: CReal,
 ) -> None:
     pass
 

classiq/qmod/builtins/functions/mid_circuit_measurement.py

@@ -11,5 +11,8 @@ def RESET(target: QBit) -> None:
 
     Args:
         target: the qubit to reset
+
+    Notes:
+        We approximate the depth of a single RESET gate to 1000 X gates.
     """
     pass

classiq/qmod/builtins/operations.py

@@ -142,13 +142,13 @@ def if_(
     if_stmt = ClassicalIf(
         condition=Expression(expr=str(condition)),
         then=_operand_to_body(then, "then"),
-        else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
+        else_=_operand_to_body(else_, "else_") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
         source_ref=source_ref,
     )
     if is_generative_mode():
         if_stmt.set_generative_block("then", then)
         if callable(else_):
-            if_stmt.set_generative_block("else", else_)
+            if_stmt.set_generative_block("else_", else_)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 

classiq/qmod/declaration_inferrer.py

@@ -19,6 +19,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.generator.types.enum_declaration import declaration_from_enum
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.classical_parameter_declaration import (
@@ -36,7 +37,7 @@ from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.python_classical_type import PythonClassicalType
-from classiq.qmod.qmod_variable import QVar
+from classiq.qmod.qmod_variable import QVar, get_port_from_type_hint
 from classiq.qmod.quantum_callable import QCallableList
 from classiq.qmod.semantics.validation.type_hints import validate_annotation
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
@@ -85,15 +86,12 @@ def python_type_to_qmod(
 
 
 def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
-    # FIXME: CAD-13409
-    qtype: type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
-    direction = qtype.port_direction(py_type)
-    if isinstance(py_type, _AnnotatedAlias):
-        py_type = py_type.__args__[0]
+    quantum_type, direction, qualifier = get_port_from_type_hint(py_type)
     param = AnonPortDeclaration(
         name=None,
         direction=direction,
-        quantum_type=qtype.to_qmod_quantum_type(py_type),
+        quantum_type=quantum_type,
+        type_qualifier=qualifier,
     )
     if name is not None:
         param = param.rename(name)
@@ -126,23 +124,45 @@ def _extract_operand_decl(
 def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
     if get_origin(py_type) is not Annotated:
         return None, py_type
+
     args = get_args(py_type)
-    if len(args) == 2:
-        if isinstance(args[1], PortDeclarationDirection):
-            return None, py_type
-        elif isinstance(args[1], str):
-            return args[1], args[0]
-        elif get_origin(args[1]) is Literal:
-            return version_portable_get_args(args[1])[0], args[0]
-    elif len(args) == 3 and isinstance(args[1], PortDeclarationDirection):
-        if isinstance(args[2], str):
-            return args[2], Annotated[args[0], args[1]]
-        elif get_origin(args[2]) is Literal:
-            return version_portable_get_args(args[2])[0], Annotated[args[0], args[1]]
-    raise ClassiqValueError(
-        f"Operand parameter declaration must be of the form <param-type> or "
-        f"Annotated[<param-type>, <param-name>]. Got {py_type}"
-    )
+    _validate_annotations(args, py_type)
+    param_name = _get_param_name(args)
+
+    if param_name is None:
+        if len(args) > 1:
+            return None, _unpacked_annotated(args[0], args[1:])
+        return None, args[0]
+
+    if len(args) > 2:
+        return param_name, _unpacked_annotated(args[0], args[1:-1])
+    return param_name, args[0]
+
+
+def _unpacked_annotated(arg_0: Any, args: Any) -> _AnnotatedAlias:
+    return Annotated.__class_getitem__((arg_0, *args))  # type:ignore[attr-defined]
+
+
+def _get_param_name(py_type_args: Any) -> Optional[str]:
+    if isinstance(py_type_args[-1], str) and not isinstance(
+        py_type_args[-1], (PortDeclarationDirection, TypeQualifier)
+    ):
+        return py_type_args[-1]
+    elif py_type_args[-1] is Literal:
+        return str(version_portable_get_args(py_type_args[-1])[0])  # type: ignore[arg-type]
+    else:
+        return None
+
+
+def _validate_annotations(py_type_args: Any, py_type: Any) -> None:
+    for arg in py_type_args[1:-1]:
+        if (
+            isinstance(arg, str) and not isinstance(arg, PortDeclarationDirection)
+        ) or arg is Literal:
+            raise ClassiqValueError(
+                f"Operand parameter declaration must be of the form <param-type> or "
+                f"Annotated[<param-type>, <param-name>]. Got {py_type}"
+            )
 
 
 @overload
@@ -177,7 +197,7 @@ def _extract_positional_args(
             if name is not None:
                 param = param.rename(name)
             result.append(param)
-        elif QVar.from_type_hint(py_type) is not None:
+        elif is_qvar(py_type):
             result.append(_extract_port_decl(name, py_type))
         else:
             result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
@@ -193,3 +213,11 @@ def infer_func_decl(
             list(py_func.__annotations__.items()), qmodule=qmodule
         ),
     )
+
+
+def is_qvar(type_hint: Any) -> Any:
+    non_annotated_type = (
+        type_hint.__origin__ if isinstance(type_hint, _AnnotatedAlias) else type_hint
+    )
+    type_ = get_origin(non_annotated_type) or non_annotated_type
+    return issubclass(type_, QVar)

classiq/qmod/model_state_container.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from typing import TYPE_CHECKING
 
 from classiq.interface.generator.constant import Constant
@@ -25,3 +26,11 @@ class ModelStateContainer:
 
 
 QMODULE = ModelStateContainer()
+QMODULE.enum_decls = {}
+QMODULE.type_decls = {}
+QMODULE.qstruct_decls = {}
+QMODULE.native_defs = {}
+QMODULE.constants = {}
+QMODULE.functions_compilation_metadata = {}
+QMODULE.generative_functions = {}
+QMODULE.function_dependencies = defaultdict(list)

classiq/qmod/native/pretty_printer.py

@@ -18,6 +18,8 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -95,6 +97,7 @@ class DSLPrettyPrinter(ModelVisitor):
         self._level = 0
         self._decimal_precision = decimal_precision
         self._emit_open_lib_functions = emit_open_lib_functions
+        self._compilation_metadata: dict[str, CompilationMetadata] = {}
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -105,6 +108,8 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_Model(self, model: Model) -> str:
         # FIXME - CAD-20149: Remove this line once the froggies are removed, and the visit of lambdas can be done without accessing the func_decl property (with rename_params values only).
         resolve_function_calls(model, model.function_dict)
+        self._compilation_metadata = model.functions_compilation_metadata
+
         enum_decls = [self.visit(enum_decl) for enum_decl in model.enums]
         struct_decls = [self.visit(struct_decl) for struct_decl in model.types]
         qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]
@@ -135,10 +140,20 @@ class DSLPrettyPrinter(ModelVisitor):
         )
         return f"({positional_args})"
 
+    def _get_decl_string(self, func_decl: QuantumFunctionDeclaration) -> str:
+        no_qualifiers_decl = "qfunc"
+        if func_decl.name not in self._compilation_metadata:
+            return no_qualifiers_decl
+        atomic_qualifiers = self._compilation_metadata[func_decl.name].atomic_qualifiers
+        if len(atomic_qualifiers) == 0:
+            return no_qualifiers_decl
+        return f"atomic_qualifiers ({', '.join(atomic_qualifiers)})\n" f"qfunc"
+
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
     ) -> str:
-        return f"qfunc {func_decl.name}{self._visit_arg_decls(func_decl)}"
+        qfunc_decl = self._get_decl_string(func_decl)
+        return f"{qfunc_decl} {func_decl.name}{self._visit_arg_decls(func_decl)}"
 
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         return f"enum {enum_decl.name} {{\n{self._visit_members(enum_decl.members)}}}\n"
@@ -175,13 +190,20 @@ class DSLPrettyPrinter(ModelVisitor):
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
+        qualifier_str = (
+            f"{port_decl.type_qualifier} "
+            if port_decl.type_qualifier is not TypeQualifier.Quantum
+            else ""
+        )
         dir_str = (
             f"{port_decl.direction} "
-            if port_decl.direction != PortDeclarationDirection.Inout
+            if port_decl.direction is not PortDeclarationDirection.Inout
             else ""
         )
         param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
-        return f"{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
+        return (
+            f"{qualifier_str}{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
+        )
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
         return "qbit"