classiq 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/qmod/semantics/static_semantics_visitor.py

@@ -1,41 +1,72 @@
 from contextlib import contextmanager
-from typing import Any, Dict, Iterator, List, Mapping, Type, Union
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+)
 
 from classiq.interface.generator.function_params import PortDirection
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.visitor import Visitor
 from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
 )
-from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 from classiq.interface.model.validation_handle import HandleState
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq import AnonClassicalParameterDeclaration
 from classiq.exceptions import ClassiqSemanticError
 from classiq.qmod.semantics.annotation import annotate_function_call_decl
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.validation.func_call_validation import (
+    check_no_overlapping_quantum_args,
     validate_call_arguments,
 )
-from classiq.qmod.semantics.validation.types_validation import check_duplicate_types
+from classiq.qmod.semantics.validation.handle_validation import resolve_handle
+from classiq.qmod.semantics.validation.types_validation import (
+    check_cstruct_has_fields,
+    check_duplicate_types,
+    check_qstruct_fields_are_defined,
+    check_qstruct_flexibility,
+    check_qstruct_has_fields,
+    check_qstruct_is_not_recursive,
+)
+
+HANDLE_BINDING_PART_MESSAGE = {
+    SubscriptHandleBinding: "array subscript",
+    SlicedHandleBinding: "array slice",
+    FieldHandleBinding: "field access",
+}
 
 
 class StaticScope:
@@ -45,16 +76,18 @@ class StaticScope:
         parameters: List[str],
         operands: Dict[str, QuantumOperandDeclaration],
         variables_to_states: Dict[str, HandleState],
+        variables_to_types: Dict[str, ConcreteQuantumType],
     ) -> None:
         self.parameters = parameters
         self.operands = operands
         self.variable_states = variables_to_states
+        self.variables_to_types = variables_to_types
 
 
 class StaticSemanticsVisitor(Visitor):
     def __init__(
         self,
-        functions_dict: Dict[str, QuantumFunctionDeclaration],
+        functions_dict: Mapping[str, QuantumFunctionDeclaration],
         constants: List[str],
     ) -> None:
         self._scope: List[StaticScope] = []
@@ -73,25 +106,46 @@ class StaticSemanticsVisitor(Visitor):
         self._scope.pop()
 
     def visit_Model(self, model: Model) -> None:
-        check_duplicate_types([*model.enums, *model.types])
+        check_duplicate_types([*model.enums, *model.types, *model.qstructs])
+        for qstruct in model.qstructs:
+            check_qstruct_has_fields(qstruct)
+            if check_qstruct_fields_are_defined(
+                qstruct
+            ) and check_qstruct_is_not_recursive(qstruct):
+                check_qstruct_flexibility(qstruct)
+        for cstruct in model.types:
+            check_cstruct_has_fields(cstruct)
         self.visit_BaseModel(model)
 
     def visit_NativeFunctionDefinition(
         self, func_def: NativeFunctionDefinition
     ) -> None:
-        if len(func_def.body) == 0:
-            return
         scope = StaticScope(
-            parameters=list(func_def.param_decls.keys()) + self._constants,
-            operands=dict(func_def.operand_declarations),
+            parameters=list(func_def.param_names) + self._constants,
+            operands=dict(func_def.operand_declarations_dict),
             variables_to_states=initialize_variables_to_state(
-                list(func_def.port_declarations.values())
+                func_def.port_declarations
             ),
+            variables_to_types={
+                port.name: port.quantum_type for port in func_def.port_declarations
+            },
         )
-        with self.scoped_visit(scope):
+        with self.scoped_visit(scope), self._error_manager.call(func_def.name):
+            parameter_declaration_names = [
+                decl.name for decl in func_def.positional_arg_declarations
+            ]
+            seen_names: Set[str] = set()
+            for name in parameter_declaration_names:
+                if name in seen_names:
+                    self._error_manager.add_error(
+                        f"duplicate parameter declaration name {name!r}"
+                    )
+                seen_names.add(name)
+            if len(func_def.body) == 0:
+                return
             self.visit(func_def.body)
             with self._error_manager.node_context(func_def.body[-1]):
-                for port_decl in func_def.port_declarations.values():
+                for port_decl in func_def.port_declarations:
                     handle_state = self.current_scope.variable_states[port_decl.name]
                     expected_terminal_state = EXPECTED_TERMINAL_STATES.get(
                         port_decl.direction
@@ -110,6 +164,7 @@ class StaticSemanticsVisitor(Visitor):
             parameters=self.current_scope.parameters,
             operands=self.current_scope.operands,
             variables_to_states=self.current_scope.variable_states.copy(),
+            variables_to_types=self.current_scope.variables_to_types.copy(),
         )
         with self.scoped_visit(scope):
             self.visit(within_apply.compute)
@@ -147,9 +202,13 @@ class StaticSemanticsVisitor(Visitor):
                         **self.current_scope.operands,
                     },
                 )
-            self._handle_inputs(op.wiring_inputs)
-            self._handle_outputs(op.wiring_outputs)
-            self._handle_inouts(op.wiring_inouts)
+            elif isinstance(op, InplaceBinaryOperation):
+                check_no_overlapping_quantum_args(
+                    [op.target, op.value], op.operation.value
+                )
+            self._handle_inputs(op.readable_inputs)
+            self._handle_outputs(op.readable_outputs)
+            self._handle_inouts(op.readable_inouts)
             self.generic_visit(op)
 
     def visit_VariableDeclarationStatement(
@@ -163,89 +222,117 @@ class StaticSemanticsVisitor(Visitor):
             return
 
         self.current_scope.variable_states[declaration.name] = HandleState.UNINITIALIZED
+        self.current_scope.variables_to_types[declaration.name] = (
+            declaration.quantum_type
+        )
 
     def visit_QuantumLambdaFunction(self, lambda_func: QuantumLambdaFunction) -> None:
-        assert lambda_func.func_decl is not None
-        renamed_parameters = [
-            lambda_func.rename_params.get(param, param)
-            for param in self.current_scope.parameters
-            + list(lambda_func.func_decl.param_decls.keys())
-        ]
-        ports = list(lambda_func.func_decl.port_declarations.values())
-        for i, port in enumerate(ports):
-            ports[i] = port.copy(
-                update={"name": lambda_func.rename_params.get(port.name, port.name)}
-            )
-        variables_to_states = self.current_scope.variable_states.copy()
-        original_operands = {
-            **dict(lambda_func.func_decl.operand_declarations),
-            **self.current_scope.operands,
-        }
-        renamed_operands: Dict[str, QuantumOperandDeclaration] = {}
-        for operand_name, operand_decl in original_operands.items():
-            renamed_name = lambda_func.rename_params.get(operand_name, operand_name)
-            renamed_operands[renamed_name] = operand_decl.copy(
-                update={"name": renamed_name}
-            )
+        renamed_parameters, renamed_operands, renamed_ports = (
+            self._get_renamed_parameters(lambda_func)
+        )
         scope = StaticScope(
-            parameters=renamed_parameters,
-            operands=renamed_operands,
+            parameters=self.current_scope.parameters + renamed_parameters,
+            operands={**self.current_scope.operands, **renamed_operands},
             variables_to_states={
-                **variables_to_states,
-                **initialize_variables_to_state(ports),
+                **self.current_scope.variable_states.copy(),
+                **initialize_variables_to_state(renamed_ports),
             },
+            variables_to_types=self.current_scope.variables_to_types
+            | {port.name: port.quantum_type for port in renamed_ports},
         )
         with self.scoped_visit(scope):
             self.generic_visit(lambda_func)
 
-    def _handle_inputs(self, inputs: Mapping[str, HandleBinding]) -> None:
-        for handle_binding in inputs.values():
-            handle_wiring_state = self.current_scope.variable_states[
-                handle_binding.name
-            ]
-            if handle_wiring_state is not HandleState.INITIALIZED:
+    def _get_renamed_parameters(
+        self, lambda_func: QuantumLambdaFunction
+    ) -> Tuple[List[str], Dict[str, QuantumOperandDeclaration], List[PortDeclaration]]:
+        renamed_parameters: List[str] = []
+        renamed_operands: Dict[str, QuantumOperandDeclaration] = {}
+        renamed_ports: List[PortDeclaration] = []
+        for idx, param in enumerate(lambda_func.func_decl.positional_arg_declarations):
+            param_name = lambda_func.get_rename_params()[idx]
+            if isinstance(param, AnonClassicalParameterDeclaration):
+                renamed_parameters.append(param_name)
+            elif isinstance(param, AnonQuantumOperandDeclaration):
+                renamed_operands[param_name] = param.rename(param_name)
+            else:
+                renamed_ports.append(param.rename(param_name))
+        return renamed_parameters, renamed_operands, renamed_ports
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> None:
+        resolve_handle(self.current_scope, handle)
+
+    def _handle_state_changing_ios(
+        self,
+        ios: Sequence[HandleMetadata],
+        state: HandleState,
+        state_change_verb: str,
+    ) -> None:
+        for handle_metadata in ios:
+            handle_binding = handle_metadata.handle
+            if isinstance(
+                handle_binding,
+                (SubscriptHandleBinding, SlicedHandleBinding, FieldHandleBinding),
+            ):
                 self._error_manager.add_error(
-                    f"Trying to access handle {handle_binding.name!r} as input but it is in incorrect state"
+                    f"Cannot use {HANDLE_BINDING_PART_MESSAGE[type(handle_binding)]} of variable {handle_binding.name!r} in {state_change_verb} context"
                 )
                 continue
-
-            self.current_scope.variable_states[handle_binding.name] = (
-                HandleState.UNINITIALIZED
-            )
-
-    def _handle_outputs(self, outputs: Mapping[str, HandleBinding]) -> None:
-        for handle_binding in outputs.values():
-            handle_wiring_state = self.current_scope.variable_states[
+            handle_wiring_state = self.current_scope.variable_states.get(
                 handle_binding.name
-            ]
-
-            if handle_wiring_state is not HandleState.UNINITIALIZED:
+            )
+            if handle_wiring_state is not state:
+                state_prefix = (
+                    ""
+                    if handle_wiring_state is None
+                    else f"{handle_wiring_state.name.lower()} "
+                )
+                location = (
+                    f" {handle_metadata.readable_location}"
+                    if handle_metadata.readable_location is not None
+                    else ""
+                )
                 self._error_manager.add_error(
-                    f"Trying to access handle {handle_binding.name!r} as output but it is in incorrect state"
+                    f"Cannot use {state_prefix}quantum variable {handle_binding.name!r}"
+                    f"{location}"
                 )
-                continue
 
-            self.current_scope.variable_states[handle_binding.name] = (
-                HandleState.INITIALIZED
-            )
+            self.current_scope.variable_states[handle_binding.name] = ~state
 
-    def _handle_inouts(
-        self,
-        inouts: Mapping[
-            str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-        ],
-    ) -> None:
+    def _handle_inputs(self, inputs: Sequence[HandleMetadata]) -> None:
+        self._handle_state_changing_ios(
+            inputs, HandleState.INITIALIZED, "uninitialization"
+        )
+
+    def _handle_outputs(self, outputs: Sequence[HandleMetadata]) -> None:
+        self._handle_state_changing_ios(
+            outputs, HandleState.UNINITIALIZED, "initialization"
+        )
+
+    def _handle_inouts(self, inouts: Sequence[HandleMetadata]) -> None:
         sliced_handles = set()
         whole_handles = set()
 
-        for handle_binding in inouts.values():
+        for handle_metadata in inouts:
+            handle_binding = handle_metadata.handle
             handle_wiring_state = self.current_scope.variable_states[
                 handle_binding.name
             ]
 
             if handle_wiring_state is not HandleState.INITIALIZED:
+                state_prefix = (
+                    ""
+                    if handle_wiring_state is None
+                    else f"{handle_wiring_state.name.lower()} "
+                )
+                location = (
+                    f" {handle_metadata.readable_location}"
+                    if handle_metadata.readable_location is not None
+                    else ""
+                )
                 self._error_manager.add_error(
-                    f"Trying to access handle {handle_binding.name!r} as inout but it is in incorrect state"
+                    f"Cannot use {state_prefix}quantum variable {handle_binding.name!r}"
+                    f"{location}"
                 )
 
             if isinstance(
@@ -275,7 +362,7 @@ def resolve_function_calls(
 
 
 def static_semantics_analysis_pass(
-    model: Model, error_type: Type[Exception] = ClassiqSemanticError
+    model: Model, error_type: Optional[Type[Exception]] = ClassiqSemanticError
 ) -> None:
     StaticSemanticsVisitor(
         {
@@ -284,7 +371,8 @@ def static_semantics_analysis_pass(
         },
         [const.name for const in model.constants],
     ).visit(model)
-    ErrorManager().report_errors(error_type)
+    if error_type is not None:
+        ErrorManager().report_errors(error_type)
 
 
 EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
@@ -294,7 +382,7 @@ EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
 
 
 def initialize_variables_to_state(
-    port_declarations: List[PortDeclaration],
+    port_declarations: Sequence[PortDeclaration],
 ) -> Dict[str, HandleState]:
     variables_to_state: Dict[str, HandleState] = dict()
 

classiq/qmod/semantics/validation/func_call_validation.py

@@ -1,13 +1,12 @@
-import re
-from typing import Mapping, Set
+from typing import List, Mapping
 
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumFunctionDeclaration,
+    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
@@ -22,128 +21,75 @@ def validate_call_arguments(
     fc: QuantumFunctionCall,
     function_dict: Mapping[str, QuantumFunctionDeclaration],
 ) -> None:
-    _check_params_against_declaration(
-        set(fc.params.keys()),
-        set(fc.func_decl.param_decls.keys()),
-        fc.func_decl.name,
-    )
-    _check_ports_against_declaration(fc, fc.func_decl)
-    _check_params_against_declaration(
-        set(fc.operands.keys()),
-        set(fc.func_decl.operand_declarations.keys()),
-        fc.func_name,
-    )
-    _check_operands_against_declaration(fc, fc.func_decl, function_dict)
-
-
-def _check_ports_against_declaration(
-    call: QuantumFunctionCall, decl: QuantumFunctionDeclaration
-) -> None:
-    call_input_names = set(call.inputs.keys())
-
-    _check_params_against_declaration(
-        call_input_names,
-        decl.ports_by_declaration_direction(PortDeclarationDirection.Input),
-        call.func_name,
-    )
-
-    call_output_names = set(call.outputs.keys())
-
-    _check_params_against_declaration(
-        call_output_names,
-        decl.ports_by_declaration_direction(PortDeclarationDirection.Output),
-        call.func_name,
-    )
-
-    inout_params = set(call.inouts.keys())
-
-    _check_params_against_declaration(
-        inout_params,
-        decl.ports_by_declaration_direction(PortDeclarationDirection.Inout),
-        call.func_name,
-    )
+    pos_args = fc.positional_args
+    pos_params = fc.func_decl.positional_arg_declarations
+    if len(pos_args) != len(pos_params):
+        ErrorManager().add_error(
+            f"Function {fc.func_name} takes {len(pos_params)} arguments but "
+            f"{len(pos_args)} were given."
+        )
+    for arg, param in zip(pos_args, pos_params):
+        if not isinstance(arg, (Expression, HandleBinding)) and isinstance(
+            param, AnonQuantumOperandDeclaration
+        ):
+            _check_operand_against_declaration(param, arg, function_dict, fc.func_name)
+    check_no_overlapping_quantum_args(fc.ports, fc.func_name)
 
 
 def _check_operand_against_declaration(
-    call: QuantumFunctionCall,
-    operand_decl: QuantumOperandDeclaration,
+    operand_decl: AnonQuantumOperandDeclaration,
     operand_argument: QuantumOperand,
     function_dict: Mapping[str, QuantumFunctionDeclaration],
+    func_name: str,
     in_list: bool = False,
 ) -> None:
     if isinstance(operand_argument, list):
         if in_list:
             ErrorManager().add_error(
-                f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not "
-                f"a valid operand. Nested operand lists are not permitted"
+                f"{str(operand_argument)!r} argument to {func_name!r} is not "
+                f"a valid operand. Nested operand lists are not permitted."
             )
             return
         for arg in operand_argument:
             _check_operand_against_declaration(
-                call, operand_decl, arg, function_dict, in_list=True
+                operand_decl, arg, function_dict, func_name, in_list=True
             )
         return
-    operand_arg_decl: QuantumFunctionDeclaration
+    operand_arg_decl: AnonQuantumFunctionDeclaration
     if isinstance(operand_argument, str):
         if operand_argument not in function_dict:
             ErrorManager().add_error(
-                f"{operand_argument!r} argument to {call.func_decl.name!r} is not a "
-                f"registered function"
+                f"{operand_argument!r} argument to {func_name!r} is not a "
+                f"registered function."
             )
             return
         operand_arg_decl = function_dict[operand_argument]
     elif isinstance(operand_argument, QuantumLambdaFunction):
-        if operand_argument.func_decl is None:
-            return
         operand_arg_decl = operand_argument.func_decl
     else:
         raise ClassiqError(
-            f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not a "
-            f"valid operand"
+            f"{str(operand_argument)!r} argument to {func_name!r} is not a "
+            f"valid operand."
         )
-    num_arg_parameters = len(operand_arg_decl.get_positional_arg_decls())
-    num_decl_parameters = len(operand_decl.get_positional_arg_decls())
+    num_arg_parameters = len(operand_arg_decl.positional_arg_declarations)
+    num_decl_parameters = len(operand_decl.positional_arg_declarations)
     if num_arg_parameters != num_decl_parameters:
         ErrorManager().add_error(
-            f"Signature of argument {operand_argument!r} to {call.func_decl.name!r} "
+            f"Signature of argument {operand_argument!r} to {func_name!r} "
             f"does not match the signature of parameter {operand_decl.name!r}. "
             f"{operand_decl.name!r} accepts {num_decl_parameters} parameters but "
-            f"{operand_argument!r} accepts {num_arg_parameters} parameters"
-        )
-
-
-def _check_operands_against_declaration(
-    call: QuantumFunctionCall,
-    decl: QuantumFunctionDeclaration,
-    function_dict: Mapping[str, QuantumFunctionDeclaration],
-) -> None:
-    for operand_parameter, operand_argument in call.operands.items():
-        _check_operand_against_declaration(
-            call,
-            decl.operand_declarations[operand_parameter],
-            operand_argument,
-            function_dict,
+            f"{operand_argument!r} accepts {num_arg_parameters} parameters."
         )
 
 
-def _check_params_against_declaration(
-    call_params: Set[str],
-    param_decls: Set[str],
-    callee_name: str,
+def check_no_overlapping_quantum_args(
+    args: List[HandleBinding], func_name: str
 ) -> None:
-    unknown_params = call_params - param_decls
-    if any(re.match(r"arg\d+", param) for param in unknown_params):
-        error_msg = (
-            f"Unsupported passing of named function {callee_name!r} as an operand."
-            "\nSuggestion: replace the named function with lambda function."
-        )
-    else:
-        error_msg = f"Unknown parameters {unknown_params} in call to {callee_name!r}."
-    if unknown_params:
-        ErrorManager().add_error(error_msg)
-
-    missing_params = param_decls - call_params
-    if missing_params:
-        ErrorManager().add_error(
-            f"Missing parameters {missing_params} in call to {callee_name!r}."
-        )
+    for idx, arg in enumerate(args):
+        for other_arg in args[idx + 1 :]:
+            if arg.overlaps(other_arg):
+                ErrorManager().add_error(
+                    f"Cannot use the same part of variable {arg.name!r} in multiple "
+                    f"arguments to function {func_name!r}."
+                )
+                break

classiq/qmod/semantics/validation/handle_validation.py

@@ -0,0 +1,85 @@
+from typing import TYPE_CHECKING, Optional, Union
+
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
+    FieldHandleBinding,
+    HandleBinding,
+    NestedHandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
+
+import classiq.qmod.semantics.error_manager as error_manager
+from classiq.qmod.model_state_container import QMODULE
+
+if TYPE_CHECKING:
+    from classiq.qmod.semantics.static_semantics_visitor import StaticScope
+
+
+def resolve_handle(scope: "StaticScope", handle: HandleBinding) -> None:
+    if handle.name not in scope.variables_to_types:
+        error_manager.append_error(handle, f"Variable {handle.name!r} is undefined.")
+        return
+    _resolve_handle_recursively(scope.variables_to_types[handle.name], handle)
+
+
+def _resolve_handle_recursively(
+    qtype: QuantumType, handle: ConcreteHandleBinding
+) -> Optional[QuantumType]:
+    if isinstance(handle, NestedHandleBinding):
+        return _resolve_nested_handle(qtype, handle)
+    return qtype
+
+
+def _resolve_nested_handle(
+    qtype: QuantumType, handle: NestedHandleBinding
+) -> Optional[QuantumType]:
+    nested_qtype = _resolve_handle_recursively(qtype, handle.base_handle)
+    if nested_qtype is None:
+        return None
+    if isinstance(handle, (SubscriptHandleBinding, SlicedHandleBinding)):
+        return _resolve_subscript_sliced_handle(nested_qtype, handle)
+    if TYPE_CHECKING:
+        assert isinstance(handle, FieldHandleBinding)
+    return _resolve_field_handle(nested_qtype, handle)
+
+
+def _resolve_subscript_sliced_handle(
+    qtype: QuantumType, handle: Union[SubscriptHandleBinding, SlicedHandleBinding]
+) -> Optional[QuantumType]:
+    if not isinstance(qtype, QuantumBitvector):
+        error_manager.append_error(handle, f"{qtype.type_name} is not subscriptable.")
+        return None
+    return qtype.element_type if isinstance(handle, SubscriptHandleBinding) else qtype
+
+
+def _validate_field_access(qtype: QuantumType, handle: FieldHandleBinding) -> bool:
+    if not isinstance(qtype, TypeName):
+        error_manager.append_error(handle, f"{qtype.type_name} has no fields.")
+        return False
+    if qtype.name not in QMODULE.qstruct_decls:
+        error_manager.append_error(
+            handle, f"{qtype.type_name} is not a quantum struct."
+        )
+        return False
+    if handle.field not in qtype.fields:
+        error_manager.append_error(
+            handle,
+            f"Struct {qtype.type_name} has no field {handle.field!r}. "
+            f"Available fields: {', '.join(qtype.fields.keys())}",
+        )
+        return False
+
+    return True
+
+
+def _resolve_field_handle(
+    qtype: QuantumType, handle: FieldHandleBinding
+) -> Optional[QuantumType]:
+    if _validate_field_access(qtype, handle):
+        if TYPE_CHECKING:
+            assert isinstance(qtype, TypeName)
+        return qtype.fields[handle.field]
+    return None