#[derive(Debug, Clone)]

pub enum SelectKind {

    StructField(Identifier),

    TupleMember(u64), // u64 is overkill, but space is taken up by `StructField` variant anyway

}

    pub kind: SelectKind,

                match &expr.kind {

                    SelectKind::StructField(field_name) => {

                        self.kv(indent2).with_s_key("StructField").with_identifier_val(field_name);

                    },

                    SelectKind::TupleMember(member_index) => {

                        self.kv(indent2).with_s_key("TupleMember").with_disp_val(member_index);

                    },

                }

                // Can be a select expression for struct fields, or a select

                // for a tuple element.

                let next = iter.next();

                let (select_kind, full_span) = if Some(TokenKind::Integer) == next {

                    // Tuple member

                    let (index, index_span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;

                    let full_span = InputSpan::from_positions(

                        ctx.heap[subject].full_span().begin, index_span.end

                    );

                    (SelectKind::TupleMember(index), full_span)

                } else if Some(TokenKind::Ident) == next {

                    // Struct field

                    let field_name = consume_ident_interned(&module.source, iter, ctx)?;

                    let full_span = InputSpan::from_positions(

                        ctx.heap[subject].full_span().begin, field_name.span.end

                    );

                    (SelectKind::StructField(field_name), full_span)

                } else {

                    return Err(ParseError::new_error_str_at_pos(

                        &module.source, iter.last_valid_pos(), "unexpected token: expected integer or identifier"

                    ));

                };

                    this, operator_span, full_span, subject,

                    kind: select_kind,

        fn try_get_definition_id_from_inference_type<'a>(types: &'a TypeTable, infer_type: &InferenceType) -> Result<Option<&'a DefinedType>, ()> {

        fn try_get_tuple_size_from_inference_type(infer_type: &InferenceType) -> Result<Option<u32>, ()> {

            for part in &infer_type.parts {

                if part.is_marker() || !part.is_concrete() {

                    continue;

                }

                if let InferenceTypePart::Tuple(size) = part {

                    return Ok(Some(*size));

                } else {

                    // Expected a tuple

                    return Err(());

                }

            }

            // Type is not "defined enough" yet

            Ok(None)

        }

        let (progress_subject, progress_expr) = match &select_expr.kind {

            SelectKind::StructField(field_name) => {

                // Handle select of a struct's field

                if infer_expr.field_or_monomorph_idx < 0 {

                    // We don't know the field or the definition it is pointing to yet

                    // Not yet known, check if we can determine it

                    let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;

                    let type_def = try_get_definition_id_from_inference_type(&ctx.types, subject_type);

                    match type_def {

                        Ok(Some(type_def)) => {

                            // Subject type is known, check if it is a

                            // struct and the field exists on the struct

                            let struct_def = if let DefinedTypeVariant::Struct(struct_def) = &type_def.definition {

                                struct_def

                            } else {

                                return Err(ParseError::new_error_at_span(

                                    &ctx.module().source, field_name.span, format!(

                                        "Can only apply field access to structs, got a subject of type '{}'",

                                        subject_type.display_name(&ctx.heap)

                                    )

                                ));

                            };

                            let mut struct_def_id = None;

                            for (field_def_idx, field_def) in struct_def.fields.iter().enumerate() {

                                if field_def.identifier == *field_name {

                                    // Set field definition and index

                                    let infer_expr = &mut self.expr_types[expr_idx as usize];

                                    infer_expr.field_or_monomorph_idx = field_def_idx as i32;

                                    struct_def_id = Some(type_def.ast_definition);

                                    break;

                                }

                            }

                            if struct_def_id.is_none() {

                                let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct();

                                return Err(ParseError::new_error_at_span(

                                    &ctx.module().source, field_name.span, format!(

                                        "this field does not exist on the struct '{}'",

                                        ast_struct_def.identifier.value.as_str()

                                    )

                                ))

                            }

                            // Encountered definition and field index for the

                            // first time

                            self.insert_initial_select_polymorph_data(ctx, id, struct_def_id.unwrap());

                        },

                        Ok(None) => {

                            // Type of subject is not yet known, so we

                            // cannot make any progress yet

                            return Ok(())

                        },

                        Err(()) => {

                            return Err(ParseError::new_error_at_span(

                                &ctx.module().source, field_name.span, format!(

                                    "Can only apply field access to structs, got a subject of type '{}'",

                                    subject_type.display_name(&ctx.heap)

                                )

                            ));

                }

                // If here then field index is known, and the referenced struct type

                // information is inserted into `extra_data`. Check to see if we can

                // do some mutual inference.

                let poly_data = &mut self.extra_data[extra_idx as usize];

                let mut poly_progress = HashSet::new();

                // Apply to struct's type

                let signature_type: *mut _ = &mut poly_data.embedded[0];

                let subject_type: *mut _ = &mut self.expr_types[subject_expr_idx as usize].expr_type;

                let (_, progress_subject) = Self::apply_equal2_signature_constraint(

                    ctx, upcast_id, Some(subject_id), poly_data, &mut poly_progress,

                    signature_type, 0, subject_type, 0

                )?;

                if progress_subject {

                    self.expr_queued.push_back(subject_expr_idx);

                // Apply to field's type

                let signature_type: *mut _ = &mut poly_data.returned;

                let expr_type: *mut _ = &mut self.expr_types[expr_idx as usize].expr_type;

                let (_, progress_expr) = Self::apply_equal2_signature_constraint(

                    ctx, upcast_id, None, poly_data, &mut poly_progress,

                    signature_type, 0, expr_type, 0

                )?;

                if progress_expr {

                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

                        let parent_idx = ctx.heap[parent_id].get_unique_id_in_definition();

                        self.expr_queued.push_back(parent_idx);

                    }

                }

                // Reapply progress in polymorphic variables to struct's type

                let signature_type: *mut _ = &mut poly_data.embedded[0];

                let subject_type: *mut _ = &mut self.expr_types[subject_expr_idx as usize].expr_type;

                let progress_subject = Self::apply_equal2_polyvar_constraint(

                    poly_data, &poly_progress, signature_type, subject_type

                );

                let signature_type: *mut _ = &mut poly_data.returned;

                let expr_type: *mut _ = &mut self.expr_types[expr_idx as usize].expr_type;

                let progress_expr = Self::apply_equal2_polyvar_constraint(

                    poly_data, &poly_progress, signature_type, expr_type

                );

                (progress_subject, progress_expr)

            },

            SelectKind::TupleMember(member_index) => {

                let member_index = *member_index;

                if infer_expr.field_or_monomorph_idx < 0 {

                    // We don't know what kind of tuple we're accessing yet

                    let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;

                    let tuple_size = try_get_tuple_size_from_inference_type(subject_type);

                    match tuple_size {

                        Ok(Some(enum_size)) => {

                            // Make sure we don't access an element outside of

                            // the tuple's bounds

                            if member_index >= enum_size as u64 {

                                return Err(ParseError::new_error_at_span(

                                    &ctx.module().source, select_expr.full_span, format!(

                                        "element index {} is out of bounds, tuple has {} elements",

                                        member_index, enum_size

                                    )

                                ));

                            }

                            // Within bounds, so set the index (such that we

                            // will not perform this lookup again)

                            let infer_expr = &mut self.expr_types[expr_idx as usize];

                            infer_expr.field_or_monomorph_idx = member_index as i32;

                        },

                        Ok(None) => {

                            // Nothing is known about the tuple yet

                            return Ok(());

                        },

                        Err(()) => {

                            return Err(ParseError::new_error_at_span(

                                &ctx.module().source, select_expr.full_span, format!(

                                    "Can only apply tuple element selection to tuples, got a subject of type '{}'",

                                    subject_type.display_name(&ctx.heap)

                                )

                            ));

                        }

                    }

                }

                // If here then we know which member we're accessing. So seek

                // that member in the subject type and apply inference.

                let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;

                let mut member_start_idx = 1;

                for _ in 0..member_index {

                    member_start_idx = InferenceType::find_subtree_end_idx(&subject_type.parts, member_start_idx);

                }

                let (progress_expr, progress_subject) = self.apply_equal2_constraint(

                    ctx, upcast_id, upcast_id, 0, subject_id, member_start_idx

                )?;

                (progress_subject, progress_expr)

            },

        };

                    let field_name = match &expr.kind {

                        SelectKind::StructField(v) => v,

                        SelectKind::TupleMember(_) => unreachable!(), // because we're constructing a polymorph error, and tuple access does not deal with polymorphs

                    };

                            poly_var, field_name.value.as_str(), struct_name