classiq 0.42.2__py3-none-any.whl → 0.43.1__py3-none-any.whl

classiq/qmod/native/pretty_printer.py

@@ -5,10 +5,12 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ConcreteClassicalType,
+    TypeName,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -57,8 +59,11 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq import Bool, ClassicalList, Integer, Pauli, Real, Struct, StructDeclaration
+from classiq import Bool, ClassicalList, Integer, Real, StructDeclaration
 from classiq.qmod.native.expression_to_qmod import transform_expression
+from classiq.qmod.semantics.static_semantics_visitor import (
+    static_semantics_analysis_pass,
+)
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
@@ -76,6 +81,9 @@ class DSLPrettyPrinter(Visitor):
         return res
 
     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).
+        static_semantics_analysis_pass(model)
+        enum_decls = [self.visit(enum_decl) for enum_decl in model.enums]
         struct_decls = [self.visit(struct_decl) for struct_decl in model.types]
         func_defs = [self.visit(func_def) for func_def in model.functions]
         constants = [self.visit(constant) for constant in model.constants]
@@ -84,7 +92,9 @@ class DSLPrettyPrinter(Visitor):
             if model.classical_execution_code
             else ""
         )
-        return "\n".join([*constants, *struct_decls, *func_defs, classical_code])
+        return "\n".join(
+            [*constants, *enum_decls, *struct_decls, *func_defs, classical_code]
+        )
 
     def visit_Constant(self, constant: Constant) -> str:
         return f"{self._indent}{self.visit(constant.name)}: {self.visit(constant.const_type)} = {self.visit(constant.value)};\n"
@@ -108,6 +118,18 @@ class DSLPrettyPrinter(Visitor):
     ) -> str:
         return f"qfunc {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"
+
+    def _visit_members(self, members: Dict[str, int]) -> str:
+        self._level += 1
+        members_str = "".join(
+            f"{self._indent}{self.visit(member_name)} = {member_value};\n"
+            for member_name, member_value in members.items()
+        )
+        self._level -= 1
+        return members_str
+
     def visit_StructDeclaration(self, struct_decl: StructDeclaration) -> str:
         return f"struct {struct_decl.name} {{\n{self._visit_variables(struct_decl.variables)}}}\n"
 
@@ -137,9 +159,10 @@ class DSLPrettyPrinter(Visitor):
         return "qbit"
 
     def visit_QuantumBitvector(self, qtype: QuantumBitvector) -> str:
+        element_type = self.visit(qtype.element_type)
         if qtype.length is not None:
-            return f"qbit[{self.visit(qtype.length)}]"
-        return "qbit[]"
+            return f"{element_type}[{self.visit(qtype.length)}]"
+        return f"{element_type}[]"
 
     def visit_QuantumNumeric(self, qtype: QuantumNumeric) -> str:
         params = ""
@@ -170,17 +193,14 @@ class DSLPrettyPrinter(Visitor):
     def visit_Bool(self, ctbool: Bool) -> str:
         return "bool"
 
-    def visit_Pauli(self, ctbool: Pauli) -> str:
-        return "Pauli"
-
     def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
         return f"{self.visit(ctlist.element_type)}[]"
 
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         return f"{self.visit(ctarray.element_type)}[{ctarray.size}]"
 
-    def visit_Struct(self, struct: Struct) -> str:
-        return struct.name
+    def visit_TypeName(self, type_: TypeName) -> str:
+        return type_.name
 
     def visit_VariableDeclarationStatement(
         self, local_decl: VariableDeclarationStatement
@@ -266,9 +286,7 @@ class DSLPrettyPrinter(Visitor):
         return code
 
     def visit_InplaceBinaryOperation(self, op: InplaceBinaryOperation) -> str:
-        return (
-            f"{self._indent}{op.operation.value}({op.value.name}, {op.target.name});\n"
-        )
+        return f"{self._indent}{op.operation.value}({self.visit(op.value)}, {self.visit(op.target)});\n"
 
     def _visit_pack_expr(self, vars: List[HandleBinding]) -> str:
         if len(vars) == 1:
@@ -290,7 +308,7 @@ class DSLPrettyPrinter(Visitor):
             if not isinstance(arg_decl, PortDeclaration)
         )
         quantum_args = ", ".join(
-            arg_decl.name
+            qlambda.rename_params.get(arg_decl.name, arg_decl.name)
             for arg_decl in qlambda.func_decl.get_positional_arg_decls()
             if isinstance(arg_decl, PortDeclaration)
         )

classiq/qmod/pretty_print/pretty_printer.py

@@ -7,10 +7,12 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ConcreteClassicalType,
+    TypeName,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -64,7 +66,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.model.within_apply_operation import WithinApply
 
 import classiq
-from classiq import Bool, ClassicalList, Integer, Pauli, Real, Struct, StructDeclaration
+from classiq import Bool, ClassicalList, Integer, Real, StructDeclaration
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
@@ -110,7 +112,10 @@ class PythonPrettyPrinter(Visitor):
         self._level = 0
         self._decimal_precision = decimal_precision
         self._imports = {"qfunc": 1}
+        self._import_enum = False
+        self._import_dataclass = False
         self._symbolic_imports: Dict[str, int] = dict()
+        self._functions: Optional[Dict[str, QuantumFunctionDeclaration]] = None
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -119,12 +124,17 @@ class PythonPrettyPrinter(Visitor):
         return res
 
     def visit_Model(self, model: Model) -> str:
+        self._functions = {
+            **model.function_dict,
+            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
+        }
+        enum_decls = [self.visit(decl) for decl in model.enums]
         struct_decls = [self.visit(decl) for decl in model.types]
         func_defs = [self.visit(func) for func in model.functions]
         constants = [self.visit(const) for const in model.constants]
         classical_code = self.format_classical_code(model.classical_execution_code)
 
-        code = f"{self.format_imports()}\n\n{self.join_code_parts(*constants, *struct_decls, *func_defs, classical_code)}"
+        code = f"{self.format_imports()}\n\n{self.join_code_parts(*constants, *enum_decls, *struct_decls, *func_defs, classical_code)}"
         return black.format_str(code, mode=black.FileMode())
 
     def format_classical_code(self, code: str) -> str:
@@ -147,7 +157,16 @@ class PythonPrettyPrinter(Visitor):
             if self._symbolic_imports
             else ""
         )
-        return imports + symbolic_imports
+        return self.special_imports + imports + symbolic_imports
+
+    @property
+    def special_imports(self) -> str:
+        imports = ""
+        if self._import_dataclass:
+            imports += "from dataclasses import dataclass\n"
+        if self._import_enum:
+            imports += "from enum import IntEnum\n"
+        return imports
 
     def join_code_parts(self, *code_parts: str) -> str:
         return "\n".join(code_parts)
@@ -169,9 +188,22 @@ class PythonPrettyPrinter(Visitor):
             f"@qfunc\ndef {func_decl.name}({self._visit_arg_decls(func_decl)}) -> None:"
         )
 
+    def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
+        self._import_enum = True
+        return f"class {enum_decl.name}(IntEnum):\n{self._visit_members(enum_decl.members)}\n"
+
+    def _visit_members(self, members: Dict[str, int]) -> str:
+        self._level += 1
+        members_str = "".join(
+            f"{self._indent}{self.visit(member_name)} = {member_value}\n"
+            for member_name, member_value in members.items()
+        )
+        self._level -= 1
+        return members_str
+
     def visit_StructDeclaration(self, struct_decl: StructDeclaration) -> str:
-        self._imports["struct"] = 1
-        return f"@struct\nclass {struct_decl.name}:\n{self._visit_variables(struct_decl.variables)}\n"
+        self._import_dataclass = True
+        return f"@dataclass\nclass {struct_decl.name}:\n{self._visit_variables(struct_decl.variables)}\n"
 
     def _visit_variables(self, variables: Dict[str, ConcreteClassicalType]) -> str:
         self._level += 1
@@ -205,9 +237,10 @@ class PythonPrettyPrinter(Visitor):
 
     def visit_QuantumBitvector(self, qtype: QuantumBitvector) -> str:
         self._imports.update({"QArray": 1, "QBit": 1})
+        element_type = self.visit(qtype.element_type)
         if qtype.length is not None:
-            return f"QArray[QBit, {_add_quotes(self.visit(qtype.length))}]"
-        return "QArray[QBit]"
+            return f"QArray[{element_type}, {_add_quotes(self.visit(qtype.length))}]"
+        return f"QArray[{element_type}]"
 
     def visit_QuantumNumeric(self, qtype: QuantumNumeric) -> str:
         params = ""
@@ -242,10 +275,6 @@ class PythonPrettyPrinter(Visitor):
         self._imports["CBool"] = 1
         return "CBool"
 
-    def visit_Pauli(self, ctbool: Pauli) -> str:
-        self._imports["Pauli"] = 1
-        return "Pauli"
-
     def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
         self._imports["CArray"] = 1
         return f"CArray[{self.visit(ctlist.element_type)}]"
@@ -254,10 +283,12 @@ class PythonPrettyPrinter(Visitor):
         self._imports["CArray"] = 1
         return f"CArray[{self.visit(ctarray.element_type)}, {ctarray.size}]"
 
-    def visit_Struct(self, struct: Struct) -> str:
-        if struct.name in dir(classiq.qmod.builtins.structs):
-            self._imports[struct.name] = 1
-        return struct.name
+    def visit_TypeName(self, type_: TypeName) -> str:
+        if type_.name in dir(classiq.qmod.builtins.enums) + dir(
+            classiq.qmod.builtins.structs
+        ):
+            self._imports[type_.name] = 1
+        return type_.name
 
     def visit_VariableDeclarationStatement(
         self, local_decl: VariableDeclarationStatement
@@ -299,13 +330,14 @@ class PythonPrettyPrinter(Visitor):
         return f"{self.visit_QuantumFunctionDeclaration(func_def)} \n{body}\n"
 
     def visit_QuantumFunctionCall(self, func_call: QuantumFunctionCall) -> str:
-        if len(func_call.get_positional_args()) <= 2:
+        if len(func_call.get_positional_args()) <= 2 or self._functions is None:
             args = ", ".join(self.visit(arg) for arg in func_call.get_positional_args())
         else:
+            func_decl = self._functions[func_call.func_name]
             args = ", ".join(
                 f"{self.visit(arg_decl.name)}={self.visit(arg)}"
                 for arg_decl, arg in zip(
-                    func_call.func_decl.get_positional_arg_decls(),
+                    func_decl.get_positional_arg_decls(),
                     func_call.get_positional_args(),
                 )
             )
@@ -343,9 +375,7 @@ class PythonPrettyPrinter(Visitor):
         if len(body) == 0:
             return "None"
         argument_string = (
-            (" " + ", ".join(operand_arguments))
-            if operand_arguments is not None
-            else ""
+            (" " + ", ".join(operand_arguments)) if operand_arguments else ""
         )
         code = f"lambda{argument_string}: {'[' if len(body) > 1 else ''}\n"
         self._level += 1
@@ -364,9 +394,7 @@ class PythonPrettyPrinter(Visitor):
 
     def visit_InplaceBinaryOperation(self, op: InplaceBinaryOperation) -> str:
         self._imports[op.operation.value] = 1
-        return (
-            f"{self._indent}{op.operation.value}({op.value.name}, {op.target.name})\n"
-        )
+        return f"{self._indent}{op.operation.value}({self.visit(op.value)}, {self.visit(op.target)})\n"
 
     def visit_Expression(self, expr: Expression) -> str:
         return transform_expression(
@@ -381,10 +409,7 @@ class PythonPrettyPrinter(Visitor):
         assert qlambda.func_decl is not None
         return self._visit_body(
             qlambda.body,
-            [
-                self.visit(arg_decl.name)
-                for arg_decl in qlambda.func_decl.get_positional_arg_decls()
-            ],
+            list(qlambda.rename_params.values()),
         )
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:

classiq/qmod/qmod_constant.py

@@ -1,4 +1,5 @@
 import inspect
+from dataclasses import is_dataclass
 from typing import Any, Optional
 
 from classiq.interface.generator.constant import Constant
@@ -6,7 +7,6 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
-    CStructBase,
 )
 
 from classiq.exceptions import ClassiqError
@@ -14,6 +14,7 @@ from classiq.qmod.declaration_inferrer import python_type_to_qmod
 from classiq.qmod.model_state_container import 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
 
 
 class QConstant(SymbolicExpr):
@@ -34,7 +35,7 @@ class QConstant(SymbolicExpr):
                 "Error trying to add a constant to a model without a current QModule."
             )
 
-        expr = str(self._value)
+        expr = qmod_val_to_expr_str(self._value)
         if (
             self.name in QConstant.CURRENT_QMODULE.constants
             and expr != QConstant.CURRENT_QMODULE.constants[self.name].value.expr
@@ -65,11 +66,14 @@ class QConstant(SymbolicExpr):
     def __getattr__(self, name: str) -> CParam:
         self.add_to_model()
 
+        if name == "is_quantum":
+            return False  # type:ignore[return-value]
+
         py_type = type(self._value)
         if (
             QConstant.CURRENT_QMODULE is None
             or not inspect.isclass(py_type)
-            or not issubclass(py_type, CStructBase)
+            or not is_dataclass(py_type)
         ):
             return self.__getattribute__(name)
 

classiq/qmod/qmod_parameter.py

@@ -34,7 +34,8 @@ else:
 
 
 class CParam(SymbolicSuperclass):
-    pass
+    def __init__(self, expr: str) -> None:
+        super().__init__(expr, False)
 
 
 class CInt(CParam):

classiq/qmod/qmod_struct.py

@@ -1,37 +1,13 @@
-import dataclasses
-from typing import Any, Type
+import warnings
+from dataclasses import dataclass
+from typing import Type
 
-from typing_extensions import dataclass_transform
 
-from classiq.interface.generator.functions.classical_type import CStructBase
-
-
-def _qmod_val_to_expr_str(val: Any) -> str:
-    if dataclasses.is_dataclass(type(val)):
-        kwargs_str = ", ".join(
-            [
-                f"{field.name}={_qmod_val_to_expr_str(vars(val)[field.name])}"
-                for field in dataclasses.fields(val)
-            ]
-        )
-        return f"struct_literal({type(val).__name__}, {kwargs_str})"
-
-    if isinstance(val, list):
-        elements_str = ", ".join([_qmod_val_to_expr_str(elem) for elem in val])
-        return f"[{elements_str}]"
-
-    return str(val)
-
-
-@dataclass_transform()
 def struct(user_class: Type) -> Type:
-    def _new_repr(self: Any) -> str:
-        return _qmod_val_to_expr_str(self)
-
-    user_dataclass = type(
-        user_class.__name__,
-        (CStructBase, dataclasses.dataclass(user_class)),
-        dict(),
+    warnings.warn(
+        "@struct is deprecated and will be removed in a future release. "
+        "Use @dataclass instead.",
+        DeprecationWarning,
+        stacklevel=2,
     )
-    user_dataclass.__repr__ = _new_repr  # type:ignore[assignment]
-    return user_dataclass
+    return dataclass(user_class)

classiq/qmod/qmod_variable.py

@@ -54,7 +54,7 @@ from classiq.qmod.utilities import get_source_ref, version_portable_get_args
 
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
 SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
-UNSUPPORTED_ELEMENT_TYPE = "Only QBit is supported as element type for QArray"
+UNSUPPORTED_ELEMENT_TYPE = "Only QBit and QNum are supported as element type for QArray"
 QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
 
 
@@ -84,12 +84,13 @@ def _no_current_expandable() -> Iterator[None]:
 
 
 class QVar(Symbolic):
-    def __init__(self, name: str) -> None:
-        super().__init__(name)
+    def __init__(self, name: str, depth: int = 2) -> None:
+        super().__init__(name, True)
         self._name = name
+        source_ref = get_source_ref(sys._getframe(depth))
         if QCallable.CURRENT_EXPANDABLE is not None:
             QCallable.CURRENT_EXPANDABLE.add_local_handle(
-                self._name, self.get_qmod_type()
+                self._name, self.get_qmod_type(), source_ref
             )
 
     @abc.abstractmethod
@@ -132,9 +133,9 @@ Input = Annotated[_Q, PortDeclarationDirection.Input]
 
 
 class QScalar(QVar, SymbolicExpr):
-    def __init__(self, name: str) -> None:
-        QVar.__init__(self, name)
-        SymbolicExpr.__init__(self, name)
+    def __init__(self, name: str, depth: int = 2) -> None:
+        QVar.__init__(self, name, depth)
+        SymbolicExpr.__init__(self, name, True)
 
     def _insert_arith_operation(
         self, expr: SymbolicTypes, inplace: bool, source_ref: SourceReference
@@ -245,7 +246,7 @@ class QNum(Generic[_P], QScalar):
         self._fraction_digits = (
             None if fraction_digits is None else Expression(expr=str(fraction_digits))
         )
-        super().__init__(name)
+        super().__init__(name, 3)
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
@@ -300,7 +301,7 @@ class QArray(ArrayBase[_P], QVar):
         slice_: Optional[Tuple[int, int]] = None,
         index_: Optional[Union[int, CInt]] = None,
     ) -> None:
-        if element_type is not QBit:
+        if not issubclass(get_origin(element_type) or element_type, (QBit, QNum)):
             raise ClassiqValueError(UNSUPPORTED_ELEMENT_TYPE)
         self._element_type = element_type
         self._length = length
@@ -324,7 +325,7 @@ class QArray(ArrayBase[_P], QVar):
 
         return HandleBinding(name=self._name)
 
-    def __getitem__(self, key: Union[slice, int, CInt]) -> "QArray":
+    def __getitem__(self, key: Union[slice, int, CInt]) -> Any:
         if self._index is not None:
             raise ClassiqValueError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
 
@@ -356,7 +357,11 @@ class QArray(ArrayBase[_P], QVar):
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
         # prevent addition to local handles, since this is used for slicing existing local handles
         with _no_current_expandable():
-            return QArray(
+            if new_index is None:
+                array_class = QArray
+            else:
+                array_class = QArraySubscript
+            return array_class(
                 self._name, length=self._length, slice_=new_slice, index_=new_index
             )
 
@@ -386,27 +391,55 @@ class QArray(ArrayBase[_P], QVar):
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
+        type_args = version_portable_get_args(type_hint)
+        if len(type_args) == 1 and isinstance(type_args[0], (str, int)):
+            type_args = (QBit, type_args[0])
+
+        api_element_type = QBit if len(type_args) == 0 else type_args[0]
+        api_element_class = get_origin(api_element_type) or api_element_type
+        element_type = api_element_class.to_qmod_quantum_type(api_element_type)
+
         length_expr: Optional[Expression] = None
-        if len(version_portable_get_args(type_hint)) == 2:
-            length_expr = Expression(
-                expr=get_type_hint_expr(version_portable_get_args(type_hint)[1])
-            )
-        return QuantumBitvector(length=length_expr)
+        if len(type_args) == 2:
+            length_expr = Expression(expr=get_type_hint_expr(type_args[1]))
+
+        return QuantumBitvector(element_type=element_type, length=length_expr)
 
     def get_qmod_type(self) -> QuantumType:
+        element_class = get_origin(self._element_type) or self._element_type
+        length = None
         if self._length is not None:
-            return QuantumBitvector(length=Expression(expr=str(self._length)))
-        return QuantumBitvector()
+            length = Expression(expr=str(self._length))
+        return QuantumBitvector(
+            element_type=element_class.to_qmod_quantum_type(self._element_type),
+            length=length,
+        )
+
+
+class QArraySubscript(QArray, QScalar):
+    @property
+    def size(self) -> CParamScalar:
+        return CParamScalar(f"get_field({self.get_handle_binding()}, 'size')")
+
+    @property
+    def fraction_digits(self) -> CParamScalar:
+        return CParamScalar(
+            f"get_field({self.get_handle_binding()}, 'fraction_digits')"
+        )
+
+    @property
+    def is_signed(self) -> CParamScalar:
+        return CParamScalar(f"get_field({self.get_handle_binding()}, 'is_signed')")
 
 
-def create_qvar_for_port_decl(port: PortDeclaration) -> QVar:
+def create_qvar_for_port_decl(port: PortDeclaration, name: str) -> QVar:
     # prevent addition to local handles, since this is used for ports
     with _no_current_expandable():
         if _is_single_qbit_vector(port):
-            return QBit(port.name)
+            return QBit(name)
         elif isinstance(port.quantum_type, QuantumNumeric):
-            return QNum(port.name)
-        return QArray(port.name)
+            return QNum(name)
+        return QArray(name)
 
 
 def _is_single_qbit_vector(port: PortDeclaration) -> bool:

classiq/qmod/quantum_callable.py

@@ -35,7 +35,12 @@ class QExpandableInterface(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    def add_local_handle(self, name: str, qtype: QuantumType) -> None:
+    def add_local_handle(
+        self,
+        name: str,
+        qtype: QuantumType,
+        source_ref: Optional[SourceReference] = None,
+    ) -> None:
         raise NotImplementedError()
 
 

classiq/qmod/quantum_expandable.py

@@ -1,5 +1,7 @@
 import inspect
 from abc import ABC
+from dataclasses import is_dataclass
+from enum import Enum as PythonEnum
 from types import TracebackType
 from typing import (
     TYPE_CHECKING,
@@ -51,7 +53,7 @@ from classiq.qmod.qmod_parameter import CInt, CParam, CParamScalar, create_param
 from classiq.qmod.qmod_variable import QVar, create_qvar_for_port_decl
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
-from classiq.qmod.utilities import mangle_keyword
+from classiq.qmod.utilities import mangle_keyword, qmod_val_to_expr_str
 
 ArgType = Union[CParam, QVar, QCallable]
 
@@ -93,8 +95,17 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     def infer_rename_params(self) -> Dict[str, str]:
         return {}
 
-    def add_local_handle(self, name: str, qtype: QuantumType) -> None:
-        self._body.append(VariableDeclarationStatement(name=name, quantum_type=qtype))
+    def add_local_handle(
+        self,
+        name: str,
+        qtype: QuantumType,
+        source_ref: Optional[SourceReference] = None,
+    ) -> None:
+        self._body.append(
+            VariableDeclarationStatement(
+                name=name, quantum_type=qtype, source_ref=source_ref
+            )
+        )
 
     def append_statement_to_body(self, stmt: QuantumStatement) -> None:
         self._body.append(stmt)
@@ -102,14 +113,14 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     def _get_positional_args(self) -> List[ArgType]:
         result: List[ArgType] = []
         for arg in self.func_decl.get_positional_arg_decls():
+            rename_dict = self.infer_rename_params()
+            actual_name = rename_dict.get(arg.name, arg.name)
             if isinstance(arg, ClassicalParameterDeclaration):
-                rename_dict = self.infer_rename_params()
-                actual_name = rename_dict.get(arg.name, arg.name)
                 result.append(
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
             elif isinstance(arg, PortDeclaration):
-                result.append(create_qvar_for_port_decl(arg))
+                result.append(create_qvar_for_port_decl(arg, actual_name))
             else:
                 assert isinstance(arg, QuantumOperandDeclaration)
                 result.append(QTerminalCallable(arg))
@@ -135,11 +146,11 @@ class QLambdaFunction(QExpandable):
 
     def infer_rename_params(self) -> Dict[str, str]:
         py_params = inspect.getfullargspec(self._py_callable)
-        decl_params = self.func_decl.param_decls.keys()
+        decl_params = self.func_decl.get_positional_arg_decls()
         return {
-            decl_param: py_param
+            decl_param.name: py_param
             for decl_param, py_param in zip(decl_params, py_params.args)
-            if decl_param != py_param
+            if decl_param.name != py_param
         }
 
 
@@ -215,7 +226,7 @@ def prepare_arg(arg_decl: PositionalArg, val: Any, func_name: str) -> ArgValue:
         return Expression(expr=str(val.name))
     if isinstance(arg_decl, ClassicalParameterDeclaration):
         _validate_classical_arg(val, arg_decl, func_name)
-        return Expression(expr=str(val))
+        return Expression(expr=qmod_val_to_expr_str(val))
     elif isinstance(arg_decl, PortDeclaration):
         if not isinstance(val, QVar):
             raise ClassiqValueError(
@@ -249,7 +260,14 @@ def prepare_arg(arg_decl: PositionalArg, val: Any, func_name: str) -> ArgValue:
 def _validate_classical_arg(
     arg: Any, arg_decl: ClassicalParameterDeclaration, func_name: str
 ) -> None:
-    if not isinstance(arg, (*PythonClassicalTypes, CParam, SymbolicExpr, Basic)):
+    if (
+        not isinstance(
+            arg, (*PythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum)
+        )
+        and not is_dataclass(arg)  # type:ignore[unreachable]
+        or isinstance(arg, SymbolicExpr)
+        and arg.is_quantum
+    ):
         raise ClassiqValueError(
             f"Argument {str(arg)!r} to parameter {arg_decl.name!r} of function "
             f"{func_name!r} has incompatible type; expected "