classes

Compose the class-lookup helpers and class-access visitor overloads into the public class-focused expression mixin.

Classes:

• ExpressionClassVisitorMixin –

ExpressionClassVisitorMixin

Bases: ExpressionClassAccessVisitorMixin

Methods:

• visit –

visit

visit(node: FieldAccess) -> None

Source code in packages/irx/src/irx/analysis/handlers/_expressions/class_access.py

@SemanticAnalyzerCore.visit.dispatch
def visit(self, node: astx.FieldAccess) -> None:
    """
    title: Visit FieldAccess nodes.
    parameters:
      node:
        type: astx.FieldAccess
    """
    self.visit(node.value)
    if not self._require_value_expression(
        node.value,
        context="Field access",
    ):
        self._set_type(node, None)
        return
    module = self._module_namespace(node.value)
    if module is not None:
        namespace_name = self._module_namespace_name(node.value, module)
        binding = self._resolve_module_member_binding(
            module,
            node.field_name,
            node=node,
            namespace_name=namespace_name,
        )
        if binding is None:
            self._set_type(node, None)
            return
        self._set_module_member_resolution(
            node,
            module=module,
            member_name=node.field_name,
            binding=binding,
        )
        return
    base_type = self._expr_type(node.value)
    struct = self._resolve_struct_from_type(
        base_type,
        node=node,
        unknown_message="field access requires a struct or class value",
    )
    if struct is not None:
        field_index = struct.field_indices.get(node.field_name)
        if field_index is None or field_index >= len(struct.fields):
            self.context.diagnostics.add(
                f"struct '{struct.name}' has no field '{node.field_name}'",
                node=node,
                code=DiagnosticCodes.SEMANTIC_INVALID_FIELD_ACCESS,
            )
            self._set_type(node, None)
            return
        field = struct.fields[field_index]
        self._set_struct(node, struct)
        self._set_field_access(node, ResolvedFieldAccess(struct, field))
        self._set_type(node, field.type_)
        return

    class_ = self._resolve_class_from_type(
        base_type,
        node=node,
        unknown_message="field access requires a struct or class value",
    )
    if class_ is None:
        if not isinstance(base_type, astx.StructType | astx.ClassType):
            self.context.diagnostics.add(
                "field access requires a struct or class value, got "
                f"{display_type_name(base_type)}",
                node=node,
                code=DiagnosticCodes.SEMANTIC_INVALID_FIELD_ACCESS,
            )
        self._set_type(node, None)
        return

    member = self._resolve_class_attribute_member(
        class_,
        node.field_name,
        node=node,
    )
    if member is None:
        self._set_type(node, None)
        return
    if member.is_static:
        self.context.diagnostics.add(
            (
                f"static attribute '{class_.name}.{node.field_name}' "
                "must be accessed through the class"
            ),
            node=node,
            code=DiagnosticCodes.SEMANTIC_INVALID_FIELD_ACCESS,
        )
        self._set_type(node, None)
        return
    if not self._member_is_accessible(member):
        self.context.diagnostics.add(
            (
                "class attribute "
                f"'{self._member_display_name(member)}' "
                "is not accessible from this context"
            ),
            node=node,
            code=DiagnosticCodes.SEMANTIC_INVALID_FIELD_ACCESS,
        )
        self._set_type(node, None)
        return
    field = self._resolve_class_field_slot(
        class_,
        member,
        visible_name=node.field_name,
    )
    self._set_class(node, class_)
    self._set_class_field_access(
        node,
        ResolvedClassFieldAccess(class_, member, field),
    )
    self._set_type(node, member.type_)