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

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/create_model_function.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Optional, Union, cast
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -7,10 +7,26 @@ from classiq.interface.generator.model.preferences.preferences import Preference
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, SerializedModel
 
 from classiq.qmod.classical_function import CFunc
-from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
+from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc, QFunc
 from classiq.qmod.write_qmod import write_qmod
 
 
+class _EntryPointWrapper(str):
+    entry_point: BaseQFunc
+
+
+def add_entry_point(
+    new_model: SerializedModel, old_model: SerializedModel
+) -> SerializedModel:
+    if not hasattr(old_model, "entry_point"):
+        return new_model
+    new_model_with_entry_point = _EntryPointWrapper(new_model)
+    new_model_with_entry_point.entry_point = cast(
+        _EntryPointWrapper, old_model
+    ).entry_point
+    return cast(SerializedModel, new_model_with_entry_point)
+
+
 def create_model(
     entry_point: Union[QFunc, GenerativeQFunc],
     constraints: Optional[Constraints] = None,
@@ -48,7 +64,9 @@ def create_model(
         preferences,
         classical_execution_function,
     )
-    result = model.get_model()
+    serialized_model = _EntryPointWrapper(model.get_model())
+    serialized_model.entry_point = entry_point
+    result = cast(SerializedModel, serialized_model)
 
     if out_file is not None:
         write_qmod(result, out_file)

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/global_declarative_switch.py

@@ -0,0 +1,19 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+_DECLARATIVE_SWITCH = False
+
+
+def get_global_declarative_switch() -> bool:
+    return _DECLARATIVE_SWITCH
+
+
+@contextmanager
+def set_global_declarative_switch() -> Iterator[None]:
+    global _DECLARATIVE_SWITCH
+    previous = _DECLARATIVE_SWITCH
+    _DECLARATIVE_SWITCH = True
+    try:
+        yield
+    finally:
+        _DECLARATIVE_SWITCH = previous

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,
@@ -34,6 +35,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -192,7 +194,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 +310,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 +345,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
@@ -390,6 +396,9 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
+    def visit_HandlesList(self, handles: HandlesList) -> str:
+        return f"{{{', '.join(map(self.visit, handles.handles))}}}"
+
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
         if arith_op.operation_kind == ArithmeticOperationKind.Assignment:
             op = "="

classiq/qmod/pretty_print/pretty_printer.py

@@ -37,6 +37,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -264,7 +265,7 @@ class PythonPrettyPrinter(ModelVisitor):
         if port_decl.direction is not PortDeclarationDirection.Inout:
             self._imports[port_decl.direction.name] = 1
             var_type = f"{port_decl.direction.name}[{var_type}]"
-        if port_decl.type_qualifier is not TypeQualifier.Quantum:
+        if port_decl.type_qualifier in [TypeQualifier.Const, TypeQualifier.QFree]:
             self._imports[port_decl.type_qualifier.name] = 1
             var_type = f"{port_decl.type_qualifier.name}[{var_type}]"
         return var_type
@@ -518,6 +519,9 @@ class PythonPrettyPrinter(ModelVisitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
+    def visit_HandlesList(self, handles: HandlesList) -> str:
+        return self.visit(handles.handles)
+
     def visit_ArithmeticOperation(
         self, arith_op: ArithmeticOperation, in_lambda: bool = False
     ) -> str:

classiq/qmod/python_classical_type.py

@@ -19,7 +19,7 @@ from classiq.interface.generator.functions.classical_type import (
     Real,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-from classiq.interface.generator.functions.type_name import Enum, Struct
+from classiq.interface.generator.functions.type_name import Enum, Struct, TypeName
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.utilities import version_portable_get_args
@@ -59,8 +59,7 @@ class PythonClassicalType:
                 )
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
-            self.register_struct(py_type)
-            return Struct(name=py_type.__name__)
+            return self.register_struct(py_type)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
             return Enum(name=py_type.__name__)
@@ -68,8 +67,8 @@ class PythonClassicalType:
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None
 
-    def register_struct(self, py_type: type) -> None:
-        pass
+    def register_struct(self, py_type: type) -> TypeName:
+        return Struct(name=py_type.__name__)
 
     def register_enum(self, py_type: EnumMeta) -> None:
         pass

classiq/qmod/qfunc.py

@@ -1,9 +1,9 @@
-from collections.abc import Iterator
-from contextlib import contextmanager
+import warnings
 from typing import Callable, Literal, Optional, Union, overload
 
-from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqInternalError
 
+from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_function import (
     BaseQFunc,
@@ -12,22 +12,9 @@ from classiq.qmod.quantum_function import (
     QFunc,
 )
 
-_GENERATIVE_SWITCH = False
-
-
-@contextmanager
-def set_global_generative_switch() -> Iterator[None]:
-    global _GENERATIVE_SWITCH
-    previous = _GENERATIVE_SWITCH
-    _GENERATIVE_SWITCH = True
-    try:
-        yield
-    finally:
-        _GENERATIVE_SWITCH = previous
-
 
 @overload
-def qfunc(func: Callable) -> QFunc: ...
+def qfunc(func: Callable) -> GenerativeQFunc: ...
 
 
 @overload
@@ -42,16 +29,16 @@ def qfunc(
 @overload
 def qfunc(
     *,
-    generative: Literal[True],
+    generative: Literal[False],
     synthesize_separately: bool = False,
     atomic_qualifiers: Optional[list[str]] = None,
-) -> Callable[[Callable], GenerativeQFunc]: ...
+) -> Callable[[Callable], QFunc]: ...
 
 
 @overload
 def qfunc(
     *, synthesize_separately: bool, atomic_qualifiers: Optional[list[str]] = None
-) -> Callable[[Callable], QFunc]: ...
+) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
 @overload
@@ -59,17 +46,38 @@ def qfunc(
     *,
     synthesize_separately: bool = False,
     atomic_qualifiers: Optional[list[str]] = None,
-) -> Callable[[Callable], QFunc]: ...
+) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
 def qfunc(
     func: Optional[Callable] = None,
     *,
     external: bool = False,
-    generative: bool = False,
+    generative: Optional[bool] = None,
     synthesize_separately: bool = False,
     atomic_qualifiers: Optional[list[str]] = None,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
+    if generative is True:
+        warnings.warn(
+            "The use of `generative=True` is no longer required. Note that the "
+            "treatment of parameters of Qmod types will change from Python value to "
+            "symbolic in a near release. Change Qmod types to the corresponding Python "
+            "built-in types in order to use the parameters in Python expression "
+            "contexts.\n"
+            "Recommended changes:\n"
+            "@qfunc(generative=True) -> @qfunc\n"
+            "CInt->int\n"
+            "CReal->float\n"
+            "CArray->list\n\n"
+            "For more information see https://docs.classiq.io/latest/qmod-reference/language-reference/generative-descriptions/",
+            ClassiqDeprecationWarning,
+            stacklevel=2,
+        )
+    elif generative is None:
+        generative = True
+    if get_global_declarative_switch():
+        generative = False
+
     def wrapper(func: Callable) -> QCallable:
         qfunc: BaseQFunc
 
@@ -77,7 +85,7 @@ def qfunc(
             _validate_directives(synthesize_separately, atomic_qualifiers)
             return ExternalQFunc(func)
 
-        if generative or _GENERATIVE_SWITCH:
+        if generative:
             qfunc = GenerativeQFunc(func)
         else:
             qfunc = QFunc(func)

classiq/qmod/qmod_constant.py

@@ -1,6 +1,6 @@
 import inspect
 from dataclasses import is_dataclass
-from typing import Any, Optional, cast, get_origin
+from typing import TYPE_CHECKING, Any, Optional, cast, get_origin
 
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
@@ -17,7 +17,7 @@ from classiq.qmod.generative import (
     interpret_expression,
     is_generative_mode,
 )
-from classiq.qmod.model_state_container import ModelStateContainer
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.utilities import qmod_val_to_expr_str
@@ -42,11 +42,12 @@ class QConstant(SymbolicExpr):
 
     def add_to_model(self) -> None:
         from classiq.qmod.builtins.constants import __all__ as builtin_constants
+        from classiq.qmod.semantics.validation.constants_validation import (
+            check_duplicate_constants,
+        )
 
-        if self.name in builtin_constants:
+        if self.name in builtin_constants or QConstant.CURRENT_QMODULE is None:
             return
-        if QConstant.CURRENT_QMODULE is None:
-            raise ClassiqError(QMODULE_ERROR_MESSAGE)
 
         expr = qmod_val_to_expr_str(self._value)
         if (
@@ -57,6 +58,7 @@ class QConstant(SymbolicExpr):
 
         constant = self._get_constant_node()
         QConstant.CURRENT_QMODULE.constants[self.name] = constant
+        check_duplicate_constants([constant])
         if is_generative_mode():
             get_frontend_interpreter().add_constant(constant)
 
@@ -106,8 +108,10 @@ class QConstant(SymbolicExpr):
     def __getitem__(self, item: Any) -> CParam:
         self.add_to_model()
 
-        assert QConstant.CURRENT_QMODULE is not None
-
+        if QConstant.CURRENT_QMODULE is None:
+            QConstant.set_current_model(QMODULE)
+        if TYPE_CHECKING:
+            assert QConstant.CURRENT_QMODULE is not None
         qmod_type = python_type_to_qmod(
             self._py_type, qmodule=QConstant.CURRENT_QMODULE
         )
@@ -141,3 +145,7 @@ class QConstant(SymbolicExpr):
         if is_generative_mode():
             return interpret_expression(len_expr)
         return cast(int, CParamScalar(len_expr))
+
+    def __str__(self) -> str:
+        self.add_to_model()
+        return super().__str__()

classiq/qmod/qmod_variable.py

@@ -70,6 +70,8 @@ from classiq.qmod.generative import (
 )
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.validation.types_validation import validate_qstruct
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 from classiq.qmod.utilities import (
@@ -696,6 +698,8 @@ def _register_qstruct(
     if type_hint is QStruct or struct_name in qmodule.qstruct_decls:
         return
 
+    # temp assignment for recursive qstruct definitions
+    qmodule.qstruct_decls[struct_name] = QStructDeclaration(name=struct_name)
     _validate_fields(type_hint)
     struct_decl = QStructDeclaration(
         name=struct_name,
@@ -705,6 +709,8 @@ def _register_qstruct(
         },
     )
     qmodule.qstruct_decls[struct_name] = struct_decl
+    QStructAnnotator().visit(struct_decl)
+    validate_qstruct(struct_decl)
 
 
 def _validate_fields(type_hint: type[QStruct]) -> None:
@@ -749,5 +755,5 @@ def _get_root_type(py_type: Any) -> type[QVar]:
     )
     root_type = get_origin(non_annotated_type) or non_annotated_type
     if not issubclass(root_type, QVar):
-        raise ClassiqInternalError(f"Invalid quantum type {root_type}")
+        raise ClassiqValueError(f"Invalid quantum type {root_type.__name__!r}")
     return root_type