classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/qmod/model_state_container.py

@@ -1,5 +1,3 @@
-from typing import Dict
-
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
@@ -8,11 +6,11 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 
 
 class ModelStateContainer:
-    enum_decls: Dict[str, EnumDeclaration]
-    type_decls: Dict[str, StructDeclaration]
-    qstruct_decls: Dict[str, QStructDeclaration]
-    native_defs: Dict[str, NativeFunctionDefinition]
-    constants: Dict[str, Constant]
+    enum_decls: dict[str, EnumDeclaration]
+    type_decls: dict[str, StructDeclaration]
+    qstruct_decls: dict[str, QStructDeclaration]
+    native_defs: dict[str, NativeFunctionDefinition]
+    constants: dict[str, Constant]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/__init__.py

@@ -1,9 +1,7 @@
-from typing import List
-
 from .pretty_printer import DSLPrettyPrinter
 
 __all__ = ["DSLPrettyPrinter"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/native/expression_to_qmod.py

@@ -1,14 +1,15 @@
 import ast
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Optional, Type
+from typing import Callable, Optional
 
 import numpy as np
 
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
-BINARY_OPS: Mapping[Type[ast.operator], str] = {
+BINARY_OPS: Mapping[type[ast.operator], str] = {
     ast.Add: "+",
     ast.Sub: "-",
     ast.Mult: "*",
@@ -21,14 +22,14 @@ BINARY_OPS: Mapping[Type[ast.operator], str] = {
     ast.LShift: "<<",
     ast.RShift: ">>",
 }
-BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
-UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
     ast.UAdd: "+",
     ast.USub: "-",
     ast.Invert: "~",
     ast.Not: "not",
 }
-COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -139,7 +140,7 @@ class ASTToQMODCode:
         else:
             raise AssertionError("Error parsing expression: unsupported AST node.")
 
-    def indent_items(self, items: Callable[[], List[str]]) -> str:
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
@@ -165,8 +166,8 @@ class ASTToQMODCode:
 def _remove_redundant_parentheses(expr: str) -> str:
     if not (expr.startswith("(") and expr.endswith(")")):
         return expr
-    parentheses_map: Dict[int, int] = dict()
-    stack: List[int] = []
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
     for index, char in enumerate(expr):
         if char == "(":
             stack.append(index)

classiq/qmod/native/pretty_printer.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Mapping, Optional, Union
+from collections.abc import Mapping
+from typing import Optional, Union
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
@@ -135,7 +136,7 @@ class DSLPrettyPrinter(Visitor):
     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:
+    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"
@@ -310,7 +311,7 @@ class DSLPrettyPrinter(Visitor):
     def visit_InplaceBinaryOperation(self, op: InplaceBinaryOperation) -> str:
         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:
+    def _visit_pack_expr(self, vars: list[HandleBinding]) -> str:
         if len(vars) == 1:
             return self.visit(vars[0])
 
@@ -324,7 +325,7 @@ class DSLPrettyPrinter(Visitor):
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
         positional_args = ", ".join(
-            qlambda.get_rename_params()[idx]
+            qlambda.pos_rename_params[idx]
             for idx, arg_decl in enumerate(
                 qlambda.func_decl.positional_arg_declarations
             )
@@ -358,7 +359,7 @@ class DSLPrettyPrinter(Visitor):
     ) -> str:
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)};\n"
 
-    def _print_bind_handles(self, handles: List[HandleBinding]) -> str:
+    def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])
 

classiq/qmod/pretty_print/__init__.py

@@ -1,9 +1,7 @@
-from typing import List
-
 from .pretty_printer import PythonPrettyPrinter
 
 __all__ = ["PythonPrettyPrinter"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/pretty_print/expression_to_python.py

@@ -1,7 +1,8 @@
 import ast
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Type
+from typing import Callable
 
 import numpy as np
 
@@ -9,7 +10,7 @@ import classiq
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
-BINARY_OPS: Mapping[Type[ast.operator], str] = {
+BINARY_OPS: Mapping[type[ast.operator], str] = {
     ast.Add: "+",
     ast.Sub: "-",
     ast.Mult: "*",
@@ -22,14 +23,14 @@ BINARY_OPS: Mapping[Type[ast.operator], str] = {
     ast.LShift: "<<",
     ast.RShift: ">>",
 }
-BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
-UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
     ast.UAdd: "+",
     ast.USub: "-",
     ast.Invert: "~",
     ast.Not: "not",
 }
-COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -43,8 +44,8 @@ LIST_FORMAT_CHAR_LIMIT = 20
 @dataclass
 class ASTToQMODCode(ast.NodeVisitor):
     level: int
-    imports: Dict[str, int]
-    symbolic_imports: Dict[str, int]
+    imports: dict[str, int]
+    symbolic_imports: dict[str, int]
     decimal_precision: int
     indent_seq: str = "    "
 
@@ -162,7 +163,7 @@ class ASTToQMODCode(ast.NodeVisitor):
     def generic_visit(self, node: ast.AST) -> None:
         raise AssertionError("Cannot parse node of type: " + type(node).__name__)
 
-    def indent_items(self, items: Callable[[], List[str]]) -> str:
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
@@ -188,8 +189,8 @@ class ASTToQMODCode(ast.NodeVisitor):
 def _remove_redundant_parentheses(expr: str) -> str:
     if not (expr.startswith("(") and expr.endswith(")")):
         return expr
-    parentheses_map: Dict[int, int] = dict()
-    stack: List[int] = []
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
     for index, char in enumerate(expr):
         if char == "(":
             stack.append(index)
@@ -208,8 +209,8 @@ def _remove_redundant_parentheses(expr: str) -> str:
 
 def transform_expression(
     expr: str,
-    imports: Dict[str, int],
-    symbolic_imports: Dict[str, int],
+    imports: dict[str, int],
+    symbolic_imports: dict[str, int],
     level: int = 0,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
 ) -> str:

classiq/qmod/pretty_print/pretty_printer.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Mapping, Optional, Tuple, Union, cast
+from collections.abc import Mapping
+from typing import Optional, Union, cast
 
 import black
 
@@ -88,20 +89,20 @@ class VariableDeclarationAssignment(Visitor):
     def __init__(self, pretty_printer: "PythonPrettyPrinter") -> None:
         self.pretty_printer = pretty_printer
 
-    def visit(self, node: NodeType) -> Tuple[str, Optional[List[str]]]:
+    def visit(self, node: NodeType) -> tuple[str, Optional[list[str]]]:
         res = super().visit(node)
         if not isinstance(res, tuple):
             raise AssertionError(f"Pretty printing for {type(node)} is not supported ")
         return res  # type: ignore[return-value]
 
-    def visit_QuantumBit(self, qtype: QuantumBit) -> Tuple[str, Optional[List[str]]]:
+    def visit_QuantumBit(self, qtype: QuantumBit) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QBit"] = 1
 
         return "QBit", None
 
     def visit_QuantumBitvector(
         self, qtype: QuantumBitvector
-    ) -> Tuple[str, Optional[List[str]]]:
+    ) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QArray"] = 1
 
         element_type = self.pretty_printer.visit(qtype.element_type)
@@ -111,7 +112,7 @@ class VariableDeclarationAssignment(Visitor):
 
     def visit_QuantumNumeric(
         self, qtype: QuantumNumeric
-    ) -> Tuple[str, Optional[List[str]]]:
+    ) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QNum"] = 1
 
         params = []
@@ -124,7 +125,7 @@ class VariableDeclarationAssignment(Visitor):
 
         return "QNum", params
 
-    def visit_TypeName(self, qtype: TypeName) -> Tuple[str, None]:
+    def visit_TypeName(self, qtype: TypeName) -> tuple[str, None]:
         return qtype.name, None
 
 
@@ -136,7 +137,7 @@ class PythonPrettyPrinter(Visitor):
         self._import_enum = False
         self._import_dataclass = False
         self._import_annotated = False
-        self._symbolic_imports: Dict[str, int] = dict()
+        self._symbolic_imports: dict[str, int] = dict()
         self._functions: Optional[Mapping[str, QuantumFunctionDeclaration]] = None
 
     def visit(self, node: NodeType) -> str:
@@ -183,7 +184,7 @@ class PythonPrettyPrinter(Visitor):
     def special_imports(self) -> str:
         imports = ""
         if self._import_annotated:
-            imports += "from typing_extensions import Annotated\n"
+            imports += "from typing import Annotated\n"
         if self._import_dataclass:
             imports += "from dataclasses import dataclass\n"
         if self._import_enum:
@@ -214,7 +215,7 @@ class PythonPrettyPrinter(Visitor):
         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:
+    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"
@@ -418,7 +419,7 @@ class PythonPrettyPrinter(Visitor):
         return f"{self._indent}invert({self._visit_body(invert.body)})\n"
 
     def _visit_body(
-        self, body: StatementBlock, operand_arguments: Optional[List[str]] = None
+        self, body: StatementBlock, operand_arguments: Optional[list[str]] = None
     ) -> str:
         if len(body) == 0:
             return "lambda: []"
@@ -454,7 +455,7 @@ class PythonPrettyPrinter(Visitor):
         )
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
-        return self._visit_body(qlambda.body, qlambda.get_rename_params())
+        return self._visit_body(qlambda.body, qlambda.pos_rename_params)
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
         return var_ref.name
@@ -482,7 +483,7 @@ class PythonPrettyPrinter(Visitor):
     ) -> str:
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)}\n"
 
-    def _print_bind_handles(self, handles: List[HandleBinding]) -> str:
+    def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])
 

classiq/qmod/python_classical_type.py

@@ -26,6 +26,11 @@ if sys.version_info[0:2] >= (3, 9):
     pass
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
+CARRAY_ERROR_MESSAGE = (
+    "CArray accepts one or two generic parameters in the form "
+    "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
+)
+
 
 class PythonClassicalType:
     def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
@@ -48,16 +53,15 @@ class PythonClassicalType:
                     element_type=self.convert(array_args[0]),
                     size=get_type_hint_expr(array_args[1]),
                 )
-            raise ClassiqValueError(
-                "CArray accepts one or two generic parameters in the form "
-                "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
-            )
+            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__)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
             return Enum(name=py_type.__name__)
+        elif py_type in (CArray, list):
+            raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None
 
     def register_struct(self, py_type: type) -> None:

classiq/qmod/qfunc.py

@@ -1,14 +1,14 @@
-from typing import Callable, List, Literal, Optional, Union, overload
+from typing import Callable, Literal, Optional, Union, overload
 
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
 
-GEN_QFUNCS: List[GenerativeQFunc] = []
-DEC_QFUNCS: List[QFunc] = []
+GEN_QFUNCS: list[GenerativeQFunc] = []
+DEC_QFUNCS: list[QFunc] = []
 
 
 def set_discovered_functions(
-    dec_funcs: List[QFunc], gen_funcs: List[GenerativeQFunc]
+    dec_funcs: list[QFunc], gen_funcs: list[GenerativeQFunc]
 ) -> None:
     DEC_QFUNCS.clear()
     DEC_QFUNCS.extend(dec_funcs)

classiq/qmod/qmod_parameter.py

@@ -44,7 +44,9 @@ class CParamList(CParam):
         self._list_type = list_type
 
     def __getitem__(self, key: Any) -> CParam:
+        param_type = self._list_type.element_type
         if isinstance(key, slice):
+            param_type = self._list_type
             start = key.start if key.start is not None else ""
             stop = key.stop if key.stop is not None else ""
             if key.step is not None:
@@ -53,7 +55,7 @@ class CParamList(CParam):
                 key = f"{start}:{stop}"
         return create_param(
             f"({self})[{key}]",
-            self._list_type.element_type,
+            param_type,
             qmodule=self._qmodule,
         )
 

classiq/qmod/qmod_variable.py

@@ -1,17 +1,15 @@
 import abc
 import sys
+from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
+    Annotated,
     Any,
     ForwardRef,
     Generic,
-    Iterator,
     Literal,
-    Mapping,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     _GenericAlias,
@@ -20,7 +18,7 @@ from typing import (  # type: ignore[attr-defined]
     get_origin,
 )
 
-from typing_extensions import Annotated, ParamSpec, Self, _AnnotatedAlias
+from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
@@ -127,7 +125,7 @@ class QVar(Symbolic):
         raise NotImplementedError()
 
     @staticmethod
-    def from_type_hint(type_hint: Any) -> Optional[Type["QVar"]]:
+    def from_type_hint(type_hint: Any) -> Optional[type["QVar"]]:
         if _is_input_output_typehint(type_hint):
             return QVar.from_type_hint(type_hint.__args__[0])
         type_ = get_origin(type_hint) or type_hint
@@ -322,7 +320,7 @@ class QNum(Generic[_P], QScalar):
         super().__init__(name, _expr_str=_expr_str, depth=3)
 
     @classmethod
-    def _get_attributes(cls, type_hint: Any) -> Tuple[Any, Any, Any]:
+    def _get_attributes(cls, type_hint: Any) -> tuple[Any, Any, Any]:
         type_args = version_portable_get_args(type_hint)
         if len(type_args) == 0:
             return None, None, None
@@ -413,6 +411,9 @@ class QArray(ArrayBase[_P], QVar):
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
+    def __setitem__(self, *args: Any) -> None:
+        pass
+
     def _get_subscript(self, index: Union[slice, int, SymbolicExpr]) -> Any:
         if isinstance(index, SymbolicExpr) and index.is_quantum:
             raise ClassiqValueError("Non-classical parameter for slicing")
@@ -492,7 +493,7 @@ class QArray(ArrayBase[_P], QVar):
             return CParamScalar(f"get_field({self}, 'len')")
 
     @classmethod
-    def _get_attributes(cls, type_hint: Any) -> Tuple[Type[QVar], Any]:
+    def _get_attributes(cls, type_hint: Any) -> tuple[type[QVar], Any]:
         type_args = version_portable_get_args(type_hint)
         if len(type_args) == 0:
             return QBit, None
@@ -505,7 +506,7 @@ class QArray(ArrayBase[_P], QVar):
                 "QArray receives two type arguments: QArray[element_type: QVar, "
                 "length: int | CInt]"
             )
-        return cast(Tuple[Type[QVar], Any], type_args)
+        return cast(tuple[type[QVar], Any], type_args)
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
@@ -597,7 +598,7 @@ class QStruct(QVar):
         base_handle = HandleBinding(name=origin) if isinstance(origin, str) else origin
         with _no_current_expandable():
             field_vars = {
-                field_name: cast(Type[QVar], field_class).to_qvar(
+                field_name: cast(type[QVar], field_class).to_qvar(
                     FieldHandleBinding(base_handle=base_handle, field=field_name),
                     field_type,
                     f"get_field({expr_str if expr_str is not None else str(origin)}, '{field_name}')",

classiq/qmod/quantum_expandable.py

@@ -1,4 +1,5 @@
 import inspect
+import warnings
 from abc import ABC
 from dataclasses import is_dataclass
 from enum import Enum as PythonEnum
@@ -8,10 +9,7 @@ from typing import (
     Any,
     Callable,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Type,
     Union,
     cast,
     overload,
@@ -21,7 +19,7 @@ import pydantic
 from sympy import Basic
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import (
     NativePythonClassicalTypes,
@@ -73,15 +71,15 @@ ArgType = Union[CParam, QVar, QCallable]
 
 
 class QExpandable(QCallable, QExpandableInterface, ABC):
-    STACK: ClassVar[List["QExpandable"]] = list()
+    STACK: ClassVar[list["QExpandable"]] = list()
 
     def __init__(self, py_callable: Callable) -> None:
         self._qmodule: ModelStateContainer = QMODULE
         self._py_callable: Callable = py_callable
-        self._body: List[QuantumStatement] = list()
+        self._body: list[QuantumStatement] = list()
 
     @property
-    def body(self) -> List[QuantumStatement]:
+    def body(self) -> list[QuantumStatement]:
         return self._body
 
     def __enter__(self) -> Self:
@@ -92,7 +90,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
@@ -106,7 +104,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             with self, generative_mode_context(False):
                 self._py_callable(*self._get_positional_args())
 
-    def infer_rename_params(self) -> Optional[List[str]]:
+    def infer_rename_params(self) -> Optional[list[str]]:
         return None
 
     def add_local_handle(
@@ -124,8 +122,8 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     def append_statement_to_body(self, stmt: QuantumStatement) -> None:
         self._body.append(stmt)
 
-    def _get_positional_args(self) -> List[ArgType]:
-        result: List[ArgType] = []
+    def _get_positional_args(self) -> list[ArgType]:
+        result: list[ArgType] = []
         rename_params = self.infer_rename_params()
         if rename_params is not None and len(rename_params) != len(
             self.func_decl.positional_arg_declarations
@@ -178,7 +176,7 @@ class QLambdaFunction(QExpandable):
         if not is_generative_mode():
             super().expand()
 
-    def infer_rename_params(self) -> List[str]:
+    def infer_rename_params(self) -> list[str]:
         return inspect.getfullargspec(self._py_callable).args
 
 
@@ -312,7 +310,7 @@ def prepare_arg(
                     f"Quantum operand {param_name!r} cannot be initialized with a "
                     f"list of non-callables"
                 )
-            val = cast(List[Union[QCallable, Callable[[Any], None]]], val)
+            val = cast(list[Union[QCallable, Callable[[Any], None]]], val)
             return [prepare_arg(arg_decl, v, func_name, param_name) for v in val]
 
         if not isinstance(val, QCallable):
@@ -390,8 +388,9 @@ def _get_operand_hint(
 
 
 def _prepare_args(
-    decl: AnonQuantumFunctionDeclaration, arg_list: List[Any], kwargs: Dict[str, Any]
-) -> List[ArgValue]:
+    decl: AnonQuantumFunctionDeclaration, arg_list: list[Any], kwargs: dict[str, Any]
+) -> list[ArgValue]:
+    _apply_control_backward_compatibility(decl, kwargs)
     result = []
     for idx, arg_decl in enumerate(decl.positional_arg_declarations):
         arg = None
@@ -414,6 +413,24 @@ def _prepare_args(
     return result
 
 
+def _apply_control_backward_compatibility(
+    decl: AnonQuantumFunctionDeclaration, kwargs: dict[str, Any]
+) -> None:
+    from classiq.qmod.builtins.functions import __all__ as builtin_functions
+
+    if decl.name in builtin_functions and "control" in kwargs:
+        warnings.warn(
+            f"Parameter 'control' of function {decl.name!r} has been renamed to "
+            f"'ctrl'. Parameter 'control' will no longer be supported starting on "
+            f"4/11/24 at the earliest.\nHint: Change {decl.name}(control=...) to "
+            f"{decl.name}(ctrl=...).",
+            ClassiqDeprecationWarning,
+            stacklevel=6,
+        )
+        kwargs["ctrl"] = kwargs["control"]
+        kwargs.pop("control")
+
+
 def _create_quantum_function_call(
     decl_: QuantumFunctionDeclaration,
     index_: Optional[Union[CParamScalar, int]] = None,