classiq 0.69.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

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,12 +11,11 @@ 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.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
@@ -113,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

@@ -1,9 +1,20 @@
 from collections.abc import Mapping
+from sys import exc_info
+from types import TracebackType
 from typing import TYPE_CHECKING, Any
 
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+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
@@ -22,7 +33,7 @@ from classiq.model_expansions.closure import (
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 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
+from classiq.qmod.qmod_parameter import CParamStruct, create_param
 from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
 from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
@@ -37,6 +48,23 @@ if TYPE_CHECKING:
     )
 
 
+def _unwrap_traceback_frame(e: Exception) -> Exception:
+    fallback_error = ClassiqExpansionError(str(e))
+    traceback = exc_info()[2]
+    if traceback is None:
+        return fallback_error
+    back_frame = traceback.tb_frame.f_back
+    if back_frame is None:
+        return fallback_error
+    back_tb = TracebackType(
+        tb_next=None,
+        tb_frame=back_frame,
+        tb_lasti=back_frame.f_lasti,
+        tb_lineno=back_frame.f_lineno,
+    )
+    return e.with_traceback(back_tb)
+
+
 class LenList(list):
     @property
     def len(self) -> int:
@@ -45,7 +73,10 @@ class LenList(list):
     def __getitem__(self, item: Any) -> Any:
         if isinstance(item, QNum):
             return SymbolicExpr(f"{self}[{item}]", True)
-        return super().__getitem__(item)
+        try:
+            return super().__getitem__(item)
+        except (IndexError, TypeError) as e:
+            raise _unwrap_traceback_frame(e) from None
 
     @classmethod
     def wrap(cls, obj: Any) -> Any:
@@ -90,6 +121,11 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             struct_type=Struct(name=classical_value.struct_declaration.name),
             qmodule=QMODULE,
         )
+    if isinstance(classical_value, ClassicalProxy):
+        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:

classiq/model_expansions/quantum_operations/arithmetic/explicit_boolean_expressions.py

@@ -0,0 +1,60 @@
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.arith.arithmetic import is_bool
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
+
+from classiq.model_expansions.scope import QuantumSymbol
+
+
+def validate_assignment_bool_expression(
+    result_symbol: QuantumSymbol, expr: str, op_kind: ArithmeticOperationKind
+) -> None:
+    if not is_bool(expr):
+        return
+    _validate_target_type(result_symbol, expr, op_kind)
+
+
+def _validate_target_type(
+    target_symbol: QuantumSymbol, expr: str, op_kind: ArithmeticOperationKind
+) -> None:
+    supported_types = _supported_types()
+    if target_symbol.quantum_type.qmod_type_name not in supported_types:
+        raise ClassiqValueError(
+            f'The expression has been evaluated to "{expr}" which is a Boolean value. '
+            f"Cannot perform {op_kind.value} operation of Boolean expression to result variable '{target_symbol.handle}' of type {target_symbol.quantum_type.qmod_type_name}. "
+            f"Boolean expressions can only be applied on {' or '.join(supported_types)}."
+        )
+
+
+def convert_assignment_bool_expression(op: ArithmeticOperation) -> None:
+    if not is_bool(op.expression.expr):
+        return
+    op.expression = op.expression.model_copy(
+        update=dict(expr="1" if op.expression.expr == "True" else "0")
+    )
+
+
+def convert_inplace_op_bool_expression(
+    op: ArithmeticOperation, target: QuantumSymbol
+) -> None:
+    if not is_bool(op.expression.expr):
+        return
+    _validate_target_type(target, op.expression.expr, op.operation_kind)
+    op.expression = op.expression.model_copy(
+        update=dict(expr="1" if op.expression.expr == "True" else "0")
+    )
+
+
+def _supported_types() -> tuple[str, ...]:
+    return (
+        QuantumBit().qmod_type_name,
+        QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ).qmod_type_name,
+    )

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -11,6 +11,10 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
+    convert_assignment_bool_expression,
+    validate_assignment_bool_expression,
+)
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
@@ -24,6 +28,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         ):
             direction = PortDeclarationDirection.Output
             self._update_result_type(op)
+            convert_assignment_bool_expression(op)
         else:
             direction = PortDeclarationDirection.Inout
         self._capture_handle(op.result_var, direction)
@@ -47,6 +52,10 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             self._machine_precision,
         )
         result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+
+        validate_assignment_bool_expression(
+            result_symbol, op.expression.expr, op.operation_kind
+        )  # must be here, otherwise copy_type_information will throw a non-indicative error
         copy_type_information(
             result_type, result_symbol.quantum_type, str(op.result_var)
         )

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -2,17 +2,29 @@ from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
     TYPE_CHECKING,
+    Any,
     Generic,
     cast,
 )
 from uuid import UUID
 
+import sympy
+
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.generated_circuit_data import OperationLevel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -75,6 +87,16 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
             )
 
 
+def _is_symbolic(arg: Any) -> bool:
+    if isinstance(arg, list):
+        return any(_is_symbolic(item) for item in arg)
+    if isinstance(arg, QmodStructInstance):
+        return any(_is_symbolic(item) for item in arg.fields.values())
+    if isinstance(arg, sympy.Basic):
+        return len(arg.free_symbols) > 0
+    return isinstance(arg, ClassicalProxy)
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
@@ -197,7 +219,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             ].occurrences_number += 1
             return function_def
 
-        function_def = self._create_function_definition(function_context)
+        function_def = self._create_function_definition(function_context, args)
         self._expanded_functions[closure_id] = function_def
         self._top_level_scope[function_def.name] = Evaluated(
             value=function_context.closure.with_new_declaration(function_def)
@@ -210,14 +232,23 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         return function_def
 
     def _create_function_definition(
-        self, function_context: FunctionContext
+        self, function_context: FunctionContext, args: list[Evaluated]
     ) -> NativeFunctionDefinition:
-        func_def = self._builder.create_definition(function_context)
+        params = [
+            param
+            for arg, param in zip(args, function_context.positional_arg_declarations)
+            if isinstance(param, PortDeclaration)
+            or (
+                isinstance(param, ClassicalParameterDeclaration)
+                and _is_symbolic(arg.value)
+            )
+        ]
+        func_def = self._builder.create_definition(function_context, params)
 
         captured_vars = function_context.closure.captured_vars.filter_vars(
             function_context.closure
         )
-        captured_ports = captured_vars.get_captured_ports()
+        captured_ports = captured_vars.get_captured_parameters()
         if len(captured_ports) == 0:
             return func_def
         func_def.positional_arg_declarations = list(
@@ -239,15 +270,22 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         closure: FunctionClosure,
     ) -> None:
         for parameter, argument in zip(parameters, arguments):
+            param_handle = HandleBinding(name=parameter.name)
             if isinstance(argument.value, QuantumSymbol):
                 assert isinstance(parameter, PortDeclaration)
                 closure.scope[parameter.name] = Evaluated(
                     QuantumSymbol(
-                        handle=HandleBinding(name=parameter.name),
+                        handle=param_handle,
                         quantum_type=parameter.quantum_type,
                     ),
                     defining_function=closure,
                 )
+            elif _is_symbolic(argument.value):
+                assert isinstance(parameter, ClassicalParameterDeclaration)
+                closure.scope[parameter.name] = Evaluated(
+                    value=parameter.classical_type.get_classical_proxy(param_handle),
+                    defining_function=closure,
+                )
             else:
                 closure.scope[parameter.name] = argument
 
@@ -264,7 +302,9 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             return [arg.emit() for arg in evaluated_args]
 
         positional_args = [
-            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
+            arg.emit()
+            for arg in evaluated_args
+            if isinstance(arg.value, QuantumSymbol) or _is_symbolic(arg.value)
         ]
 
         return positional_args

classiq/model_expansions/quantum_operations/emitter.py

@@ -19,6 +19,13 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -145,6 +152,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         return new_expression
 
     def emit_statement(self, statement: QuantumStatement) -> None:
+        self._update_captured_classical_vars(statement)
         if isinstance(statement, QuantumOperation):
             self._update_captured_vars(statement)
         if statement.uuid not in self._interpreter._model.debug_info:
@@ -153,6 +161,11 @@ class Emitter(Generic[QuantumStatementT], ABC):
             )
         self._builder.emit_statement(statement)
 
+    def _update_captured_classical_vars(self, stmt: QuantumStatement) -> None:
+        for expr in stmt.expressions:
+            for var_name, var_type in self._get_classical_vars_in_expression(expr):
+                self._capture_classical_var(var_name, var_type)
+
     def _update_captured_vars(self, op: QuantumOperation) -> None:
         handles = (
             [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
@@ -178,6 +191,18 @@ class Emitter(Generic[QuantumStatementT], ABC):
             direction=direction,
         )
 
+    def _capture_classical_var(self, var_name: str, var_type: ClassicalType) -> None:
+        if var_name not in self._current_scope:
+            return
+        defining_function = self._current_scope[var_name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        self._builder.current_block.captured_vars.capture_classical_var(
+            var_name=var_name,
+            var_type=var_type,
+            defining_function=defining_function,
+        )
+
     def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
         vrc.visit(ast.parse(expr.expr))
@@ -187,3 +212,19 @@ class Emitter(Generic[QuantumStatementT], ABC):
             if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
         )
         return [self._interpreter.evaluate(handle).value for handle in handles]
+
+    def _get_classical_vars_in_expression(
+        self, expr: Expression
+    ) -> list[tuple[str, ClassicalType]]:
+        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
+        vrc.visit(ast.parse(expr.expr))
+        return list(
+            {
+                handle.name: get_proxy_type(proxy)
+                for handle in vrc.var_handles
+                if handle.name in self._current_scope
+                and isinstance(
+                    proxy := self._current_scope[handle.name].value, ClassicalProxy
+                )
+            }.items()
+        )

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -26,6 +26,10 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
+        for var_name, var_type in self._get_classical_vars_in_expression(
+            evaluated_expression
+        ):
+            self._capture_classical_var(var_name, var_type)
         op = op.model_copy(
             update={self._expression_name: evaluated_expression, "back_ref": op.uuid}
         )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,9 +1,5 @@
 from typing import TYPE_CHECKING
 
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.allocate import Allocate
-from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 from classiq.model_expansions.closure import FunctionClosure
@@ -17,21 +13,12 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
-ALLOCATE_COMPATIBILITY_ERROR_MESSAGE = (
-    "'allocate' expects two argument: The number of qubits to allocate (integer) and "
-    "the variable to be allocated (quantum variable)"
-)
-
-
 class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         super().__init__(interpreter)
         self._model = self._interpreter._model
 
     def emit(self, call: QuantumFunctionCall, /) -> bool:
-        if call.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
-            self._allocate_compatibility(call)
-            return True
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
@@ -40,15 +27,6 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             )
         return True
 
-    def _allocate_compatibility(self, call: QuantumFunctionCall) -> None:
-        if len(call.positional_args) != 2:
-            raise ClassiqValueError(ALLOCATE_COMPATIBILITY_ERROR_MESSAGE)
-        size, target = call.positional_args
-        if not isinstance(size, Expression) or not isinstance(target, HandleBinding):
-            raise ClassiqValueError(ALLOCATE_COMPATIBILITY_ERROR_MESSAGE)
-        allocate = Allocate(size=size, target=target, source_ref=call.source_ref)
-        self._interpreter.emit_statement(allocate)
-
 
 class DeclarativeQuantumFunctionCallEmitter(
     QuantumFunctionCallEmitter, DeclarativeCallEmitter

classiq/model_expansions/scope.py

@@ -1,13 +1,10 @@
 import itertools
-import re
 from collections import UserDict
 from collections.abc import Iterator
 from dataclasses import dataclass
 from functools import singledispatch
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
-from sympy import Symbol
-
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -16,10 +13,7 @@ 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.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import TypeName
@@ -72,9 +66,9 @@ class QuantumSymbol:
         array_length = self.quantum_type.length_value
         if start < 0 or end > array_length:
             raise ClassiqExpansionError(
-                f"Slice [{start}:{end}] is out of bounds of "
-                f"{self.quantum_type.type_name} {str(self.handle)!r} of length "
-                f"{array_length}"
+                f"Slice [{start}:{end}] is out of bounds for "
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
+                f"length {array_length})"
             )
         return QuantumSymbol(
             handle=SlicedHandleBinding(
@@ -96,8 +90,9 @@ class QuantumSymbol:
         array_length = self.quantum_type.length_value
         if index < 0 or index >= array_length:
             raise ClassiqExpansionError(
-                f"Subscript {index} is out of bounds of {self.quantum_type.type_name} "
-                f"{str(self.handle)!r} of length {array_length}"
+                f"Index {index} is out of bounds for "
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
+                f"length {array_length})"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(
@@ -203,8 +198,6 @@ class Scope(EvaluatedUserDict):
             return self.data[name]
         if self._parent is not None:
             return self._parent[name]
-        if re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, name):
-            return Evaluated(value=Symbol(name))
         raise ClassiqExpansionError(f"Variable {name!r} is undefined")
 
     def __contains__(self, item: Any) -> bool:

classiq/model_expansions/scope_initialization.py

@@ -1,16 +1,20 @@
 from collections.abc import Sequence
-from typing import Any
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqError, ClassiqInternalExpansionError
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+)
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 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,
-)
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.evaluators.classical_expression import (
@@ -101,17 +105,24 @@ def add_entry_point_params_to_scope(
     parameters: Sequence[PositionalArg], main_closure: FunctionClosure
 ) -> None:
     for parameter in parameters:
-        if not isinstance(parameter, PortDeclaration):
-            continue
-        main_closure.scope[parameter.name] = Evaluated(
-            value=QuantumSymbol(
-                handle=HandleBinding(name=parameter.name),
-                quantum_type=evaluate_type_in_quantum_symbol(
-                    parameter.quantum_type, main_closure.scope, parameter.name
+        if isinstance(parameter, PortDeclaration):
+            main_closure.scope[parameter.name] = Evaluated(
+                value=QuantumSymbol(
+                    handle=HandleBinding(name=parameter.name),
+                    quantum_type=evaluate_type_in_quantum_symbol(
+                        parameter.quantum_type, main_closure.scope, parameter.name
+                    ),
                 ),
-            ),
-            defining_function=main_closure,
-        )
+                defining_function=main_closure,
+            )
+        elif isinstance(parameter, ClassicalParameterDeclaration):
+            param_val = parameter.classical_type.get_classical_proxy(
+                handle=HandleBinding(name=parameter.name)
+            )
+            main_closure.scope[parameter.name] = Evaluated(
+                value=param_val,
+                defining_function=main_closure,
+            )
 
 
 def init_top_level_scope(model: Model, scope: Scope) -> None:
@@ -125,27 +136,9 @@ def init_builtin_types() -> None:
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
 
 
-def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
-    if not isinstance(param_val, list):
-        scope[str(param_val)] = Evaluated(value=param_val)
-        return
-    for param_part in param_val:
-        _add_exec_param_parts_to_scope(param_part, scope)
-
-
-def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
-    if model.execution_parameters is not None:
-        exec_params = model.execution_parameters
-    else:
-        exec_params = {
-            param.name: param.classical_type
-            for param in model.function_dict.get(
-                "_dec_main", model.main_func
-            ).param_decls
-        }
-    for param_name, param_type in exec_params.items():
-        param_val = param_type.as_symbolic(param_name)
-        scope[param_name] = Evaluated(value=param_val)
-        if isinstance(param_val, list):
-            _add_exec_param_parts_to_scope(param_val, scope)
-    return exec_params
+def _get_shape(classical_type: ConcreteClassicalType) -> tuple[int, ...]:
+    if isinstance(classical_type, ClassicalList):
+        raise ClassiqInternalExpansionError("Unexpected classical list")
+    if isinstance(classical_type, ClassicalArray):
+        return classical_type.size, *_get_shape(classical_type.element_type)
+    return ()