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

classiq/model_expansions/scope.py

@@ -66,8 +66,6 @@ class QuantumSymbol:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if TYPE_CHECKING:
-            assert self.quantum_type.length is not None
         if isinstance(start, int) and isinstance(end, int) and start >= end:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} slice '{self.handle}[{start}:{end}]' "
@@ -75,6 +73,7 @@ class QuantumSymbol:
             )
         if (isinstance(start, int) and start < 0) or (
             isinstance(end, int)
+            and self.quantum_type.length is not None
             and self.quantum_type.length.is_constant()
             and end > self.quantum_type.length_value
         ):
@@ -100,19 +99,23 @@ class QuantumSymbol:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if TYPE_CHECKING:
-            assert self.quantum_type.length is not None
         if isinstance(index, int) and (
             index < 0
             or (
-                self.quantum_type.length.is_constant()
+                self.quantum_type.length is not None
+                and self.quantum_type.length.is_constant()
                 and index >= self.quantum_type.length_value
             )
         ):
+            length_suffix = (
+                f" (of length {self.quantum_type.length})"
+                if self.quantum_type.length is not None
+                else ""
+            )
             raise ClassiqExpansionError(
                 f"Index {index} is out of bounds for "
-                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
-                f"length {self.quantum_type.length})"
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r}"
+                f"{length_suffix}"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(

classiq/model_expansions/sympy_conversion/arithmetics.py

@@ -47,3 +47,21 @@ class BitwiseNot(Function):
             return ~a
 
         return None
+
+
+class RShift(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a >> b
+
+        return None
+
+
+class LShift(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a << b
+
+        return None

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -23,6 +23,8 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
         ast.BitAnd: "BitwiseAnd",
         ast.BitXor: "BitwiseXor",
         ast.Div: "do_div",
+        ast.RShift: "RShift",
+        ast.LShift: "LShift",
     }
 
     UNARY_OPERATORS: dict[type[ast.AST], str] = {

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -17,6 +17,9 @@ from sympy.printing.pycode import PythonCodePrinter
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 
 from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 
@@ -24,7 +27,9 @@ from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 def sympy_to_python(
     value: Any, locals: Optional[dict[str, ExpressionValue]] = None
 ) -> ExpressionValue:
-    if isinstance(value, Integer):
+    if isinstance(value, AnyClassicalValue):
+        pass
+    elif isinstance(value, Integer):
         value = int(value)
     elif isinstance(value, Float):
         value = float(value)
@@ -66,6 +71,8 @@ class SympyToQuantumExpressionTranslator(PythonCodePrinter):
         "BitwiseOr": "|",
         "BitwiseXor": "^",
         "LogicalXor": "^",
+        "RShift": ">>",
+        "LShift": "<<",
     }
     UNARY_BITWISE_OPERATORS_MAPPING = {"BitwiseNot": "~"}
 
@@ -117,6 +124,8 @@ class SympyToBoolExpressionTranslator(SympyToQuantumExpressionTranslator):
 
 
 def translate_sympy_quantum_expression(expr: Basic, preserve_bool_ops: bool) -> str:
+    if isinstance(expr, AnyClassicalValue):
+        return str(expr)
     if preserve_bool_ops:
         return SympyToBoolExpressionTranslator().doprint(expr)
     else:

classiq/model_expansions/transformers/model_renamer.py

@@ -2,8 +2,10 @@ import ast
 import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
+from functools import cmp_to_key
 from typing import TypeVar, cast
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.handle_binding import HandleBinding
@@ -23,6 +25,39 @@ def _replace_full_word(pattern: str, substitution: str, target: str) -> str:
     )
 
 
+def _handle_contains_handle(handle: HandleBinding, other_handle: HandleBinding) -> int:
+    if str(other_handle) in str(handle) or other_handle.qmod_expr in handle.qmod_expr:
+        return 1
+    if str(handle) in str(other_handle) or handle.qmod_expr in other_handle.qmod_expr:
+        return -1
+    return 0
+
+
+class _ExprNormalizer(ast.NodeTransformer):
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        if not isinstance(node.func, ast.Name):
+            return self.generic_visit(node)
+        if node.func.id == "get_field":
+            if (
+                len(node.args) != 2
+                or not isinstance(node.args[1], ast.Constant)
+                or not isinstance(node.args[1].value, str)
+            ):
+                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
+            return ast.Attribute(
+                value=self.visit(node.args[0]), attr=node.args[1].value
+            )
+        if node.func.id == "do_subscript":
+            if len(node.args) != 2:
+                raise ClassiqInternalExpansionError(
+                    "Unexpected 'do_subscript' arguments"
+                )
+            return ast.Subscript(
+                value=self.visit(node.args[0]), slice=self.visit(node.args[1])
+            )
+        return self.generic_visit(node)
+
+
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -39,26 +74,29 @@ SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 def _rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
+    normalized_expr = _ExprNormalizer().visit(ast.parse(expression.expr))
     vrc = VarRefCollector(
         ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
     )
-    vrc.visit(ast.parse(expression.expr))
+    vrc.visit(normalized_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_expr_str = ast.unparse(normalized_expr)
+    sorted_handles = sorted(
+        vrc.var_handles,
+        key=cmp_to_key(  # type:ignore[misc]
+            lambda handle, other_handle: _handle_contains_handle(other_handle, handle)
+        ),
+    )
+    for handle in sorted_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

classiq/model_expansions/utils/handles_collector.py

@@ -18,7 +18,7 @@ class _HandlesCollector(Visitor):
         self.handles.append(handle)
 
     def visit_Expression(self, expression: Expression) -> None:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expression.expr))
         self.handles.extend(vrc.var_handles)
 

classiq/model_expansions/visitors/variable_references.py

@@ -95,16 +95,25 @@ class VarRefCollector(ast.NodeVisitor):
     def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
         return self._get_field_handle(node.value, node.attr)
 
-    def visit_Call(self, node: ast.Call) -> Optional[FieldHandleBinding]:
-        if (
-            not isinstance(node.func, ast.Name)
-            or node.func.id != "get_field"
-            or len(node.args) != 2
-            or not isinstance(node.args[1], ast.Constant)
-            or not isinstance(node.args[1].value, str)
-        ):
+    def visit_Call(self, node: ast.Call) -> Optional[HandleBinding]:
+        if not isinstance(node.func, ast.Name):
             return self.generic_visit(node)
-        return self._get_field_handle(node.args[0], node.args[1].value)
+        if node.func.id == "get_field":
+            if (
+                len(node.args) != 2
+                or not isinstance(node.args[1], ast.Constant)
+                or not isinstance(node.args[1].value, str)
+            ):
+                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
+            return self._get_field_handle(node.args[0], node.args[1].value)
+        if node.func.id == "do_subscript":
+            if len(node.args) != 2:
+                raise ClassiqInternalExpansionError(
+                    "Unexpected 'do_subscript' arguments"
+                )
+            self.visit(node.args[1])
+            return self._get_subscript_handle(node.args[0], node.args[1])
+        return self.generic_visit(node)
 
     def _get_field_handle(
         self, subject: ast.expr, field: str
@@ -121,6 +130,33 @@ class VarRefCollector(ast.NodeVisitor):
             self._var_handles[handle] = True
         return handle
 
+    def _get_subscript_handle(
+        self, subject: ast.expr, subscript: ast.expr
+    ) -> Optional[HandleBinding]:
+        with self.set_nested():
+            base_handle = self.visit(subject)
+        if base_handle is None:
+            return None
+        handle: HandleBinding
+        if isinstance(subscript, ast.Slice):
+            if subscript.lower is None or subscript.upper is None:
+                raise ClassiqExpansionError(
+                    f"{str(base_handle)!r} slice must specify both lower and upper bounds"
+                )
+            handle = SlicedHandleBinding(
+                base_handle=base_handle,
+                start=Expression(expr=ast.unparse(subscript.lower)),
+                end=Expression(expr=ast.unparse(subscript.upper)),
+            )
+        else:
+            handle = SubscriptHandleBinding(
+                base_handle=base_handle,
+                index=Expression(expr=ast.unparse(subscript)),
+            )
+        if not self._is_nested:
+            self._var_handles[handle] = True
+        return handle
+
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
         if not self._ignore_sympy_symbols and node.id in set(
             SYMPY_SUPPORTED_EXPRESSIONS

classiq/qmod/builtins/functions/allocation.py

@@ -2,11 +2,11 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QFree
 
 
 @qfunc(external=True)
-def free(in_: Input[QArray[QBit]]) -> None:
+def free(in_: QFree[Input[QArray[QBit]]]) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/builtins/functions/arithmetic.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
-from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
+from classiq.qmod.qmod_variable import Const, Output, QArray, QBit, QFree, QNum
 
 
 @qfunc(external=True)
@@ -24,13 +24,15 @@ def unitary(
 
 @qfunc(external=True)
 def add(
-    left: QNum,
-    right: QNum,
-    result: Output[
-        QNum[
-            Literal["result_size"],
-            Literal["result_is_signed"],
-            Literal["result_fraction_places"],
+    left: Const[QNum],
+    right: Const[QNum],
+    result: QFree[
+        Output[
+            QNum[
+                Literal["result_size"],
+                Literal["result_is_signed"],
+                Literal["result_fraction_places"],
+            ]
         ]
     ],
     result_size: CReal,
@@ -41,20 +43,20 @@ def add(
 
 
 @qfunc(external=True)
-def modular_add(left: QArray[QBit], right: QArray[QBit]) -> None:
+def modular_add(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def modular_add_constant(left: CReal, right: QNum) -> None:
+def modular_add_constant(left: CReal, right: QFree[QNum]) -> None:
     pass
 
 
 @qfunc(external=True)
-def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
+def integer_xor(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def real_xor_constant(left: CReal, right: QNum) -> None:
+def real_xor_constant(left: CReal, right: QFree[QNum]) -> None:
     pass

classiq/qmod/builtins/functions/standard_gates.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CReal
-from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.qmod_variable import Const, QArray, QBit, QFree
 
 
 @qfunc(external=True)
@@ -25,7 +25,7 @@ def H(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def X(target: QBit) -> None:
+def X(target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -44,7 +44,7 @@ def X(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def Y(target: QBit) -> None:
+def Y(target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -63,7 +63,7 @@ def Y(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def Z(target: QBit) -> None:
+def Z(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -82,7 +82,7 @@ def Z(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def I(target: QBit) -> None:
+def I(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -101,7 +101,7 @@ def I(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def S(target: QBit) -> None:
+def S(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -120,7 +120,7 @@ def S(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def T(target: QBit) -> None:
+def T(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -139,7 +139,7 @@ def T(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def SDG(target: QBit) -> None:
+def SDG(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -158,7 +158,7 @@ def SDG(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def TDG(target: QBit) -> None:
+def TDG(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -177,7 +177,7 @@ def TDG(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def PHASE(theta: CReal, target: QBit) -> None:
+def PHASE(theta: CReal, target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -239,7 +239,7 @@ def RY(theta: CReal, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def RZ(theta: CReal, target: QBit) -> None:
+def RZ(theta: CReal, target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -324,7 +324,7 @@ def RYY(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
 
 
 @qfunc(external=True)
-def RZZ(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
+def RZZ(theta: CReal, target: Const[QArray[QBit, Literal[2]]]) -> None:
     """
     [Qmod core-library function]
 
@@ -345,7 +345,7 @@ def RZZ(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
 
 
 @qfunc(external=True)
-def CH(ctrl: QBit, target: QBit) -> None:
+def CH(ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -370,7 +370,7 @@ def CH(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CX(ctrl: QBit, target: QBit) -> None:
+def CX(ctrl: Const[QBit], target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -395,7 +395,7 @@ def CX(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CY(ctrl: QBit, target: QBit) -> None:
+def CY(ctrl: Const[QBit], target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -420,7 +420,7 @@ def CY(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CZ(ctrl: QBit, target: QBit) -> None:
+def CZ(ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -445,7 +445,7 @@ def CZ(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRX(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CRX(theta: CReal, ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -471,7 +471,7 @@ def CRX(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CRY(theta: CReal, ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -497,7 +497,7 @@ def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CRZ(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -523,7 +523,7 @@ def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CPHASE(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -549,7 +549,7 @@ def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def SWAP(qbit0: QBit, qbit1: QBit) -> None:
+def SWAP(qbit0: QFree[QBit], qbit1: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -574,7 +574,7 @@ def SWAP(qbit0: QBit, qbit1: QBit) -> None:
 
 
 @qfunc(external=True)
-def IDENTITY(target: QArray[QBit]) -> None:
+def IDENTITY(target: Const[QArray[QBit]]) -> None:
     """
     [Qmod core-library function]
 
@@ -623,7 +623,7 @@ def U(theta: CReal, phi: CReal, lam: CReal, gam: CReal, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CCX(ctrl: QArray[QBit, Literal[2]], target: QBit) -> None:
+def CCX(ctrl: Const[QArray[QBit, Literal[2]]], target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 

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_name import TypeName
 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
@@ -40,6 +41,10 @@ from classiq.qmod.python_classical_type import PythonClassicalType
 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.semantics.validation.types_validation import (
+    check_duplicate_types,
+    validate_cstruct,
+)
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 if sys.version_info[0:2] >= (3, 9):
@@ -61,14 +66,16 @@ class _PythonClassicalType(PythonClassicalType):
 
         enum_decl = declaration_from_enum(py_type)
         self.qmodule.enum_decls[py_type.__name__] = enum_decl
+        check_duplicate_types([enum_decl])
 
-    def register_struct(self, py_type: type) -> None:
-        if (
-            self.qmodule is None
-            or py_type.__name__ in BUILTIN_STRUCT_DECLARATIONS
-            or py_type.__name__ in self.qmodule.type_decls
-        ):
-            return
+    def register_struct(self, py_type: type) -> TypeName:
+        classical_type = super().register_struct(py_type)
+        if self.qmodule is None:
+            return classical_type
+        all_decls = BUILTIN_STRUCT_DECLARATIONS | self.qmodule.type_decls
+        if py_type.__name__ in all_decls:
+            classical_type.set_classical_struct_decl(all_decls[py_type.__name__])
+            return classical_type
 
         struct_decl = StructDeclaration(
             name=py_type.__name__,
@@ -77,6 +84,11 @@ class _PythonClassicalType(PythonClassicalType):
             },
         )
         self.qmodule.type_decls[py_type.__name__] = struct_decl
+        check_duplicate_types([struct_decl])
+        validate_cstruct(struct_decl)
+
+        classical_type.set_classical_struct_decl(struct_decl)
+        return classical_type
 
 
 def python_type_to_qmod(

classiq/qmod/generative.py

@@ -4,6 +4,11 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
+
+from classiq.qmod.cparam import CParamScalar
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.generative_interpreter import (
@@ -41,4 +46,7 @@ def get_frontend_interpreter() -> "GenerativeInterpreter":
 
 
 def interpret_expression(expr: str) -> Any:
-    return get_frontend_interpreter().evaluate(Expression(expr=expr)).value
+    val = get_frontend_interpreter().evaluate(Expression(expr=expr)).value
+    if isinstance(val, AnyClassicalValue):
+        return CParamScalar(str(val))
+    return val

classiq/qmod/native/expression_to_qmod.py

@@ -131,6 +131,10 @@ class ASTToQMODCode:
                     ]
                 )
                 return f"{self.ast_to_code(node.args[0])} {{{initializer_list}}}"
+            elif func == "do_subscript":
+                if len(node.args) != 2:
+                    raise AssertionError("Error parsing array access.")
+                return f"{self.ast_to_code(node.args[0])}[{self.ast_to_code(node.args[1])}]"
             else:
                 return "{}({})".format(
                     func, ", ".join(self._cleaned_ast_to_code(arg) for arg in node.args)

classiq/qmod/native/pretty_printer.py

@@ -26,6 +26,7 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
@@ -192,7 +193,7 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         qualifier_str = (
             f"{port_decl.type_qualifier} "
-            if port_decl.type_qualifier is not TypeQualifier.Quantum
+            if port_decl.type_qualifier in [TypeQualifier.Const, TypeQualifier.QFree]
             else ""
         )
         dir_str = (
@@ -308,8 +309,6 @@ class DSLPrettyPrinter(ModelVisitor):
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         classical_if = f"{self._indent}if ({self.visit(op.condition)}) {{\n"
-        if not op.then:
-            raise AssertionError('Expected non empty "then" block')
         classical_if += self._visit_body(op.then)
 
         if op.else_:
@@ -345,6 +344,12 @@ class DSLPrettyPrinter(ModelVisitor):
         invert_code += f"{self._indent}}}\n"
         return invert_code
 
+    def visit_Block(self, block: Block) -> str:
+        invert_code = f"{self._indent}block {{\n"
+        invert_code += self._visit_body(block.statements)
+        invert_code += f"{self._indent}}}\n"
+        return invert_code
+
     def _visit_body(self, body: StatementBlock) -> str:
         code = ""
         self._level += 1