classiq 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

classiq/interface/generator/arith/arithmetic.py

@@ -9,6 +9,9 @@ from classiq.interface.generator.arith import arithmetic_expression_parser
 from classiq.interface.generator.arith.arithmetic_expression_abc import (
     ArithmeticExpressionABC,
 )
+from classiq.interface.generator.arith.arithmetic_expression_validator import (
+    is_constant,
+)
 from classiq.interface.generator.arith.arithmetic_param_getters import (
     id2op,
     operation_allows_target,
@@ -17,7 +20,9 @@ from classiq.interface.generator.arith.arithmetic_result_builder import (
     ArithmeticResultBuilder,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
     QuantumType,
     quantum_var_to_register,
     register_info_to_quantum_type,
@@ -28,6 +33,10 @@ ARITHMETIC_EXPRESSION_RESULT_NAME: Final[str] = "expression_result"
 ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
 
 
+def is_zero(expr: str) -> bool:
+    return is_constant(expr) and float(expr) == 0
+
+
 class Arithmetic(ArithmeticExpressionABC):
     target: Optional[RegisterArithmeticInfo] = None
     inputs_to_save: set[str] = pydantic.Field(default_factory=set)
@@ -99,7 +108,13 @@ def get_arithmetic_params(
 
 def compute_arithmetic_result_type(
     expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
-) -> QuantumType:
+) -> QuantumNumeric:
+    if is_zero(expr_str):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
     arith_param = get_arithmetic_params(expr_str, var_types, machine_precision)
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -3,6 +3,7 @@ import re
 from _ast import AST
 from typing import Any, Optional, Union
 
+from sympy import Expr
 from typing_extensions import TypeAlias, get_args
 
 from classiq.interface.exceptions import ClassiqArithmeticError, ClassiqValueError
@@ -54,11 +55,11 @@ SupportedNodesTypes = Union[
 DEFAULT_SUPPORTED_NODE_TYPES = get_args(SupportedNodesTypes)
 
 
-def _is_constant(expr: str) -> bool:
+def is_constant(expr: Union[str, Expr]) -> bool:
     try:
         float(expr)
         return True
-    except ValueError:
+    except (ValueError, TypeError):
         return False
 
 
@@ -94,7 +95,7 @@ class ExpressionValidator(ast.NodeVisitor):
     @staticmethod
     def _get_adjusted_expression(expression: str) -> str:
         # This works around the simplification of the trivial expressions such as a + 0, 1 * a, etc.
-        if IDENITIFIER_REGEX.fullmatch(expression) or _is_constant(expression):
+        if IDENITIFIER_REGEX.fullmatch(expression) or is_constant(expression):
             return f"0 + {expression}"
         return expression
 

classiq/interface/generator/expressions/expression_constants.py

@@ -20,3 +20,6 @@ BOOLEAN_LITERALS = {"True", "False"}
 FORBIDDEN_LITERALS: set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
 CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
 RESERVED_EXPRESSIONS: frozenset[str] = frozenset({"i"})
+CPARAM_EXECUTION_SUFFIX_PATTERN = (
+    rf"({CPARAM_EXECUTION_SUFFIX}|^({'|'.join(RESERVED_EXPRESSIONS)}))(_\d+)*$"
+)

classiq/interface/generator/generated_circuit_data.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Literal, Optional, Union
+from typing import Literal, Optional, Union
 
 import pydantic
 from pydantic import ConfigDict
@@ -12,6 +12,12 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
     ExecutionData,
 )
 
+from classiq.model_expansions.capturing.mangling_utils import (
+    demangle_capture_name,
+    demangle_name,
+    is_captured_var_name,
+)
+
 _logger = logging.getLogger(__name__)
 ParameterName = str
 IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
@@ -52,6 +58,16 @@ class GeneratedRegister(pydantic.BaseModel):
     def width(self) -> int:
         return len(self)
 
+    @property
+    def is_captured(self) -> bool:
+        return is_captured_var_name(self.name)
+
+    @staticmethod
+    def demangle_name(name: str) -> str:
+        if is_captured_var_name(name):
+            return demangle_capture_name(name)
+        return demangle_name(name)
+
 
 class GeneratedFunction(pydantic.BaseModel):
     name: str
@@ -157,32 +173,54 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             for key, value in parameters.items()
         ]
 
-    def update(self, **kwargs: Any) -> None:
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-
-    def propagate_absolute_qubits(self) -> None:
+    def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":
         if self.absolute_qubits is None:
-            return
-
-        for register in self.registers:
-            register.qubit_indexes_absolute = list(
-                _get_absolute_from_relative(
-                    self.absolute_qubits, tuple(register.qubit_indexes_relative)
+            return self
+
+        updated_registers = [
+            register.model_copy(
+                update=dict(
+                    qubit_indexes_absolute=list(
+                        _get_absolute_from_relative(
+                            self.absolute_qubits, tuple(register.qubit_indexes_relative)
+                        )
+                    )
                 )
             )
+            for register in self.registers
+        ]
+        updated_generated_function = (
+            self.generated_function.model_copy(update=dict(registers=updated_registers))
+            if self.generated_function
+            else None
+        )
 
+        updated_children: list[FunctionDebugInfoInterface] = []
         for child in self.children:
-            child.absolute_qubits = _get_absolute_from_relative(
-                self.absolute_qubits, child.relative_qubits
+            updated_child = child.model_copy(
+                update=dict(
+                    absolute_qubits=_get_absolute_from_relative(
+                        self.absolute_qubits, child.relative_qubits
+                    )
+                )
             )
-            child.propagate_absolute_qubits()
+            updated_children.append(updated_child.propagate_absolute_qubits())
 
-    def inverse(self) -> None:
-        self.is_inverse = not self.is_inverse
-        for child in self.children:
-            child.inverse()
-        self.children = self.children[::-1]
+        return self.model_copy(
+            update=dict(
+                generated_function=updated_generated_function,
+                children=updated_children,
+            )
+        )
+
+    def inverse(self) -> "FunctionDebugInfoInterface":
+        inverted_children = [child.inverse() for child in self.children[::-1]]
+        return self.model_copy(
+            update=dict(
+                is_inverse=not self.is_inverse,
+                children=inverted_children,
+            )
+        )
 
 
 def _get_absolute_from_relative(

classiq/interface/generator/model/__init__.py

@@ -10,8 +10,8 @@ from classiq.interface.generator.model.preferences import (
 
 __all__: list[str] = [
     "Constraints",
-    "Preferences",
     "CustomHardwareSettings",
     "OptimizationParameter",
+    "Preferences",
     "TranspilerBasisGates",
 ]

classiq/interface/generator/model/quantum_register.py

@@ -250,11 +250,11 @@ def get_type_and_size_dict(
 
 
 __all__ = [
+    "AuxQReg",
     "QReg",
-    "QSInt",
-    "QUInt",
     "QSFixed",
+    "QSInt",
     "QUFixed",
+    "QUInt",
     "ZeroQReg",
-    "AuxQReg",
 ]

classiq/interface/generator/standard_gates/controlled_standard_gates.py

@@ -26,26 +26,6 @@ class ControlledGate(_StandardGate):  # type: ignore[misc]
     num_ctrl_qubits: pydantic.PositiveInt = pydantic.Field(
         default=DEFAULT_NUM_CTRL_QUBITS
     )
-
-    def _create_ios(self) -> None:
-        _StandardGate._create_ios(self)
-        control = RegisterUserInput(
-            name=CONTROLLED_GATE_CONTROL, size=self.num_ctrl_qubits
-        )
-        self._inputs[CONTROLLED_GATE_CONTROL] = control
-        self._outputs[CONTROLLED_GATE_CONTROL] = control
-
-    def to_control_state(self) -> ControlState:
-        return ControlState(
-            name=CONTROLLED_GATE_CONTROL, num_ctrl_qubits=self.num_ctrl_qubits
-        )
-
-
-class ControlledGateWithState(ControlledGate):  # type: ignore[misc]
-    """
-    Base model for controlled Gates with control over the controlled_state
-    """
-
     ctrl_state: CtrlState = pydantic.Field(
         description="The control state in decimal or as a bit string (e.g. '1011'). If not specified, the control "
         "state is 2**num_ctrl_qubits - 1.\n"
@@ -82,12 +62,20 @@ class ControlledGateWithState(ControlledGate):  # type: ignore[misc]
         )
         return ControlState(name=CONTROLLED_GATE_CONTROL, ctrl_state=ctrl_state_str)
 
+    def _create_ios(self) -> None:
+        _StandardGate._create_ios(self)
+        control = RegisterUserInput(
+            name=CONTROLLED_GATE_CONTROL, size=self.num_ctrl_qubits
+        )
+        self._inputs[CONTROLLED_GATE_CONTROL] = control
+        self._outputs[CONTROLLED_GATE_CONTROL] = control
+
 
 def _num_to_control_string(ctrl_state_int: int, num_ctrl_qubits: int) -> str:
     return format(ctrl_state_int, f"0{num_ctrl_qubits}b")
 
 
-class CXGate(ControlledGateWithState):  # type: ignore[misc]
+class CXGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-X Gate
     """
@@ -98,7 +86,7 @@ class CXGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CCXGate(ControlledGateWithState):  # type: ignore[misc]
+class CCXGate(ControlledGate):  # type: ignore[misc]
     """
     The Double Controlled-X Gate
     """
@@ -109,7 +97,7 @@ class CCXGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class C3XGate(ControlledGateWithState):  # type: ignore[misc]
+class C3XGate(ControlledGate):  # type: ignore[misc]
     """
     The X Gate controlled on 3 qubits
     """
@@ -121,7 +109,7 @@ class C3XGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class C4XGate(ControlledGateWithState):  # type: ignore[misc]
+class C4XGate(ControlledGate):  # type: ignore[misc]
     """
     The X Gate controlled on 4 qubits
     """
@@ -133,7 +121,7 @@ class C4XGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CYGate(ControlledGateWithState):  # type: ignore[misc]
+class CYGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-Y Gate
     """
@@ -142,7 +130,7 @@ class CYGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CZGate(ControlledGateWithState):  # type: ignore[misc]
+class CZGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-Z Gate
     """
@@ -151,7 +139,7 @@ class CZGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CHGate(ControlledGateWithState):  # type: ignore[misc]
+class CHGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-H Gate
     """
@@ -160,7 +148,7 @@ class CHGate(ControlledGateWithState):  # type: ignore[misc]
         return 2
 
 
-class CSXGate(ControlledGateWithState):  # type: ignore[misc]
+class CSXGate(ControlledGate):  # type: ignore[misc]
     """
     The Controlled-SX Gate
     """
@@ -169,25 +157,25 @@ class CSXGate(ControlledGateWithState):  # type: ignore[misc]
         return 4
 
 
-class CRXGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CRXGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-RX Gate
     """
 
 
-class CRYGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CRYGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-RY Gate
     """
 
 
-class CRZGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CRZGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-RZ Gate
     """
 
 
-class CPhaseGate(ControlledGateWithState, angles=["theta"]):  # type: ignore[misc]
+class CPhaseGate(ControlledGate, angles=["theta"]):  # type: ignore[misc]
     """
     The Controlled-Phase Gate
     """

classiq/interface/ide/visual_model.py

@@ -42,6 +42,7 @@ class OperationLink(pydantic.BaseModel):
     inner_label: Optional[str] = None
     qubits: tuple[int, ...]
     type: str
+    is_captured: bool = False
 
     model_config = ConfigDict(frozen=True)
 

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "5"
+INTERFACE_VERSION = "6"

classiq/interface/model/model.py

@@ -180,9 +180,8 @@ class Model(VersionedModel, ASTNode):
             )
         return constants
 
-    def json_no_preferences_and_constraints(self) -> str:
-        return self.model_dump_json(
-            indent=2,
+    def dump_no_preferences_and_constraints(self) -> dict[str, Any]:
+        return self.model_dump(
             exclude={
                 "constraints",
                 "execution_preferences",

classiq/interface/model/quantum_function_call.py

@@ -7,7 +7,6 @@ from typing import (
 
 import pydantic
 
-from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
@@ -21,7 +20,10 @@ from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumOperand
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumOperand,
+)
 from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
 ArgValue = Union[
@@ -31,11 +33,6 @@ ArgValue = Union[
 ]
 
 
-class OperandIdentifier(ASTNode):
-    name: str
-    index: Expression
-
-
 class QuantumFunctionCall(QuantumOperation):
     kind: Literal["QuantumFunctionCall"]
 

classiq/interface/model/quantum_function_declaration.py

@@ -9,6 +9,7 @@ from typing import (
 import pydantic
 from pydantic import SerializeAsAny
 from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
@@ -171,6 +172,12 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
         new_instance_data["kind"] = "QuantumOperandDeclaration"
         return QuantumOperandDeclaration(**new_instance_data)
 
+    @property
+    def element_declaration(self) -> Self:
+        if not self.is_list:
+            raise ClassiqInternalError
+        return self.model_copy(update={"is_list": False})
+
 
 AnonQuantumFunctionDeclaration.model_rebuild()
 

classiq/interface/model/quantum_lambda_function.py

@@ -4,6 +4,7 @@ import pydantic
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
 )
@@ -52,5 +53,13 @@ class QuantumLambdaFunction(ASTNode):
         self._func_decl = fd
 
 
-QuantumCallable = Union[str, QuantumLambdaFunction]
+class OperandIdentifier(ASTNode):
+    name: str
+    index: Expression
+
+    def __str__(self) -> str:
+        return f"{self.name}[{self.index.expr}]"
+
+
+QuantumCallable = Union[str, OperandIdentifier, QuantumLambdaFunction]
 QuantumOperand = Union[QuantumCallable, list[QuantumCallable]]

classiq/interface/model/quantum_type.py

@@ -159,7 +159,9 @@ class QuantumNumeric(QuantumScalar):
     def _validate_fields(self) -> Self:
         has_sign = self.is_signed is not None
         has_fraction_digits = self.fraction_digits is not None
-        if has_sign and not has_fraction_digits or not has_sign and has_fraction_digits:
+        if (has_sign and not has_fraction_digits) or (
+            not has_sign and has_fraction_digits
+        ):
             raise ClassiqValueError(
                 "Assign neither or both of is_signed and fraction_digits"
             )

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -61,7 +61,7 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
                 for field_name, field_type in val.struct_declaration.variables.items()
             }
 
-        if isinstance(val, Enum):
+        if isinstance(val, (Enum, int)):
             return val
 
     elif isinstance(qmod_type, ClassicalList):
@@ -147,6 +147,8 @@ def get_field(
     proxy: Union[QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list],
     field: str,
 ) -> ExpressionValue:
+    if isinstance(proxy, type) and issubclass(proxy, Enum):
+        return getattr(proxy, field)
     if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
         raise ClassiqExpansionError(
             f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "

classiq/model_expansions/capturing/captured_vars.py

@@ -2,7 +2,7 @@ import dataclasses
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import (
@@ -16,12 +16,14 @@ from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBi
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
 from classiq.interface.model.quantum_type import QuantumType
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
 
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_handle,
     mangle_captured_var_name,
 )
-from classiq.model_expansions.scope import QuantumSymbol
 from classiq.model_expansions.transformers.var_splitter import SymbolPart, SymbolParts
 
 if TYPE_CHECKING:
@@ -71,7 +73,11 @@ class _CapturedHandle:
 
     @property
     def mangled_name(self) -> str:
-        return mangle_captured_var_name(self.handle.identifier, self.defining_function)
+        return mangle_captured_var_name(
+            self.handle.identifier,
+            self.defining_function.name,
+            self.defining_function.depth,
+        )
 
     @property
     def port(self) -> PortDeclaration:
@@ -211,7 +217,16 @@ class CapturedVars:
             ]
         )
 
-    def filter(self, current_function: "FunctionClosure") -> "CapturedVars":
+    def filter_vars(
+        self,
+        current_function: "FunctionClosure",
+        current_declarations: Optional[list[VariableDeclarationStatement]] = None,
+    ) -> "CapturedVars":
+        current_declared_vars = (
+            None
+            if current_declarations is None
+            else {decl.name for decl in current_declarations}
+        )
         return CapturedVars(
             _captured_handles=[
                 captured_handle
@@ -219,6 +234,10 @@ class CapturedVars:
                 if not _same_closure(
                     captured_handle.defining_function, current_function
                 )
+                or (
+                    current_declared_vars is not None
+                    and captured_handle.handle.name not in current_declared_vars
+                )
             ]
         )
 
@@ -247,10 +266,7 @@ class CapturedVars:
 
     def get_captured_mapping(self) -> SymbolParts:
         return {
-            QuantumSymbol(
-                handle=captured_handle.handle,
-                quantum_type=captured_handle.quantum_type,
-            ): [
+            captured_handle.handle: [
                 SymbolPart(
                     source_handle=captured_handle.handle,
                     target_var_name=captured_handle.mangled_name,

classiq/model_expansions/capturing/mangling_utils.py

@@ -1,12 +1,9 @@
 import re
-from typing import TYPE_CHECKING
+from typing import Optional
 
 from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
 from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
 
-if TYPE_CHECKING:
-    from classiq.model_expansions.closure import FunctionClosure
-
 IDENTIFIER_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_]*"
 CAPTURE_PATTERN = re.compile(
     rf"({IDENTIFIER_PATTERN}){CAPTURE_SUFFIX}{IDENTIFIER_PATTERN}__\d*"
@@ -15,24 +12,34 @@ ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 
 
 def mangle_captured_var_name(
-    var_name: str, defining_function: "FunctionClosure"
+    var_name: str, function_name: str, function_depth: int
 ) -> str:
-    return (
-        f"{var_name}{CAPTURE_SUFFIX}{defining_function.name}__{defining_function.depth}"
-    )
+    return f"{var_name}{CAPTURE_SUFFIX}{function_name}__{function_depth}"
 
 
-def demangle_name(name: str) -> str:
-    match = re.match(CAPTURE_PATTERN, name)
+def _match_capture_pattern(name: str) -> Optional[re.Match[str]]:
+    return re.match(CAPTURE_PATTERN, name)
+
+
+def is_captured_var_name(name: str) -> bool:
+    return _match_capture_pattern(name) is not None
+
+
+def demangle_capture_name(name: str) -> str:
+    match = _match_capture_pattern(name)
     return match.group(1) if match else name
 
 
 def demangle_handle(handle: HandleBinding) -> HandleBinding:
-    name = handle.name
+    demangled_name = demangle_name(handle.name)
+    return handle.rename(demangled_name)
+
+
+def demangle_name(name: str) -> str:
     if HANDLE_ID_SEPARATOR not in name:
-        return handle
+        return name
     if ARRAY_CAST_SUFFIX in name:
-        return HandleBinding(name=name.split(ARRAY_CAST_SUFFIX)[0])
+        return name.split(ARRAY_CAST_SUFFIX)[0]
     name = re.sub(r"([^_])_\d+$", r"\1", name)
     name_parts = name.split(HANDLE_ID_SEPARATOR)
     new_name_parts = [name_parts[0]]
@@ -44,5 +51,6 @@ def demangle_handle(handle: HandleBinding) -> HandleBinding:
             new_name_parts.append(f"[{part_left}:{part_right}]")
         else:
             new_name_parts.append(f".{part}")
-    new_name_parts = list(map(demangle_name, new_name_parts))
-    return handle.rename("".join(new_name_parts))
+    new_name_parts = list(map(demangle_capture_name, new_name_parts))
+    new_name = "".join(new_name_parts)
+    return new_name

classiq/model_expansions/evaluators/arg_type_match.py

@@ -135,13 +135,13 @@ def _check_classical_type_match(
     arg_struct_name = None if not arg_is_struct else argument.struct_declaration.name
     if (
         arg_is_qvar
-        or arg_is_builtin
-        and (type_is_struct or type_is_enum)
-        or arg_is_struct
-        and (not type_is_struct or arg_struct_name != type_name)
-        or arg_is_enum
-        and get_qmod_type(classical_type) != CInt
-        and (not type_is_enum or type(argument).__name__ != type_name)
+        or (arg_is_builtin and (type_is_struct or type_is_enum))
+        or (arg_is_struct and (not type_is_struct or arg_struct_name != type_name))
+        or (
+            arg_is_enum
+            and get_qmod_type(classical_type) != CInt
+            and (not type_is_enum or type(argument).__name__ != type_name)
+        )
     ):
         raise ClassiqExpansionError(error_message)