self.expr_types.resize(func_def.num_expressions_in_body as usize, Default::default());

        // Visit parameters

        let section = self.var_buffer.start_section_initialized(func_def.parameters.as_slice());

        for param_id in section.iter_copied() {

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);

            debug_assert!(var_type.is_done, "expected function arguments to be concrete types");

            self.var_types.insert(param_id, VarData::new_local(var_type));

        }

        section.forget();

        // Visit all of the expressions within the body

        let body_stmt_id = ctx.heap[id].body;

        self.visit_block_stmt(ctx, body_stmt_id)

    }

    // Statements

    fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {

        // Transfer statements for traversal

        let block = &ctx.heap[id];

        let section = self.stmt_buffer.start_section_initialized(block.statements.as_slice());

        for stmt_id in section.iter_copied() {

            self.visit_stmt(ctx, stmt_id)?;

        }

        section.forget();

        Ok(())

    }

    fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {

        let memory_stmt = &ctx.heap[id];

        let local = &ctx.heap[memory_stmt.variable];

        let var_type = self.determine_inference_type_from_parser_type_elements(&local.parser_type.elements, true);

        self.var_types.insert(memory_stmt.variable, VarData::new_local(var_type));

        Ok(())

    }

    fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {

        let channel_stmt = &ctx.heap[id];

        let from_local = &ctx.heap[channel_stmt.from];

        let from_var_type = self.determine_inference_type_from_parser_type_elements(&from_local.parser_type.elements, true);

        self.var_types.insert(from_local.this, VarData::new_channel(from_var_type, channel_stmt.to));

        let to_local = &ctx.heap[channel_stmt.to];

        let to_var_type = self.determine_inference_type_from_parser_type_elements(&to_local.parser_type.elements, true);

        self.var_types.insert(to_local.this, VarData::new_channel(to_var_type, channel_stmt.from));

        Ok(())

    }

    fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {

        let labeled_stmt = &ctx.heap[id];

        let substmt_id = labeled_stmt.body;

        self.visit_stmt(ctx, substmt_id)

    }

    fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {

        let if_stmt = &ctx.heap[id];

        let true_body_id = if_stmt.true_body;

        let false_body_id = if_stmt.false_body;

        let test_expr_id = if_stmt.test;

        self.visit_expr(ctx, test_expr_id)?;

        self.visit_block_stmt(ctx, true_body_id)?;

        if let Some(false_body_id) = false_body_id {

            self.visit_block_stmt(ctx, false_body_id)?;

        }

        Ok(())

    }

    fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {

        let while_stmt = &ctx.heap[id];

        let body_id = while_stmt.body;

        let test_expr_id = while_stmt.test;

        self.visit_expr(ctx, test_expr_id)?;

        self.visit_block_stmt(ctx, body_id)?;

        Ok(())

    }

    fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {

        let sync_stmt = &ctx.heap[id];

        let body_id = sync_stmt.body;

        self.visit_block_stmt(ctx, body_id)

    }

    fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {

        let fork_stmt = &ctx.heap[id];

        let left_body_id = fork_stmt.left_body;

        let right_body_id = fork_stmt.right_body;

        self.visit_block_stmt(ctx, left_body_id)?;

        if let Some(right_body_id) = right_body_id {

            self.visit_block_stmt(ctx, right_body_id)?;

        }

        Ok(())

    }

    fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {

        let return_stmt = &ctx.heap[id];

        debug_assert_eq!(return_stmt.expressions.len(), 1);

        let expr_id = return_stmt.expressions[0];

        self.visit_expr(ctx, expr_id)

    }

    fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {

        let new_stmt = &ctx.heap[id];

        let call_expr_id = new_stmt.expression;

        self.visit_call_expr(ctx, call_expr_id)

    }

    fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {

        let expr_stmt = &ctx.heap[id];

        let subexpr_id = expr_stmt.expression;

        self.visit_expr(ctx, subexpr_id)

    }

    // Expressions

    fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let assign_expr = &ctx.heap[id];

        let left_expr_id = assign_expr.left;

        let right_expr_id = assign_expr.right;

        self.visit_expr(ctx, left_expr_id)?;

        self.visit_expr(ctx, right_expr_id)?;

        self.progress_assignment_expr(ctx, id)

    }

    fn visit_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let binding_expr = &ctx.heap[id];

        let bound_to_id = binding_expr.bound_to;

        let bound_from_id = binding_expr.bound_from;

        self.visit_expr(ctx, bound_to_id)?;

        self.visit_expr(ctx, bound_from_id)?;

        self.progress_binding_expr(ctx, id)

    }

    fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let conditional_expr = &ctx.heap[id];

        let test_expr_id = conditional_expr.test;

        let true_expr_id = conditional_expr.true_expression;

        let false_expr_id = conditional_expr.false_expression;

        self.visit_expr(ctx, test_expr_id)?;

        self.visit_expr(ctx, true_expr_id)?;

        self.visit_expr(ctx, false_expr_id)?;

        self.progress_conditional_expr(ctx, id)

    }

    fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let binary_expr = &ctx.heap[id];

        let lhs_expr_id = binary_expr.left;

        let rhs_expr_id = binary_expr.right;

        self.visit_expr(ctx, lhs_expr_id)?;

        self.visit_expr(ctx, rhs_expr_id)?;

        self.progress_binary_expr(ctx, id)

    }

    fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let unary_expr = &ctx.heap[id];

        let arg_expr_id = unary_expr.expression;

        self.visit_expr(ctx, arg_expr_id)?;

        self.progress_unary_expr(ctx, id)

    }

    fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let indexing_expr = &ctx.heap[id];

        let subject_expr_id = indexing_expr.subject;

        let index_expr_id = indexing_expr.index;

        self.visit_expr(ctx, subject_expr_id)?;

        self.visit_expr(ctx, index_expr_id)?;

        self.progress_indexing_expr(ctx, id)

    }

    fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let slicing_expr = &ctx.heap[id];

        let subject_expr_id = slicing_expr.subject;

        let from_expr_id = slicing_expr.from_index;

        let to_expr_id = slicing_expr.to_index;

        self.visit_expr(ctx, subject_expr_id)?;

        self.visit_expr(ctx, from_expr_id)?;

        self.visit_expr(ctx, to_expr_id)?;

        self.progress_slicing_expr(ctx, id)

    }

    fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let select_expr = &ctx.heap[id];

        let subject_expr_id = select_expr.subject;

        self.visit_expr(ctx, subject_expr_id)?;

        self.progress_select_expr(ctx, id)

    }

    fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let literal_expr = &ctx.heap[id];

        match &literal_expr.value {

            Literal::Null | Literal::False | Literal::True |

            Literal::Integer(_) | Literal::Character(_) | Literal::String(_) => {

                // No subexpressions

            },

            Literal::Struct(literal) => {

                let mut expr_ids = self.expr_buffer.start_section();

                for field in &literal.fields {

                    expr_ids.push(field.value);

                }

                self.insert_initial_struct_polymorph_data(ctx, id);

                for expr_id in expr_ids.iter_copied() {

                    self.visit_expr(ctx, expr_id)?;

                }

                expr_ids.forget();

            },

            Literal::Enum(_) => {

                // Enumerations do not carry any subexpressions, but may still

                // have a user-defined polymorphic marker variable. For this 

                // reason we may still have to apply inference to this 

                // polymorphic variable

                self.insert_initial_enum_polymorph_data(ctx, id);

            },

            Literal::Union(literal) => {

                // May carry subexpressions and polymorphic arguments

                let expr_ids = self.expr_buffer.start_section_initialized(literal.values.as_slice());

                self.insert_initial_union_polymorph_data(ctx, id);

                for expr_id in expr_ids.iter_copied() {

                    self.visit_expr(ctx, expr_id)?;

                }

                expr_ids.forget();

            },

            Literal::Array(expressions) | Literal::Tuple(expressions) => {

                let expr_ids = self.expr_buffer.start_section_initialized(expressions.as_slice());

                for expr_id in expr_ids.iter_copied() {

                    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;

                    };

                    let definition_id = expr.definition;

                    let concrete_type = inference_type_to_concrete_type(

                        ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part

                    )?;

                    match ctx.types.get_procedure_monomorph_index(&definition_id, &concrete_type.parts) {

                        Some(reserved_idx) => {

                            // Already typechecked, or already put into the resolve queue

                            infer_expr.field_or_monomorph_idx = reserved_idx;

                        },

                        None => {

                            // Not typechecked yet, so add an entry in the queue

                            let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, concrete_type);

                            infer_expr.field_or_monomorph_idx = reserved_idx;

                            queue.push(ResolveQueueElement {

                                root_id: ctx.heap[definition_id].defined_in(),

                                definition_id,

                                reserved_monomorph_idx: reserved_idx,

                            });

                        }

                    }

                },

                Expression::Literal(expr) => {

                    let definition_id = match &expr.value {

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

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

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

                        _ => unreachable!(),

                    };

                    let first_concrete_part = ConcreteTypePart::Instance(definition_id, extra_data.poly_vars.len() as u32);

                    let concrete_type = inference_type_to_concrete_type(

                        ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part

                    )?;

                    let mono_index = ctx.types.add_data_monomorph(ctx.modules, ctx.heap, ctx.arch, definition_id, concrete_type)?;

                    infer_expr.field_or_monomorph_idx = mono_index;

                },

                Expression::Select(_) => {

                    debug_assert!(infer_expr.field_or_monomorph_idx >= 0);

                },

                _ => {

                    unreachable!("handling extra data for expression {:?}", &ctx.heap[extra_data.expr_id]);

                }

            }

        }

        // Every expression checked, and new monomorphs are queued. Transfer the

        // expression information to the type table.

        let procedure_arguments = match &self.definition_type {

            DefinitionType::Component(id) => {

                let definition = &ctx.heap[*id];

                &definition.parameters

            },

            DefinitionType::Function(id) => {

                let definition = &ctx.heap[*id];

                &definition.parameters

            },

        };

        let target = ctx.types.get_procedure_monomorph_mut(self.reserved_idx);

        debug_assert!(target.arg_types.is_empty()); // makes sure we never queue a procedure's type inferencing twice

        debug_assert!(target.expr_data.is_empty());

        // - Write the arguments to the procedure

        target.arg_types.reserve(procedure_arguments.len());

        for argument_id in procedure_arguments {

            let mut concrete = ConcreteType::default();

            let argument_type = self.var_types.get(argument_id).unwrap();

            argument_type.var_type.write_concrete_type(&mut concrete);

            target.arg_types.push(concrete);

        }

        // - Write the expression data

        target.expr_data.reserve(self.expr_types.len());

        for infer_expr in self.expr_types.iter() {

            let mut concrete = ConcreteType::default();

            infer_expr.expr_type.write_concrete_type(&mut concrete);

            target.expr_data.push(MonomorphExpression{

                expr_type: concrete,

                field_or_monomorph_idx: infer_expr.field_or_monomorph_idx

            });

        }

        Ok(())

    }

    fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {

        let id = self.expr_types[idx as usize].expr_id;

        match &ctx.heap[id] {

            Expression::Assignment(expr) => {

                let id = expr.this;

                self.progress_assignment_expr(ctx, id)

            },

            Expression::Binding(expr) => {

                let id = expr.this;

                self.progress_binding_expr(ctx, id)

            },

            Expression::Conditional(expr) => {

                let id = expr.this;

                self.progress_conditional_expr(ctx, id)

            },

            Expression::Binary(expr) => {

                let id = expr.this;

                self.progress_binary_expr(ctx, id)

            },

            Expression::Unary(expr) => {

                let id = expr.this;

                self.progress_unary_expr(ctx, id)

            },

            Expression::Indexing(expr) => {

                let id = expr.this;

                self.progress_indexing_expr(ctx, id)

            },

            Expression::Slicing(expr) => {

                let id = expr.this;

                self.progress_slicing_expr(ctx, id)

            },

            Expression::Select(expr) => {

                let id = expr.this;

                self.progress_select_expr(ctx, id)

            },

            Expression::Literal(expr) => {

                let id = expr.this;

                self.progress_literal_expr(ctx, id)

            },

            Expression::Cast(expr) => {

                let id = expr.this;

                self.progress_cast_expr(ctx, id)

            },

            Expression::Call(expr) => {

                let id = expr.this;

                self.progress_call_expr(ctx, id)

            },

            Expression::Variable(expr) => {

                let id = expr.this;

                self.progress_variable_expr(ctx, id)

            }

        }

    }

    fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError> {

        use AssignmentOperator as AO;

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let arg1_expr_id = expr.left;

        let arg2_expr_id = expr.right;

        debug_log!("Assignment expr '{:?}': {}", expr.operation, upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Arg1 type: {}", self.debug_get_display_name(ctx, arg1_expr_id));

        debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_expr_id));

        debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));

        // Assignment does not return anything (it operates like a statement)

        let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &VOID_TEMPLATE)?;

        // Apply forced constraint to LHS value

        let progress_forced = match expr.operation {

            AO::Set =>

                false,

            AO::Concatenated =>

                self.apply_template_constraint(ctx, arg1_expr_id, &ARRAYLIKE_TEMPLATE)?,

            AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>

                self.apply_template_constraint(ctx, arg1_expr_id, &NUMBERLIKE_TEMPLATE)?,

            AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |

            AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>

                self.apply_template_constraint(ctx, arg1_expr_id, &INTEGERLIKE_TEMPLATE)?,

        };

        let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(

            ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0

        )?;

        debug_log!(" * After:");

        debug_log!("   - Arg1 type [{}]: {}", progress_forced || progress_arg1, self.debug_get_display_name(ctx, arg1_expr_id));

        debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.debug_get_display_name(ctx, arg2_expr_id));

        debug_log!("   - Expr type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_forced || progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }

        if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }

        Ok(())

    }

    fn progress_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> Result<(), ParseError> {

        let upcast_id = id.upcast();

        let binding_expr = &ctx.heap[id];

        let bound_from_id = binding_expr.bound_from;

        let bound_to_id = binding_expr.bound_to;

        // Output is always a boolean. The two arguments should be of equal

        // type.

        let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;

        let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, bound_from_id, 0, bound_to_id, 0)?;

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_from { self.queue_expr(ctx, bound_from_id); }

        if progress_to { self.queue_expr(ctx, bound_to_id); }

        Ok(())

    }

    fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError> {

        // Note: test expression type is already enforced

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let arg1_expr_id = expr.true_expression;

        let arg2_expr_id = expr.false_expression;

        debug_log!("Conditional expr: {}", upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Arg1 type: {}", self.debug_get_display_name(ctx, arg1_expr_id));

        debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_expr_id));

        debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));

        // I keep confusing myself: this applies equality of types between the

        // condition branches' types, and the result from the conditional

        // expression, because the result from the conditional is one of the

        // branches.

        let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(

            ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0

        )?;

        debug_log!(" * After:");

        debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.debug_get_display_name(ctx, arg1_expr_id));

        debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.debug_get_display_name(ctx, arg2_expr_id));

        debug_log!("   - Expr type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        if progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }

        if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }

        Ok(())

    }

    fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError> {

        // Note: our expression type might be fixed by our parent, but we still

        // need to make sure it matches the type associated with our operation.

        use BinaryOperator as BO;

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let arg1_id = expr.left;

        let arg2_id = expr.right;

        debug_log!("Binary expr '{:?}': {}", expr.operation, upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Arg1 type: {}", self.debug_get_display_name(ctx, arg1_id));

        debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_id));

        debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));

        let (progress_expr, progress_arg1, progress_arg2) = match expr.operation {

            BO::Concatenate => {

                // Two cases: if one of the arguments or the output type is a

                // string, then all must be strings. Otherwise the arguments

                // must be arraylike and the output will be a array.

                let (expr_is_str, expr_is_not_str) = self.type_is_certainly_or_certainly_not_string(ctx, upcast_id);

                let (arg1_is_str, arg1_is_not_str) = self.type_is_certainly_or_certainly_not_string(ctx, arg1_id);

                let (arg2_is_str, arg2_is_not_str) = self.type_is_certainly_or_certainly_not_string(ctx, arg2_id);

                let someone_is_str = expr_is_str || arg1_is_str || arg2_is_str;

                let someone_is_not_str = expr_is_not_str || arg1_is_not_str || arg2_is_not_str;

                // Note: this statement is an expression returning the progression bools

                if someone_is_str {

                    // One of the arguments is a string, then all must be strings

                    self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?

                } else {

                    let progress_expr = if someone_is_not_str {

                        // Output must be a normal array

                        self.apply_template_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?

                    } else {

                        // Output may still be anything

                        self.apply_template_constraint(ctx, upcast_id, &ARRAYLIKE_TEMPLATE)?

                    };

                    let progress_arg1 = self.apply_template_constraint(ctx, arg1_id, &ARRAYLIKE_TEMPLATE)?;

                    let progress_arg2 = self.apply_template_constraint(ctx, arg2_id, &ARRAYLIKE_TEMPLATE)?;

                    // If they're all arraylike, then we want the subtype to match

                    let (subtype_expr, subtype_arg1, subtype_arg2) =

                        self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 1)?;

                    (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)