classiq 0.70.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

classiq/model_expansions/capturing/captured_vars.py

@@ -3,15 +3,21 @@ from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from typing_extensions import Self
+
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     NestedHandleBinding,
@@ -19,6 +25,7 @@ from classiq.interface.model.handle_binding import (
 )
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -28,7 +35,11 @@ from classiq.model_expansions.capturing.mangling_utils import (
     demangle_handle,
     mangle_captured_var_name,
 )
-from classiq.model_expansions.transformers.var_splitter import SymbolPart, SymbolParts
+from classiq.model_expansions.transformers.model_renamer import (
+    HandleRenaming,
+    SymbolRenaming,
+)
+from classiq.model_expansions.transformers.var_splitter import SymbolPart
 
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
@@ -72,12 +83,29 @@ class PortDirection(StrEnum):
 
 
 @dataclass(frozen=True)
-class _CapturedHandle:
+class _Captured:
+    defining_function: "FunctionClosure"
+    is_propagated: bool
+
+    def change_defining_function(
+        self, new_defining_function: "FunctionClosure"
+    ) -> Self:
+        return dataclasses.replace(self, defining_function=new_defining_function)
+
+    def set_propagated(self) -> Self:
+        return dataclasses.replace(self, is_propagated=True)
+
+    def update_propagation(self, other_captured_handle: Self) -> Self:
+        if self.is_propagated and not other_captured_handle.is_propagated:
+            return dataclasses.replace(self, is_propagated=False)
+        return self
+
+
+@dataclass(frozen=True)
+class _CapturedHandle(_Captured):
     handle: HandleBinding
     quantum_type: QuantumType
-    defining_function: "FunctionClosure"
     direction: PortDirection
-    is_propagated: bool
 
     @property
     def mangled_name(self) -> str:
@@ -103,27 +131,33 @@ class _CapturedHandle:
     def change_direction(self, new_direction: PortDirection) -> "_CapturedHandle":
         return dataclasses.replace(self, direction=new_direction)
 
-    def change_defining_function(
-        self, new_defining_function: "FunctionClosure"
-    ) -> "_CapturedHandle":
-        return dataclasses.replace(self, defining_function=new_defining_function)
-
-    def set_propagated(self) -> "_CapturedHandle":
-        return dataclasses.replace(self, is_propagated=True)
-
-    def update_propagation(
-        self, other_captured_handle: "_CapturedHandle"
-    ) -> "_CapturedHandle":
-        if self.is_propagated and not other_captured_handle.is_propagated:
-            return dataclasses.replace(self, is_propagated=False)
-        return self
-
     def set_symbol(
         self, handle: HandleBinding, quantum_type: QuantumType
     ) -> "_CapturedHandle":
         return dataclasses.replace(self, handle=handle, quantum_type=quantum_type)
 
 
+@dataclass(frozen=True)
+class _CapturedClassicalVar(_Captured):
+    name: str
+    classical_type: ClassicalType
+    defining_function: "FunctionClosure"
+
+    @property
+    def mangled_name(self) -> str:
+        return mangle_captured_var_name(
+            self.name,
+            self.defining_function.name,
+            self.defining_function.depth,
+        )
+
+    @property
+    def parameter_declaration(self) -> ClassicalParameterDeclaration:
+        return ClassicalParameterDeclaration(
+            name=self.mangled_name, classical_type=self.classical_type
+        )
+
+
 HandleState = tuple[str, "FunctionClosure", bool]
 
 
@@ -131,6 +165,7 @@ HandleState = tuple[str, "FunctionClosure", bool]
 class CapturedVars:
     _captured_handles: list[_CapturedHandle] = field(default_factory=list)
     _handle_states: list[HandleState] = field(default_factory=list)
+    _captured_classical_vars: list[_CapturedClassicalVar] = field(default_factory=list)
 
     def capture_handle(
         self,
@@ -332,16 +367,48 @@ class CapturedVars:
         )
         return merged_handle, merged_quantum_type
 
+    def capture_classical_var(
+        self,
+        var_name: str,
+        var_type: ClassicalType,
+        defining_function: "FunctionClosure",
+    ) -> None:
+        self._capture_classical_var(
+            _CapturedClassicalVar(
+                name=var_name,
+                classical_type=var_type,
+                defining_function=defining_function,
+                is_propagated=False,
+            )
+        )
+
+    def _capture_classical_var(
+        self, captured_classical_var: _CapturedClassicalVar
+    ) -> None:
+        for existing_captured_classical_var in self._captured_classical_vars:
+            if (
+                existing_captured_classical_var.name == captured_classical_var.name
+                and _same_closure(
+                    existing_captured_classical_var.defining_function,
+                    captured_classical_var.defining_function,
+                )
+            ):
+                return
+        self._captured_classical_vars.append(captured_classical_var)
+
     def update(self, other_captured_vars: "CapturedVars") -> None:
         for captured_handle in other_captured_vars._captured_handles:
             self._capture_handle(captured_handle)
+        for captured_classical_var in other_captured_vars._captured_classical_vars:
+            self._capture_classical_var(captured_classical_var)
 
     def negate(self) -> "CapturedVars":
         return CapturedVars(
             _captured_handles=[
                 captured_handle.change_direction(captured_handle.direction.negate())
                 for captured_handle in self._captured_handles
-            ]
+            ],
+            _captured_classical_vars=self._captured_classical_vars,
         )
 
     def filter_vars(self, current_function: "FunctionClosure") -> "CapturedVars":
@@ -352,7 +419,14 @@ class CapturedVars:
                 if not _same_closure(
                     captured_handle.defining_function, current_function
                 )
-            ]
+            ],
+            _captured_classical_vars=[
+                captured_classical_var
+                for captured_classical_var in self._captured_classical_vars
+                if not _same_closure(
+                    captured_classical_var.defining_function, current_function
+                )
+            ],
         )
 
     def filter_var_decls(
@@ -367,7 +441,8 @@ class CapturedVars:
                     current_declared_vars is not None
                     and captured_handle.handle.name not in current_declared_vars
                 )
-            ]
+            ],
+            _captured_classical_vars=self._captured_classical_vars,
         )
 
     def set_propagated(self) -> "CapturedVars":
@@ -375,16 +450,37 @@ class CapturedVars:
             _captured_handles=[
                 captured_handle.set_propagated()
                 for captured_handle in self._captured_handles
-            ]
+            ],
+            _captured_classical_vars=[
+                captured_classical_var.set_propagated()
+                for captured_classical_var in self._captured_classical_vars
+            ],
         )
 
-    def get_captured_ports(self) -> list[PortDeclaration]:
-        return [captured_handle.port for captured_handle in self._captured_handles]
-
-    def get_captured_args(
-        self, current_function: "FunctionClosure"
-    ) -> list[HandleBinding]:
-        return [
+    def get_captured_parameters(self) -> list[PositionalArg]:
+        decls: list[PositionalArg]
+        decls = [
+            captured_classical_var.parameter_declaration
+            for captured_classical_var in self._captured_classical_vars
+        ]
+        decls += [captured_handle.port for captured_handle in self._captured_handles]
+        return decls
+
+    def get_captured_args(self, current_function: "FunctionClosure") -> list[ArgValue]:
+        args: list[ArgValue]
+        args = [
+            Expression(
+                expr=(
+                    captured_classical_var.name
+                    if _same_closure(
+                        current_function, captured_classical_var.defining_function
+                    )
+                    else captured_classical_var.mangled_name
+                )
+            )
+            for captured_classical_var in self._captured_classical_vars
+        ]
+        args += [
             (
                 captured_handle.handle
                 if _same_closure(current_function, captured_handle.defining_function)
@@ -392,9 +488,11 @@ class CapturedVars:
             )
             for captured_handle in self._captured_handles
         ]
+        return args
 
-    def get_captured_mapping(self) -> SymbolParts:
-        return {
+    def get_captured_mapping(self) -> SymbolRenaming:
+        mapping: SymbolRenaming
+        mapping = {
             captured_handle.handle: [
                 SymbolPart(
                     source_handle=captured_handle.handle,
@@ -405,6 +503,17 @@ class CapturedVars:
             for captured_handle in self._captured_handles
             if not captured_handle.is_propagated
         }
+        mapping |= {
+            (handle := HandleBinding(name=captured_classical_var.name)): [
+                HandleRenaming(
+                    source_handle=handle,
+                    target_var_name=captured_classical_var.mangled_name,
+                )
+            ]
+            for captured_classical_var in self._captured_classical_vars
+            if not captured_classical_var.is_propagated
+        }
+        return mapping
 
     def init_var(self, var_name: str, defining_function: "FunctionClosure") -> None:
         self._handle_states.append((var_name, defining_function, False))
@@ -470,6 +579,7 @@ class CapturedVars:
         return CapturedVars(
             _captured_handles=list(self._captured_handles),
             _handle_states=list(self._handle_states),
+            _captured_classical_vars=list(self._captured_classical_vars),
         )
 
     def set(
@@ -492,6 +602,14 @@ class CapturedVars:
                 self._handle_states.append((var, target_func, state))
             else:
                 self._handle_states.append((var, defining_function, state))
+        self._captured_classical_vars = []
+        for captured_classical_var in other._captured_classical_vars:
+            if _same_closure(captured_classical_var.defining_function, source_func):
+                self._captured_classical_vars.append(
+                    captured_classical_var.change_defining_function(target_func)
+                )
+            else:
+                self._captured_classical_vars.append(captured_classical_var)
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
@@ -499,11 +617,15 @@ def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") ->
 
 
 def validate_args_are_not_propagated(
-    args: Sequence[ArgValue], captured_vars: Sequence[HandleBinding]
+    args: Sequence[ArgValue], captured_vars: Sequence[ArgValue]
 ) -> None:
     if not captured_vars:
         return
-    captured_handles = {demangle_handle(handle) for handle in captured_vars}
+    captured_handles = {
+        demangle_handle(handle)
+        for handle in captured_vars
+        if isinstance(handle, HandleBinding)
+    }
     arg_handles = {
         demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
     }

classiq/model_expansions/closure.py

@@ -8,7 +8,6 @@ from typing import Any, Optional
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
@@ -35,14 +34,6 @@ class Closure:
     positional_arg_declarations: Sequence[PositionalArg] = tuple()
     captured_vars: CapturedVars = field(default_factory=CapturedVars)
 
-    @property
-    def port_declarations(self) -> dict[str, PortDeclaration]:
-        return {
-            param.name: param
-            for param in self.positional_arg_declarations
-            if isinstance(param, PortDeclaration)
-        }
-
 
 @dataclass(frozen=True)
 class GenerativeClosure(Closure):

classiq/model_expansions/evaluators/classical_type_inference.py

@@ -0,0 +1,70 @@
+from typing import Any, Union
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    ClassicalType,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+
+
+def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalType:
+    if isinstance(classical_type, TypeName):
+        return _infer_classical_struct_type(val, classical_type)
+    if isinstance(classical_type, (ClassicalArray, ClassicalList)):
+        return _infer_classical_array_type(val, classical_type)
+    return classical_type
+
+
+def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> ClassicalType:
+    if not isinstance(val, (QmodStructInstance, ClassicalStructProxy)):
+        return classical_type
+    decl = val.struct_declaration
+    new_fields = {
+        field_name: infer_classical_type(field_val, field_type)
+        for (field_name, field_val), field_type in zip(
+            val.fields.items(),
+            decl.variables.values(),
+            strict=True,
+        )
+    }
+    new_classical_type = TypeName(name=decl.name)
+    new_classical_type.set_classical_struct_decl(
+        StructDeclaration(name=decl.name, variables=new_fields)
+    )
+    return new_classical_type
+
+
+def _infer_classical_array_type(
+    val: Any, classical_type: Union[ClassicalArray, ClassicalList]
+) -> ClassicalType:
+    if isinstance(val, list):
+        val_length = len(val)
+    elif isinstance(val, ClassicalArrayProxy):
+        val_length = val.length
+    else:
+        raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
+    if isinstance(classical_type, ClassicalArray) and val_length != classical_type.size:
+        raise ClassiqExpansionError(
+            f"Type mismatch: Argument has {val_length} items but "
+            f"{classical_type.size} expected"
+        )
+    return ClassicalArray(
+        element_type=(
+            infer_classical_type(val[0], classical_type.element_type)
+            if val_length > 0
+            else classical_type.element_type
+        ),
+        size=val_length,
+    )

classiq/model_expansions/evaluators/parameter_types.py

@@ -12,6 +12,9 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
@@ -29,6 +32,9 @@ from classiq.model_expansions.evaluators.arg_type_match import check_type_match
 from classiq.model_expansions.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
+from classiq.model_expansions.evaluators.classical_type_inference import (
+    infer_classical_type,
+)
 from classiq.model_expansions.evaluators.quantum_type_utils import (
     copy_type_information,
     set_element_type,
@@ -73,11 +79,6 @@ def _update_scope(
     if parameter.direction is PortDeclarationDirection.Output:
         return
     quantum_symbol = argument.as_type(QuantumSymbol)
-    if not quantum_symbol.quantum_type.has_size_in_bits:
-        raise ClassiqExpansionError(
-            f"Argument {str(quantum_symbol.emit())!r} to function {closure.name!r} "
-            f"is not initialized"
-        )
     casted_argument = _cast(
         parameter.quantum_type,
         quantum_symbol,
@@ -126,6 +127,14 @@ def _cast(
 def _evaluate_type_from_arg(
     parameter: PositionalArg, argument: Evaluated, inner_scope: Scope
 ) -> PositionalArg:
+    if isinstance(parameter, ClassicalParameterDeclaration):
+        return ClassicalParameterDeclaration(
+            name=parameter.name,
+            classical_type=infer_classical_type(
+                argument.value, parameter.classical_type
+            ),
+        )
+
     if not isinstance(parameter, PortDeclaration):
         return parameter
 
@@ -260,9 +269,10 @@ def evaluate_types_in_quantum_symbols(
 def _inject_quantum_arg_info_to_type(
     parameter_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
 ) -> QuantumType:
-    copy_type_information(
-        quantum_symbol.quantum_type,
-        parameter_type,
-        param_name,
-    )
+    if quantum_symbol.quantum_type.has_size_in_bits:
+        copy_type_information(
+            quantum_symbol.quantum_type,
+            parameter_type,
+            param_name,
+        )
     return parameter_type

classiq/model_expansions/expression_evaluator.py

@@ -1,5 +1,4 @@
 import ast
-import re
 from collections.abc import Mapping
 from enum import EnumMeta
 from typing import Any, Optional
@@ -12,9 +11,6 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.expression_constants import (
-    CPARAM_EXECUTION_SUFFIX_PATTERN,
-)
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
@@ -115,13 +111,6 @@ def _validate_undefined_vars(
         - uninitialized_locals
     )
 
-    # Ignore expanded execution parameters
-    undefined_vars = {
-        var
-        for var in undefined_vars
-        if not re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, var)
-    }
-
     if len(undefined_vars) == 1:
         undefined_var = undefined_vars.__iter__().__next__()
         raise ClassiqExpansionError(f"Variable {undefined_var!r} is undefined")

classiq/model_expansions/function_builder.py

@@ -15,7 +15,6 @@ from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
 )
@@ -210,19 +209,14 @@ class OperationBuilder:
         self._current_source_ref = previous_source_ref
 
     def create_definition(
-        self, function_context: FunctionContext
+        self, function_context: FunctionContext, params: Sequence[PositionalArg]
     ) -> NativeFunctionDefinition:
         name = self._get_expanded_function_name(function_context)
-        new_parameters: list[PortDeclaration] = [
-            param
-            for param in function_context.positional_arg_declarations
-            if isinstance(param, PortDeclaration)
-        ]
 
         return NativeFunctionDefinition(
             name=name,
             body=function_context.body,
-            positional_arg_declarations=new_parameters,
+            positional_arg_declarations=params,
         )
 
     def _get_expanded_function_name(self, function_context: FunctionContext) -> str:

classiq/model_expansions/generative_functions.py

@@ -5,25 +5,17 @@ from typing import TYPE_CHECKING, Any
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
-    ClassiqInternalExpansionError,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
-    ClassicalArrayProxy,
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
-from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
-    ClassicalScalarProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
-    ClassicalStructProxy,
-)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
-from classiq.interface.generator.functions.classical_type import ClassicalArray
-from classiq.interface.generator.functions.type_name import Struct, TypeName
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
+from classiq.interface.generator.functions.type_name import Struct
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -39,7 +31,6 @@ from classiq.model_expansions.closure import (
     GenerativeClosure,
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
-from classiq.qmod.cparam import CParam
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CParamStruct, create_param
@@ -94,22 +85,6 @@ class LenList(list):
         return LenList([cls.wrap(item) for item in obj])
 
 
-def _create_qmod_classical_var(proxy: ClassicalProxy) -> CParam:
-    if isinstance(proxy, ClassicalScalarProxy):
-        classical_type = proxy._classical_type
-    elif isinstance(proxy, ClassicalArrayProxy):
-        classical_type = ClassicalArray(
-            element_type=proxy._element_type, size=proxy._length
-        )
-    elif isinstance(proxy, ClassicalStructProxy):
-        classical_type = TypeName(name=proxy._decl.name)
-    else:
-        raise ClassiqInternalExpansionError(
-            f"Unrecognized classical proxy {type(proxy).__name__}"
-        )
-    return create_param(str(proxy.handle), classical_type, QMODULE)
-
-
 def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
     if isinstance(param, PortDeclaration):
         quantum_symbol = evaluated.as_type(QuantumSymbol)
@@ -147,7 +122,9 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             qmodule=QMODULE,
         )
     if isinstance(classical_value, ClassicalProxy):
-        return _create_qmod_classical_var(classical_value)
+        return create_param(
+            str(classical_value.handle), get_proxy_type(classical_value), QMODULE
+        )
 
     return LenList.wrap(classical_value)
 

classiq/model_expansions/interpreters/base_interpreter.py

@@ -52,7 +52,6 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_entry_point_params_to_scope,
     init_builtin_types,
-    init_exec_params,
     init_top_level_scope,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
@@ -77,7 +76,6 @@ class BaseInterpreter:
 
         init_builtin_types()
         init_top_level_scope(model, self._top_level_scope)
-        self._exec_params = init_exec_params(model, self._top_level_scope)
         self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
             self._model.functions_compilation_metadata
         )
@@ -96,7 +94,9 @@ class BaseInterpreter:
         )
         context = self._expand_operation(main_closure)
         self._expanded_functions[main_closure.closure_id] = (
-            self._builder.create_definition(cast(FunctionContext, context))
+            self._builder.create_definition(
+                cast(FunctionContext, context), main_closure.positional_arg_declarations
+            )
         )
 
     def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
@@ -139,7 +139,6 @@ class BaseInterpreter:
             qstructs=list(QMODULE.qstruct_decls.values()),
             debug_info=self._model.debug_info,
             functions_compilation_metadata=self._expanded_functions_compilation_metadata,
-            execution_parameters=self._exec_params,
         )
 
     def process_exception(self, e: Exception) -> None:
@@ -159,7 +158,7 @@ class BaseInterpreter:
         expr = evaluate_classical_expression(expression, self._builder.current_scope)
         if not isinstance(expr.value, sympy.Basic):
             return expr
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(str(expr.value)))
         for handle in vrc.var_handles:
             if handle.name in self._builder.current_scope and isinstance(
@@ -190,8 +189,8 @@ class BaseInterpreter:
         quantum_variable = self.evaluate(sliced_handle_binding.base_handle).as_type(
             QuantumSymbol
         )
-        start = self.evaluate(sliced_handle_binding.start).as_type(int)
-        end = self.evaluate(sliced_handle_binding.end).as_type(int)
+        start = self.evaluate(sliced_handle_binding.start).value
+        end = self.evaluate(sliced_handle_binding.end).value
         return Evaluated(value=quantum_variable[start:end])
 
     @evaluate.register
@@ -201,7 +200,7 @@ class BaseInterpreter:
     @evaluate.register
     def evaluate_subscript_handle(self, subscript: SubscriptHandleBinding) -> Evaluated:
         base_value = self.evaluate(subscript.base_handle)
-        index_value = self.evaluate(subscript.index).as_type(int)
+        index_value = self.evaluate(subscript.index).value
         return Evaluated(value=base_value.value[index_value])
 
     @evaluate.register