#[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();