classiq 0.60.1__py3-none-any.whl → 0.62.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,16 +1,12 @@
 import inspect
 import sys
-import warnings
 from collections.abc import Mapping
 from types import FrameType
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Final,
-    Optional,
     Union,
-    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -44,7 +40,8 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
+from classiq.qmod.generative import is_generative_mode
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -89,9 +86,10 @@ def if_(
         else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
         source_ref=source_ref,
     )
-    if_stmt.set_generative_block("then", then)
-    if callable(else_):
-        if_stmt.set_generative_block("else", else_)
+    if is_generative_mode():
+        if_stmt.set_generative_block("then", then)
+        if callable(else_):
+            if_stmt.set_generative_block("else", else_)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 
@@ -109,9 +107,10 @@ def control(
         else_block=_operand_to_body(else_block, "else_block") if else_block else None,
         source_ref=source_ref,
     )
-    control_stmt.set_generative_block("body", stmt_block)
-    if else_block is not None:
-        control_stmt.set_generative_block("else_block", else_block)
+    if is_generative_mode():
+        control_stmt.set_generative_block("body", stmt_block)
+        if else_block is not None:
+            control_stmt.set_generative_block("else_block", else_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
@@ -161,22 +160,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
-@overload
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
-    pass
-
-
-@overload
-def inplace_add(*, value: QNum, target: QNum) -> None:
-    pass
-
-
-def inplace_add(
-    expression: Optional[SymbolicExpr] = None,
-    target_var: Optional[QScalar] = None,
-    value: Optional[QNum] = None,
-    target: Optional[QNum] = None,
-) -> None:
     """
     Add an arithmetic expression to a quantum variable.
 
@@ -187,23 +171,6 @@ def inplace_add(
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    if value is not None or target is not None:
-        warnings.warn(
-            "Parameters 'value' and 'target of function 'inplace_add' have "
-            "been renamed to 'expression' and 'target_var' respectively. Parameters "
-            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
-            "the earliest.\nHint: Change `inplace_add(value=..., target=...)` to "
-            "`inplace_add(expression=..., target_var=...)` or `inplace_add(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if value is not None:
-        expression = value
-    if target is not None:
-        target_var = target
-    if TYPE_CHECKING:
-        assert expression is not None
-        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
@@ -215,22 +182,7 @@ def inplace_add(
     )
 
 
-@overload
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
-    pass
-
-
-@overload
-def inplace_xor(*, value: QNum, target: QNum) -> None:
-    pass
-
-
-def inplace_xor(
-    expression: Optional[SymbolicExpr] = None,
-    target_var: Optional[QScalar] = None,
-    value: Optional[QNum] = None,
-    target: Optional[QNum] = None,
-) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
 
@@ -241,23 +193,6 @@ def inplace_xor(
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    if value is not None or target is not None:
-        warnings.warn(
-            "Parameters 'value' and 'target of function 'inplace_xor' have "
-            "been renamed to 'expression' and 'target_var' respectively. Parameters "
-            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
-            "the earliest.\nHint: Change `inplace_xor(value=..., target=...)` to "
-            "`inplace_xor(expression=..., target_var=...)` or `inplace_xor(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if value is not None:
-        expression = value
-    if target is not None:
-        target_var = target
-    if TYPE_CHECKING:
-        assert expression is not None
-        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
@@ -282,8 +217,9 @@ def within_apply(
         action=_operand_to_body(apply, "apply"),
         source_ref=source_ref,
     )
-    within_apply_stmt.set_generative_block("within", within)
-    within_apply_stmt.set_generative_block("apply", apply)
+    if is_generative_mode():
+        within_apply_stmt.set_generative_block("within", within)
+        within_apply_stmt.set_generative_block("apply", apply)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(within_apply_stmt)
 
 
@@ -313,7 +249,8 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
         body=iteration_operand.body,
         source_ref=source_ref,
     )
-    repeat_stmt.set_generative_block("body", iteration)
+    if is_generative_mode():
+        repeat_stmt.set_generative_block("body", iteration)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(repeat_stmt)
 
 
@@ -329,7 +266,8 @@ def power(
         body=_operand_to_body(stmt_block, "stmt_block"),
         source_ref=source_ref,
     )
-    power_stmt.set_generative_block("body", stmt_block)
+    if is_generative_mode():
+        power_stmt.set_generative_block("body", stmt_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(power_stmt)
 
 
@@ -340,7 +278,8 @@ def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
     invert_stmt = Invert(
         body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
     )
-    invert_stmt.set_generative_block("body", stmt_block)
+    if is_generative_mode():
+        invert_stmt.set_generative_block("body", stmt_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 
@@ -434,14 +373,14 @@ __all__ = [
     "assign_amplitude",
     "bind",
     "control",
-    "invert",
     "if_",
     "inplace_add",
     "inplace_xor",
+    "invert",
+    "phase",
     "power",
-    "within_apply",
     "repeat",
-    "phase",
+    "within_apply",
 ]
 
 

classiq/qmod/builtins/structs.py

@@ -134,18 +134,18 @@ BUILTIN_STRUCT_DECLARATIONS = {
 
 
 __all__ = [
-    "PauliTerm",
-    "MoleculeProblem",
-    "Molecule",
     "ChemistryAtom",
-    "Position",
-    "FockHamiltonianProblem",
-    "LadderTerm",
-    "LadderOp",
     "CombinatorialOptimizationSolution",
+    "FinanceFunction",
+    "FockHamiltonianProblem",
     "GaussianModel",
+    "LadderOp",
+    "LadderTerm",
     "LogNormalModel",
-    "FinanceFunction",
-    "QsvmResult",
+    "Molecule",
+    "MoleculeProblem",
+    "PauliTerm",
+    "Position",
     "QSVMFeatureMapPauli",
+    "QsvmResult",
 ]

classiq/qmod/native/pretty_printer.py

@@ -51,7 +51,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import (
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -60,7 +59,10 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -76,6 +78,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.qmod.builtins.functions import OPEN_LIBRARY_FUNCTIONS
 from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
@@ -85,11 +88,11 @@ class DSLPrettyPrinter(Visitor):
     def __init__(
         self,
         decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
-        rename_phase: bool = False,
+        emit_open_lib_functions: bool = False,
     ) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
-        self._rename_phase = rename_phase
+        self._emit_open_lib_functions = emit_open_lib_functions
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -168,10 +171,7 @@ class DSLPrettyPrinter(Visitor):
     def visit_QuantumVariableDeclaration(
         self, var_decl: QuantumVariableDeclaration
     ) -> str:
-        var_name = var_decl.name
-        if self._rename_phase and var_name == "phase":
-            var_name = "phase_var"
-        return f"{var_name}: {self.visit(var_decl.quantum_type)}"
+        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         dir_str = (
@@ -179,12 +179,7 @@ class DSLPrettyPrinter(Visitor):
             if port_decl.direction != PortDeclarationDirection.Inout
             else ""
         )
-        port_name = (
-            port_decl.name
-            if not (self._rename_phase and port_decl.name == "phase")
-            else "phase_var"
-        )
-        param_name = f"{port_name}: " if port_decl.name is not None else ""
+        param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
         return f"{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
@@ -250,6 +245,10 @@ class DSLPrettyPrinter(Visitor):
         return self.visit_AnonQuantumOperandDeclaration(op_decl)
 
     def visit_NativeFunctionDefinition(self, func_def: NativeFunctionDefinition) -> str:
+        if not self._emit_open_lib_functions and func_def.name in [
+            qfunc_.func_decl.name for qfunc_ in OPEN_LIBRARY_FUNCTIONS
+        ]:
+            return ""
         self._level += 1
         body = "".join(self.visit(qvar_decl) for qvar_decl in func_def.body)
         self._level -= 1
@@ -350,11 +349,7 @@ class DSLPrettyPrinter(Visitor):
         return f"lambda({positional_args}) {{\n{body}{self._indent}}}"
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
-        return (
-            var_ref.name
-            if not (self._rename_phase and var_ref.name == "phase")
-            else "phase_var"
-        )
+        return var_ref.name
 
     def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
@@ -391,6 +386,9 @@ class DSLPrettyPrinter(Visitor):
     def visit_list(self, node: list) -> str:
         return "[" + ", ".join(self.visit(elem) for elem in node) + "]"
 
+    def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
+        return str(op)
+
     @property
     def _indent(self) -> str:
         return "  " * self._level

classiq/qmod/pretty_print/pretty_printer.py

@@ -52,7 +52,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import (
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -61,7 +60,10 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -285,10 +287,8 @@ class PythonPrettyPrinter(Visitor):
             raise ClassiqInternalError
 
         is_unsigned = (
-            is_signed_expr.is_evaluated()
-            and not is_signed_expr.to_bool_value()
-            or is_signed_expr.expr == "UNSIGNED"
-        )
+            is_signed_expr.is_evaluated() and not is_signed_expr.to_bool_value()
+        ) or is_signed_expr.expr == "UNSIGNED"
         is_integer = (
             fraction_digits_expr.is_evaluated()
             and fraction_digits_expr.to_int_value() == 0
@@ -526,6 +526,9 @@ class PythonPrettyPrinter(Visitor):
     def visit_list(self, node: list) -> str:
         return "[" + ", ".join(self.visit(elem) for elem in node) + "]"
 
+    def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
+        return str(op)
+
     @property
     def _indent(self) -> str:
         return "    " * self._level

classiq/qmod/python_classical_type.py

@@ -1,6 +1,5 @@
 import dataclasses
 import inspect
-import sys
 from enum import EnumMeta
 from typing import (
     Optional,
@@ -16,16 +15,13 @@ from classiq.interface.generator.functions.classical_type import (
     Integer,
     Real,
 )
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.type_name import Enum, Struct
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import get_type_hint_expr
 from classiq.qmod.utilities import version_portable_get_args
 
-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>]`"

classiq/qmod/qmod_variable.py

@@ -452,11 +452,8 @@ class QArray(ArrayBase[_P], QVar):
             )
         if self._length is not None and self._length.is_evaluated():
             length = self._length.to_int_value()
-            if (
-                isinstance(slice_.start, int)
-                and slice_.start < 0
-                or isinstance(slice_.stop, int)
-                and slice_.stop > length
+            if (isinstance(slice_.start, int) and slice_.start < 0) or (
+                isinstance(slice_.stop, int) and slice_.stop > length
             ):
                 raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
 

classiq/qmod/quantum_expandable.py

@@ -18,7 +18,7 @@ import pydantic
 from sympy import Basic
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import (
     NativePythonClassicalTypes,
@@ -30,7 +30,6 @@ from classiq.interface.model.classical_parameter_declaration import (
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_call import (
     ArgValue,
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -39,7 +38,11 @@ from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumCallable,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -232,7 +235,9 @@ class QTerminalCallable(QCallable):
             raise NotImplementedError("Operand lists don't support slicing")
         if isinstance(key, CParam) and not isinstance(key, CParamScalar):
             raise ClassiqValueError("Non-classical parameter for slicing")
-        return QTerminalCallable(self._decl, index_=key)
+        if not isinstance(self._decl, AnonQuantumOperandDeclaration):
+            raise ClassiqInternalError
+        return QTerminalCallable(self._decl.element_declaration, index_=key)
 
     def __len__(self) -> int:
         raise ClassiqValueError(
@@ -267,6 +272,13 @@ class QTerminalCallable(QCallable):
             self.func_decl, self._index, source_ref_, *args, **kwargs
         )
 
+    def get_arg(self) -> QuantumCallable:
+        if self._index is None:
+            return self._decl.name
+        return OperandIdentifier(
+            name=self._decl.name, index=Expression(expr=str(self._index))
+        )
+
 
 @overload
 def prepare_arg(
@@ -324,11 +336,14 @@ def prepare_arg(
                 pos_rename_params=val.infer_rename_params(),
                 body=val.body,
             )
-            qlambda.set_py_callable(val._py_callable)
+            if is_generative_mode():
+                qlambda.set_py_callable(val._py_callable)
             return qlambda
 
         if isinstance(val, QExpandable):
             val.expand()
+        elif isinstance(val, QTerminalCallable):
+            return val.get_arg()
         return val.func_decl.name
 
 

classiq/qmod/quantum_function.py

@@ -77,12 +77,24 @@ class QFunc(BaseQFunc):
         self.compilation_metadata: Optional[CompilationMetadata] = None
 
     @property
-    def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        return self._qmodule.native_defs.get(
-            self._py_callable.__name__,
-            infer_func_decl(self._py_callable, qmodule=self._qmodule),
+    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        if type(self.func_decl) is NamedParamsQuantumFunctionDeclaration:
+            return self.func_decl
+        return NamedParamsQuantumFunctionDeclaration(
+            **{
+                k: v
+                for k, v in self.func_decl.model_dump().items()
+                if k in NamedParamsQuantumFunctionDeclaration.model_fields
+            }
         )
 
+    @property
+    def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        name = self._py_callable.__name__
+        if hasattr(self._qmodule, "native_defs") and name in self._qmodule.native_defs:
+            return self._qmodule.native_defs[name]
+        return infer_func_decl(self._py_callable, qmodule=self._qmodule)
+
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         super().__call__(*args, **kwargs)
         self.expand()
@@ -181,6 +193,10 @@ class ExternalQFunc(QTerminalCallable):
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self._decl
 
+    @property
+    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        return self.func_decl
+
     def get_implementation(self) -> NativeFunctionDefinition:
         model = QFunc(self._py_callable).create_model()
         return [
@@ -224,12 +240,9 @@ def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
         for name, annotation in annotations.items()
         if not (
             name == "return"
-            or isclass(annotation)
-            and issubclass(annotation, CParam)
-            or isclass(annotation)
-            and is_dataclass(annotation)
-            or isclass(annotation)
-            and isinstance(annotation, EnumMeta)
+            or (isclass(annotation) and issubclass(annotation, CParam))
+            or (isclass(annotation) and is_dataclass(annotation))
+            or (isclass(annotation) and isinstance(annotation, EnumMeta))
             or get_origin(annotation) is CArray
             or (get_origin(annotation) or annotation) is QCallable
             or (get_origin(annotation) or annotation) is QCallableList

classiq/qmod/semantics/static_semantics_visitor.py

@@ -1,3 +1,4 @@
+import ast
 from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from typing import (
@@ -6,7 +7,9 @@ from typing import (
 )
 
 from classiq.interface.exceptions import ClassiqSemanticError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.function_params import PortDirection
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -25,6 +28,9 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -41,7 +47,10 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.qmod.builtins.functions import (
+    BUILTIN_FUNCTION_DECLARATIONS,
+)
 from classiq.qmod.semantics.annotation import annotate_function_call_decl
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.qstruct_annotator import QStructAnnotator
@@ -52,6 +61,9 @@ from classiq.qmod.semantics.validation.func_call_validation import (
     check_no_overlapping_quantum_args,
     validate_call_arguments,
 )
+from classiq.qmod.semantics.validation.function_name_collisions_validation import (
+    _check_function_name_collisions,
+)
 from classiq.qmod.semantics.validation.handle_validation import resolve_handle
 from classiq.qmod.semantics.validation.main_validation import validate_main_function
 from classiq.qmod.semantics.validation.types_validation import (
@@ -266,6 +278,26 @@ class StaticSemanticsVisitor(Visitor):
     def visit_HandleBinding(self, handle: HandleBinding) -> None:
         resolve_handle(self.current_scope, handle)
 
+    def visit_Expression(self, expr: Expression) -> None:
+        if len(self._scope) == 0:
+            return
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = [
+            HandleMetadata(handle=handle)
+            for handle in vrc.var_handles
+            if handle.name in self.current_scope.variable_states
+            and (
+                not isinstance(handle, FieldHandleBinding)
+                or handle.field not in CLASSICAL_ATTRIBUTES
+            )
+        ]
+        self._handle_inouts(handles)
+
+    def visit_QuantumExpressionOperation(self, op: QuantumExpressionOperation) -> None:
+        self.visit_Expression(op.expression)
+        self.visit_QuantumOperation(op)
+
     def _handle_state_changing_ios(
         self,
         ios: Sequence[HandleMetadata],
@@ -314,9 +346,6 @@ class StaticSemanticsVisitor(Visitor):
         )
 
     def _handle_inouts(self, inouts: Sequence[HandleMetadata]) -> None:
-        sliced_handles = set()
-        whole_handles = set()
-
         for handle_metadata in inouts:
             handle_binding = handle_metadata.handle
 
@@ -345,18 +374,6 @@ class StaticSemanticsVisitor(Visitor):
                     f"{location}"
                 )
 
-            if isinstance(
-                handle_binding, (SlicedHandleBinding, SubscriptHandleBinding)
-            ):
-                sliced_handles.add(handle_binding.name)
-            else:
-                whole_handles.add(handle_binding.name)
-
-        for handle in sliced_handles & whole_handles:
-            self._error_manager.add_error(
-                f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
-            )
-
 
 def resolve_function_calls(
     root: Any,
@@ -374,6 +391,7 @@ def resolve_function_calls(
 def static_semantics_analysis_pass(
     model: Model, error_type: Optional[type[Exception]] = ClassiqSemanticError
 ) -> None:
+    _check_function_name_collisions(model, error_type)
     QStructAnnotator().visit(model)
     StaticSemanticsVisitor(
         {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict},

classiq/qmod/semantics/validation/func_call_validation.py

@@ -10,6 +10,7 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
     QuantumLambdaFunction,
     QuantumOperand,
 )
@@ -56,16 +57,19 @@ def _check_operand_against_declaration(
             )
         return
     operand_arg_decl: AnonQuantumFunctionDeclaration
-    if isinstance(operand_argument, str):
-        if operand_argument not in function_dict:
+    operand_argument_for_decl = operand_argument
+    if isinstance(operand_argument_for_decl, OperandIdentifier):
+        operand_argument_for_decl = operand_argument_for_decl.name
+    if isinstance(operand_argument_for_decl, str):
+        if operand_argument_for_decl not in function_dict:
             ErrorManager().add_error(
                 f"{operand_argument!r} argument to {func_name!r} is not a "
                 f"registered function."
             )
             return
-        operand_arg_decl = function_dict[operand_argument]
-    elif isinstance(operand_argument, QuantumLambdaFunction):
-        operand_arg_decl = operand_argument.func_decl
+        operand_arg_decl = function_dict[operand_argument_for_decl]
+    elif isinstance(operand_argument_for_decl, QuantumLambdaFunction):
+        operand_arg_decl = operand_argument_for_decl.func_decl
     else:
         raise ClassiqError(
             f"{str(operand_argument)!r} argument to {func_name!r} is not a "