classiq 0.88.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/evaluators/parameter_types.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, NoReturn, TypeVar, Union
 
 import sympy
 
@@ -6,14 +6,17 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
 )
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import RuntimeConstant
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
     ClassicalTuple,
     ClassicalType,
+    Integer,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
@@ -22,12 +25,14 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumOperandDeclaration,
     PositionalArg,
     QuantumOperandDeclaration,
 )
@@ -38,71 +43,62 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
-from classiq.evaluators.arg_type_match import check_type_match
 from classiq.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
-from classiq.evaluators.classical_type_inference import (
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, get_sympy_val
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
     infer_classical_type,
+    inject_classical_type_attributes,
 )
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes,
+    validate_quantum_type_attributes,
 )
+from classiq.evaluators.type_type_match import check_signature_match
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.scope import (
+    ClassicalSymbol,
     Evaluated,
     QuantumSymbol,
     QuantumVariable,
     Scope,
 )
+from classiq.model_expansions.visitors.symbolic_param_inference import (
+    set_generative_recursively,
+)
 
 
 def evaluate_parameter_types_from_args(
-    closure: FunctionClosure, signature_scope: Scope, arguments: list[Evaluated]
+    closure: FunctionClosure, arguments: list[Evaluated]
 ) -> list[PositionalArg]:
     parameters = closure.positional_arg_declarations
-    function_name = closure.name
-    check_type_match(parameters, arguments, function_name)
+    if len(parameters) != len(arguments):
+        raise ClassiqExpansionError(
+            f"Function {closure.name!r} takes {len(parameters)} arguments but "
+            f"{len(arguments)} were given"
+        )
+
+    for parameter, argument in zip_strict(parameters, arguments, strict=True):
+        if isinstance(parameter, ClassicalParameterDeclaration):
+            arg_val = argument.value
+            if not isinstance(arg_val, QmodAnnotatedExpression):
+                closure.scope[parameter.name] = argument
 
-    for parameter, argument in zip(parameters, arguments):
-        _update_scope(parameter, argument, closure)
+    evaluated_params = [
+        _evaluate_type_from_arg(parameter, argument, closure)
+        for parameter, argument in zip_strict(parameters, arguments, strict=True)
+    ]
 
     parameter_names = {parameter.name for parameter in parameters}
-    for parameter in parameters:
+    for parameter, argument in zip_strict(parameters, arguments, strict=True):
         if isinstance(parameter, QuantumOperandDeclaration):
-            parameter_value = closure.scope[parameter.name].value
             _update_operand_signature_environment(
-                parameter_value, parameter_names, closure
+                argument.value, parameter_names, closure
             )
 
-    return [
-        _evaluate_type_from_arg(
-            parameter,
-            argument,
-            Scope(parent=closure.scope | signature_scope),
-            closure.name,
-        )
-        for parameter, argument in zip(parameters, arguments)
-    ]
-
-
-def _update_scope(
-    parameter: PositionalArg, argument: Evaluated, closure: FunctionClosure
-) -> None:
-    if not isinstance(parameter, PortDeclaration):
-        closure.scope[parameter.name] = argument
-        return
-    if parameter.direction is PortDeclarationDirection.Output:
-        return
-    quantum_var = argument.as_type(QuantumVariable)
-    casted_argument = _cast(
-        parameter.quantum_type,
-        quantum_var,
-        parameter.name,
-    )
-    closure.scope[parameter.name] = Evaluated(
-        value=casted_argument, defining_function=closure
-    )
+    return evaluated_params
 
 
 NestedFunctionClosureT = Union[FunctionClosure, list["NestedFunctionClosureT"]]
@@ -130,60 +126,162 @@ def _update_operand_signature_environment(
     )
 
 
-def _cast(
-    parameter_type: QuantumType, argument: QuantumVariable, param_name: str
-) -> QuantumSymbol:
-    updated_type = inject_quantum_type_attributes(argument.quantum_type, parameter_type)
-    if updated_type is None:
-        raise ClassiqExpansionError(
-            f"Argument {str(argument)!r} of type "
-            f"{argument.quantum_type.qmod_type_name} is incompatible with parameter "
-            f"{param_name!r} of type {parameter_type.qmod_type_name}"
-        )
-    return QuantumSymbol(
-        handle=HandleBinding(name=param_name), quantum_type=updated_type
-    )
-
-
 def _evaluate_type_from_arg(
     parameter: PositionalArg,
     argument: Evaluated,
-    inner_scope: Scope,
-    function_name: str,
+    closure: FunctionClosure,
 ) -> PositionalArg:
     # FIXME: Remove suzuki_trotter overloading (CLS-2912)
-    if function_name == "suzuki_trotter" and parameter.name == "pauli_operator":
+    if closure.name == "suzuki_trotter" and parameter.name == "pauli_operator":
         return parameter
     if isinstance(parameter, ClassicalParameterDeclaration):
-        updated_classical_type = evaluate_type_in_classical_symbol(
-            parameter.classical_type.model_copy(), inner_scope, parameter.name
-        )
-        return ClassicalParameterDeclaration(
-            name=parameter.name,
-            classical_type=infer_classical_type(argument.value, updated_classical_type),
+        return _evaluate_classical_type_from_arg(parameter, argument, closure)
+    if isinstance(parameter, PortDeclaration):
+        return _evaluate_quantum_type_from_arg(parameter, argument, closure)
+    if TYPE_CHECKING:
+        assert isinstance(parameter, QuantumOperandDeclaration)
+    if parameter.is_list:
+        return _evaluate_op_list_type_from_arg(parameter, argument, closure)
+    else:
+        return _evaluate_op_type_from_arg(parameter, argument, closure)
+
+
+def _evaluate_classical_type_from_arg(
+    parameter: ClassicalParameterDeclaration,
+    argument: Evaluated,
+    closure: FunctionClosure,
+) -> ClassicalParameterDeclaration:
+    unified_scope = closure.scope | closure.signature_scope
+    updated_classical_type = evaluate_type_in_classical_symbol(
+        parameter.classical_type.model_copy(), unified_scope, parameter.name
+    )
+    arg_val = argument.value
+    if isinstance(arg_val, QmodAnnotatedExpression):
+        arg_type = arg_val.get_classical_type(arg_val.root)
+    else:
+        arg_type = infer_classical_type(arg_val)
+    injected_classical_type = inject_classical_type_attributes(
+        arg_type.without_symbolic_attributes(), updated_classical_type
+    )
+    if injected_classical_type is None:
+        _raise_argument_type_error(
+            arg_val, arg_type, parameter.name, updated_classical_type
         )
+    if parameter.classical_type.is_purely_generative:
+        set_generative_recursively(injected_classical_type)
+    closure.scope[parameter.name] = Evaluated(
+        value=(
+            ClassicalSymbol(
+                handle=HandleBinding(name=parameter.name),
+                classical_type=injected_classical_type,
+            )
+            if isinstance(arg_val, QmodAnnotatedExpression)
+            else arg_val
+        ),
+        defining_function=closure,
+    )
+    return ClassicalParameterDeclaration(
+        name=parameter.name, classical_type=injected_classical_type
+    )
 
-    if not isinstance(parameter, PortDeclaration):
-        return parameter
 
+def _evaluate_quantum_type_from_arg(
+    parameter: PortDeclaration,
+    argument: Evaluated,
+    closure: FunctionClosure,
+) -> PortDeclaration:
+    unified_scope = closure.scope | closure.signature_scope
     updated_quantum_type: QuantumType = evaluate_type_in_quantum_symbol(
-        parameter.quantum_type.model_copy(), inner_scope, parameter.name
+        parameter.quantum_type.model_copy(), unified_scope, parameter.name
     )
     if parameter.direction != PortDeclarationDirection.Output:
         arg_type = argument.as_type(QuantumVariable).quantum_type
         updated_output_quantum_type = inject_quantum_type_attributes(
-            arg_type, updated_quantum_type
+            arg_type.without_symbolic_attributes(), updated_quantum_type
         )
         if updated_output_quantum_type is None:
-            raise ClassiqExpansionError(
-                f"Argument {str(argument.value)!r} of type "
-                f"{arg_type.qmod_type_name} is incompatible with parameter "
-                f"{parameter.name!r} of type {updated_quantum_type.qmod_type_name}"
+            _raise_argument_type_error(
+                argument.value, arg_type, parameter.name, updated_quantum_type
             )
         updated_quantum_type = updated_output_quantum_type
+    validate_quantum_type_attributes(updated_quantum_type)
+    closure.scope[parameter.name] = Evaluated(
+        value=QuantumSymbol(
+            handle=HandleBinding(name=parameter.name), quantum_type=updated_quantum_type
+        ),
+        defining_function=closure,
+    )
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
 
+def _evaluate_op_list_type_from_arg(
+    parameter: QuantumOperandDeclaration, argument: Evaluated, closure: FunctionClosure
+) -> QuantumOperandDeclaration:
+    arg_val = argument.value
+    if not isinstance(arg_val, list) or any(
+        not isinstance(op, FunctionClosure) for op in arg_val
+    ):
+        if isinstance(arg_val, FunctionClosure):
+            _raise_argument_type_error(
+                "<lambda>",
+                arg_val.as_operand_declaration(is_list=False),
+                parameter.name,
+                parameter,
+            )
+        raise ClassiqInternalExpansionError("Non-lambda argument to lambda parameter")
+    for idx, operand in enumerate(arg_val):
+        check_signature_match(
+            parameter.positional_arg_declarations,
+            operand.positional_arg_declarations,
+            f"operand #{idx + 1} in parameter {parameter.name!r} "
+            f"in function {closure.name!r}",
+        )
+    return parameter
+
+
+def _evaluate_op_type_from_arg(
+    parameter: QuantumOperandDeclaration, argument: Evaluated, closure: FunctionClosure
+) -> QuantumOperandDeclaration:
+    arg_val = argument.value
+    if not isinstance(arg_val, FunctionClosure):
+        if isinstance(arg_val, list):
+            if len(arg_val) == 0:
+                _raise_argument_type_error(
+                    arg_val,
+                    AnonQuantumOperandDeclaration(is_list=True),
+                    parameter.name,
+                    parameter,
+                )
+            first_lambda = arg_val[0]
+            if isinstance(first_lambda, FunctionClosure):
+                _raise_argument_type_error(
+                    arg_val,
+                    first_lambda.as_operand_declaration(is_list=True),
+                    parameter.name,
+                    parameter,
+                )
+        raise ClassiqInternalExpansionError("Non-lambda argument to lambda parameter")
+    check_signature_match(
+        parameter.positional_arg_declarations,
+        arg_val.positional_arg_declarations,
+        f"operand {parameter.name!r} in function {closure.name!r}",
+    )
+    return parameter
+
+
+def _raise_argument_type_error(
+    arg_val: Any,
+    arg_type: Union[QmodType, AnonQuantumOperandDeclaration],
+    param_name: str,
+    param_type: Union[QmodType, AnonQuantumOperandDeclaration],
+) -> NoReturn:
+    raise ClassiqExpansionError(
+        f"Argument {str(arg_val)!r} of type "
+        f"{arg_type.qmod_type_name} is incompatible with parameter "
+        f"{param_name!r} of type {param_type.qmod_type_name}"
+    )
+
+
 def evaluate_type_in_quantum_symbol(
     type_to_update: QuantumType, scope: Scope, param_name: str
 ) -> ConcreteQuantumType:
@@ -206,16 +304,15 @@ def _evaluate_qarray_in_quantum_symbol(
     )
     type_to_update.element_type = new_element_type
     if type_to_update.length is not None:
-        new_length = _eval_expr(
+        type_to_update.length = _eval_expr(
             type_to_update.length,
             scope,
             int,
+            Integer,
             type_to_update.type_name,
             "length",
             param_name,
         )
-        if new_length is not None:
-            type_to_update.length = Expression(expr=str(new_length))
     return type_to_update
 
 
@@ -224,73 +321,74 @@ def _evaluate_qnum_in_quantum_symbol(
 ) -> QuantumNumeric:
     if type_to_update.size is None:
         return type_to_update
-    new_size = _eval_expr(
+    type_to_update.size = _eval_expr(
         type_to_update.size,
         scope,
         int,
+        Integer,
         type_to_update.type_name,
         "size",
         param_name,
     )
-    if new_size is not None:
-        type_to_update.size = Expression(expr=str(new_size))
 
     if type_to_update.is_signed is not None:
-        new_is_sign = _eval_expr(
+        type_to_update.is_signed = _eval_expr(
             type_to_update.is_signed,
             scope,
             bool,
+            Bool,
             type_to_update.type_name,
             "sign",
             param_name,
         )
-        if new_is_sign is not None:
-            type_to_update.is_signed = Expression(expr=str(new_is_sign))
     else:
         type_to_update.is_signed = Expression(expr="False")
 
     if type_to_update.fraction_digits is not None:
-        new_fraction_digits = _eval_expr(
+        type_to_update.fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
             scope,
             int,
+            Integer,
             type_to_update.type_name,
             "fraction digits",
             param_name,
         )
-        if new_fraction_digits is not None:
-            type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     else:
         type_to_update.fraction_digits = Expression(expr="0")
 
     return type_to_update
 
 
-_EXPR_TYPE = TypeVar("_EXPR_TYPE")
+_EXPR_TYPE = TypeVar("_EXPR_TYPE", bound=RuntimeConstant)
 
 
 def _eval_expr(
     expression: Expression,
     scope: Scope,
     expected_type: type[_EXPR_TYPE],
+    expected_qmod_type: type,
     type_name: str,
     attr_name: str,
     param_name: str,
-) -> Optional[_EXPR_TYPE]:
-    val = evaluate_classical_expression(expression, scope).value
-    if expected_type is int and isinstance(val, float):
+) -> Expression:
+    val = evaluate_classical_expression(Expression(expr=expression.expr), scope).value
+    if isinstance(val, sympy.Basic):
+        val = get_sympy_val(val)
+    if expected_type is int and isinstance(val, float) and int(val) == val:
         val = int(val)
-    if isinstance(val, expected_type):
-        return val
-    if isinstance(val, AnyClassicalValue) or (
-        isinstance(val, sympy.Basic) and len(val.free_symbols) > 0
+    if not isinstance(val, expected_type) and (
+        not isinstance(val, QmodAnnotatedExpression)
+        or not isinstance(val.get_type(val.root), expected_qmod_type)
     ):
-        return None
-    raise ClassiqExpansionError(
-        f"When inferring the type of parameter {param_name!r}: "
-        f"{type_name} {attr_name} must be {expected_type.__name__}, got "
-        f"{str(val)!r}"
-    )
+        raise ClassiqExpansionError(
+            f"When inferring the type of parameter {param_name!r}: "
+            f"{type_name} {attr_name} must be {expected_qmod_type.__name__}, got "
+            f"{str(val)!r}"
+        )
+    expr = Expression(expr=str(val))
+    expr._evaluated_expr = EvaluatedExpression(value=val)
+    return expr
 
 
 def _evaluate_qstruct_in_quantum_symbol(
@@ -325,11 +423,9 @@ def evaluate_type_in_classical_symbol(
     if isinstance(type_to_update, ClassicalArray):
         length = type_to_update.length
         if length is not None:
-            new_length = _eval_expr(
-                length, scope, int, "classical array", "length", param_name
+            length = _eval_expr(
+                length, scope, int, Integer, "classical array", "length", param_name
             )
-            if new_length is not None:
-                length = Expression(expr=str(new_length))
         updated_type = ClassicalArray(
             element_type=evaluate_type_in_classical_symbol(
                 type_to_update.element_type, scope, param_name

classiq/evaluators/qmod_annotated_expression.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Union, cast
 
+import sympy
+
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
@@ -30,7 +32,7 @@ class QuantumSubscriptAnnotation:
 
 @dataclass(frozen=True)
 class QuantumTypeAttributeAnnotation:
-    value: QmodExprNodeId
+    value: HandleBinding
     attr: str
 
 
@@ -50,7 +52,7 @@ def qmod_val_to_str(val: Any) -> str:
         return f"[{', '.join(qmod_val_to_str(item) for item in val)}]"
     if isinstance(val, Enum):
         return Enum.__str__(val)
-    if isinstance(val, (int, float, bool, complex)):
+    if isinstance(val, (int, float, bool, complex, sympy.Basic)):
         return str(val)
     raise ClassiqInternalExpansionError(
         f"Unrecognized value {str(val)!r} of type {type(val)}"
@@ -84,8 +86,11 @@ class QmodAnnotatedExpression:
         self._concatenations: dict[QmodExprNodeId, ConcatenationAnnotation] = {}
         self._locked = False
 
+    def print_by_node(self, node: ast.AST) -> str:
+        return ast.unparse(_ExprInliner(self).visit(node))
+
     def __str__(self) -> str:
-        return ast.unparse(_ExprInliner(self).visit(self.root))
+        return self.print_by_node(self.root)
 
     def has_node(self, node_id: QmodExprNodeId) -> bool:
         return node_id in self._node_mapping
@@ -212,15 +217,13 @@ class QmodAnnotatedExpression:
     def set_quantum_type_attr(
         self,
         node: Union[ast.AST, QmodExprNodeId],
-        value: Union[ast.AST, QmodExprNodeId],
+        value: HandleBinding,
         attr: str,
     ) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
-        if isinstance(value, ast.AST):
-            value = id(value)
         self._quantum_type_attrs[node] = QuantumTypeAttributeAnnotation(
             value=value, attr=attr
         )
@@ -280,9 +283,7 @@ class QmodAnnotatedExpression:
         if qs is not None:
             self.clear_node_data(qs.value)
             self.clear_node_data(qs.index)
-        qta = self._quantum_type_attrs.pop(node, None)
-        if qta is not None:
-            self.clear_node_data(qta.value)
+        self._quantum_type_attrs.pop(node, None)
         cnct = self._concatenations.pop(node, None)
         if cnct is not None:
             for element in cnct.elements:

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -85,7 +85,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             Sequence[ClassicalFunctionDeclaration]
         ] = None,
         classical_function_callables: Optional[Mapping[str, Callable]] = None,
-        scope: Optional[dict[str, Any]] = None,
+        scope: Optional[Mapping[str, Any]] = None,
     ) -> None:
         self._expr_val = expr_val
         self._treat_qnum_as_float = treat_qnum_as_float
@@ -264,7 +264,7 @@ def evaluate_qmod_expression(
         Sequence[ClassicalFunctionDeclaration]
     ] = None,
     classical_function_callables: Optional[Mapping[str, Callable]] = None,
-    scope: Optional[dict[str, Any]] = None,
+    scope: Optional[Mapping[str, Any]] = None,
 ) -> QmodAnnotatedExpression:
     expr_ast = ast.parse(expr, mode="eval").body
     expr_value = QmodAnnotatedExpression(expr_ast)

classiq/evaluators/qmod_expression_visitors/qmod_expression_renamer.py

@@ -40,7 +40,7 @@ def replace_expression_type_attrs(
         return expr_val
     type_attrs = dict(expr_val.get_quantum_type_attributes())
     for node_id, ta in type_attrs.items():
-        var = expr_val.get_var(ta.value)
+        var = ta.value
         renamed_var = var
         renamed_attr = ta.attr
         for (source, attr), target in renaming.items():

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -5,6 +5,7 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
@@ -15,7 +16,12 @@ from classiq.interface.generator.functions.classical_type import (
     Integer,
 )
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.model.handle_binding import FieldHandleBinding
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
@@ -26,6 +32,46 @@ from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_node_evaluators.utils import QmodType
 
 
+def _get_symbolic_quantum_var(
+    expr_val: QmodAnnotatedExpression, node: ast.AST
+) -> HandleBinding:
+    if expr_val.has_quantum_var(node):
+        var = expr_val.get_var(node)
+        expr_val.remove_var(node)
+        return var
+    if isinstance(node, ast.Attribute):
+        return FieldHandleBinding(
+            base_handle=_get_symbolic_quantum_var(expr_val, node.value),
+            field=node.attr,
+        )
+    if isinstance(node, ast.Subscript):
+        base_var = _get_symbolic_quantum_var(expr_val, node.value)
+        slice_ = node.slice
+        if isinstance(slice_, ast.Slice):
+            if slice_.lower is None or slice_.upper is None or slice_.step is not None:
+                raise ClassiqInternalExpansionError("Illegal slice")
+            return SlicedHandleBinding(
+                base_handle=base_var,
+                start=Expression(expr=expr_val.print_by_node(slice_.lower)),
+                end=Expression(expr=expr_val.print_by_node(slice_.upper)),
+            )
+        else:
+            return SubscriptHandleBinding(
+                base_handle=base_var,
+                index=Expression(expr=expr_val.print_by_node(slice_)),
+            )
+    raise ClassiqInternalExpansionError("Symbolic variable construction failed")
+
+
+def _remove_quantum_var(expr_val: QmodAnnotatedExpression, node: ast.AST) -> None:
+    if expr_val.has_quantum_var(node):
+        expr_val.remove_var(node)
+    elif isinstance(node, (ast.Attribute, ast.Subscript)):
+        _remove_quantum_var(expr_val, node.value)
+    else:
+        raise ClassiqInternalExpansionError("Failed to remove quantum var")
+
+
 def _eval_type_attribute(
     expr_val: QmodAnnotatedExpression, node: ast.Attribute
 ) -> None:
@@ -37,15 +83,22 @@ def _eval_type_attribute(
         expr_val.set_type(node, Integer())
         if subject_type.has_size_in_bits:
             expr_val.set_value(node, subject_type.size_in_bits)
+            _remove_quantum_var(expr_val, subject)
         else:
-            expr_val.set_quantum_type_attr(node, subject, attr)
+            expr_val.set_quantum_type_attr(
+                node, _get_symbolic_quantum_var(expr_val, subject), attr
+            )
         return
     if isinstance(subject_type, (ClassicalArray, QuantumBitvector)) and attr == "len":
         expr_val.set_type(node, Integer())
         if subject_type.has_constant_length:
             expr_val.set_value(node, subject_type.length_value)
+            if isinstance(subject_type, QuantumBitvector):
+                _remove_quantum_var(expr_val, subject)
         elif isinstance(subject_type, QuantumType):
-            expr_val.set_quantum_type_attr(node, subject, attr)
+            expr_val.set_quantum_type_attr(
+                node, _get_symbolic_quantum_var(expr_val, subject), attr
+            )
         return
     if isinstance(subject_type, ClassicalTuple) and attr == "len":
         expr_val.set_type(node, Integer())
@@ -56,19 +109,27 @@ def _eval_type_attribute(
             expr_val.set_type(node, Bool())
             if subject_type.has_sign:
                 expr_val.set_value(node, subject_type.sign_value)
+                _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:
                 expr_val.set_value(node, False)
+                _remove_quantum_var(expr_val, subject)
             else:
-                expr_val.set_quantum_type_attr(node, subject, attr)
+                expr_val.set_quantum_type_attr(
+                    node, _get_symbolic_quantum_var(expr_val, subject), attr
+                )
             return
         if attr == "fraction_digits":
             expr_val.set_type(node, Integer())
             if subject_type.has_fraction_digits:
                 expr_val.set_value(node, subject_type.fraction_digits_value)
+                _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:
                 expr_val.set_value(node, 0)
+                _remove_quantum_var(expr_val, subject)
             else:
-                expr_val.set_quantum_type_attr(node, subject, attr)
+                expr_val.set_quantum_type_attr(
+                    node, _get_symbolic_quantum_var(expr_val, subject), attr
+                )
             return
     raise ClassiqExpansionError(
         f"{subject_type.raw_qmod_type_name} has no attribute {attr!r}"