self.visit_expr(ctx, expr_id)?;

                }

                expr_ids.forget();

            }

        }

        self.progress_literal_expr(ctx, id)

    }

    fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let cast_expr = &ctx.heap[id];

        let subject_expr_id = cast_expr.subject;

        self.visit_expr(ctx, subject_expr_id)?;

        self.progress_cast_expr(ctx, id)

    }

    fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        self.insert_initial_call_polymorph_data(ctx, id);

        // By default we set the polymorph idx for calls to 0. If the call ends

        // up not being a polymorphic one, then we will select the default

        // expression types in the type table

        let call_expr = &ctx.heap[id];

        self.expr_types[call_expr.unique_id_in_definition as usize].field_or_monomorph_idx = 0;

        // Visit all arguments

        let expr_ids = self.expr_buffer.start_section_initialized(call_expr.arguments.as_slice());

        for arg_expr_id in expr_ids.iter_copied() {

            self.visit_expr(ctx, arg_expr_id)?;

        }

        expr_ids.forget();

        self.progress_call_expr(ctx, id)

    }

    fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let var_expr = &ctx.heap[id];

        debug_assert!(var_expr.declaration.is_some());

        // Not pretty: if a binding expression, then this is the first time we

        // encounter the variable, so we still need to insert the variable data.

        let declaration = &ctx.heap[var_expr.declaration.unwrap()];

        if !self.var_types.contains_key(&declaration.this)  {

            debug_assert!(declaration.kind == VariableKind::Binding);

            let var_type = self.determine_inference_type_from_parser_type_elements(

                &declaration.parser_type.elements, true

            );

            self.var_types.insert(declaration.this, VarData{

                var_type,

                used_at: vec![upcast_id],

                linked_var: None

            });

        } else {

            let var_data = self.var_types.get_mut(&declaration.this).unwrap();

            var_data.used_at.push(upcast_id);

        }

        self.progress_variable_expr(ctx, id)

    }

}

impl PassTyping {

    #[allow(dead_code)] // used when debug flag at the top of this file is true.

    fn debug_get_display_name(&self, ctx: &Ctx, expr_id: ExpressionId) -> String {

        let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition();

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

        expr_type.display_name(&ctx.heap)

    }

    fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {

        // Keep inferring until we can no longer make any progress

        while !self.expr_queued.is_empty() {

            // Make as much progress as possible without forced integer

            // inference.

            while !self.expr_queued.is_empty() {

                let next_expr_idx = self.expr_queued.pop_front().unwrap();

                self.progress_expr(ctx, next_expr_idx)?;

            }

            // Nothing is queued anymore. However we might have integer literals

            // whose type cannot be inferred. For convenience's sake we'll

            // infer these to be s32.

            for (infer_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {

                let expr_type = &mut infer_expr.expr_type;

                if !expr_type.is_done && expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {

                    // Force integer type to s32

                    expr_type.parts[0] = InferenceTypePart::SInt32;

                    expr_type.is_done = true;

                    // Requeue expression (and its parent, if it exists)

                    self.expr_queued.push_back(infer_expr_idx as i32);

                    if let Some(parent_expr) = ctx.heap[infer_expr.expr_id].parent_expr_id() {

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

                        self.expr_queued.push_back(parent_idx);

                    }

                }

            }

        }

        // Helper for transferring polymorphic variables to concrete types and

        // checking if they're completely specified

        fn inference_type_to_concrete_type(

            ctx: &Ctx, expr_id: ExpressionId, inference: &Vec<InferenceType>,

            first_concrete_part: ConcreteTypePart,

        ) -> Result<ConcreteType, ParseError> {

            // Prepare storage vector

            let mut num_inference_parts = 0;

            for inference_type in inference {

                num_inference_parts += inference_type.parts.len();

            }

            let mut concrete_type = ConcreteType{

                parts: Vec::with_capacity(1 + num_inference_parts),

            };

            concrete_type.parts.push(first_concrete_part);

            // Go through all polymorphic arguments and add them to the concrete

            // types.

            for (poly_idx, poly_type) in inference.iter().enumerate() {

                if !poly_type.is_done {

                    let expr = &ctx.heap[expr_id];

                    let definition = match expr {

                        Expression::Call(expr) => expr.definition,

                        Expression::Literal(expr) => match &expr.value {

                            Literal::Enum(lit) => lit.definition,

                            Literal::Union(lit) => lit.definition,

                            Literal::Struct(lit) => lit.definition,

                            _ => unreachable!()

                        },

                        _ => unreachable!(),

                    };

                    let poly_vars = ctx.heap[definition].poly_vars();

                    return Err(ParseError::new_error_at_span(

                        &ctx.module().source, expr.operation_span(), format!(

                            "could not fully infer the type of polymorphic variable '{}' of this expression (got '{}')",

                            poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)

                        )

                    ));

                }

                poly_type.write_concrete_type(&mut concrete_type);

            }

            Ok(concrete_type)

        }

        // Inference is now done. But we may still have uninferred types. So we

        // check for these.

        for infer_expr in self.expr_types.iter_mut() {

            if !infer_expr.expr_type.is_done {

                let expr = &ctx.heap[infer_expr.expr_id];

                return Err(ParseError::new_error_at_span(

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

                        "could not fully infer the type of this expression (got '{}')",

                        infer_expr.expr_type.display_name(&ctx.heap)

                    )

                ));

            }

            // Expression is fine, check if any extra data is attached

            if infer_expr.extra_data_idx < 0 { continue; }

            // Extra data is attached, perform typechecking and transfer

            // resolved information to the expression

            let extra_data = &self.extra_data[infer_expr.extra_data_idx as usize];

            // Note that only call and literal expressions need full inference.

            // Select expressions also use `extra_data`, but only for temporary

            // storage of the struct type whose field it is selecting.

            match &ctx.heap[extra_data.expr_id] {

                Expression::Call(expr) => {

                    // Check if it is not a builtin function. If not, then

                    // construct the first part of the concrete type.

                    let first_concrete_part = if expr.method == Method::UserFunction {

                        ConcreteTypePart::Function(expr.definition, extra_data.poly_vars.len() as u32)

                    } else if expr.method == Method::UserComponent {

                        ConcreteTypePart::Component(expr.definition, extra_data.poly_vars.len() as u32)

                    } else {

                        // Builtin function

                        continue;

                    };