for module_idx in 0..self.modules.len() {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                modules: &mut self.modules,

                module_idx,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

                arch: &self.arch,

            };

            self.pass_typing.queue_module_definitions(&mut ctx, &mut queue);

        };

        while !queue.is_empty() {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                modules: &mut self.modules,

                module_idx: top.root_id.index as usize,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

                arch: &self.arch,

            };

            self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;

        }

        // Rewrite nodes in tree, then prepare for execution of code

        variant: SymbolVariant::Definition(SymbolDefinition{

            defined_in_module: RootId::new_invalid(),

            defined_in_scope: SymbolScope::Global,

            definition_span: InputSpan::new(),

            identifier_span: InputSpan::new(),

            imported_at: None,

            class: DefinitionClass::Function,

            definition_id: procedure_id.upcast(),

        })

    }).unwrap();

    // Insert into type table

}

    () => { false };

}

macro_rules! debug_log {

    ($format:literal) => {

        enabled_debug_print!(false, "types", $format);

    };

    ($format:literal, $($args:expr),*) => {

        enabled_debug_print!(false, "types", $format, $($args),*);

    };

}

use crate::collections::{ScopedBuffer, ScopedSection, DequeSet};

use crate::protocol::ast::*;

use crate::protocol::input_source::ParseError;

use crate::protocol::parser::ModuleCompilationPhase;

use crate::protocol::parser::type_table::*;

use crate::protocol::parser::token_parsing::*;

use super::visitor::{

    BUFFER_INIT_CAP_LARGE,

    BUFFER_INIT_CAP_SMALL,

    Ctx,

};

type VarDataIndex = usize;

pub(crate) struct ResolveQueueElement {

    // Note that using the `definition_id` and the `monomorph_idx` one may

    // query the type table for the full procedure type, thereby retrieving

    // the polymorphic arguments to the procedure.

    pub(crate) root_id: RootId,

    pub(crate) definition_id: DefinitionId,

    pub(crate) reserved_type_id: TypeId,

    pub(crate) reserved_monomorph_index: u32,

}

struct InferenceNode {

    // filled in during type inference

    expr_type: InferenceType,               // result type from expression

    expr_id: ExpressionId,                  // expression that is evaluated

    inference_rule: InferenceRule,          // rule used to infer node type

    parent_index: Option<InferNodeIndex>,   // parent of inference node

    field_index: i32,                       // index of struct field or tuple member

    poly_data_index: PolyDataIndex,         // index to inference data for polymorphic types

    // filled in once type inference is done

    info_type_id: TypeId,

    info_variant: ExpressionInfoVariant,

                    }

                }

                Definition::Enum(_) | Definition::Struct(_) | Definition::Union(_) => None,

            };

            if let Some((first_concrete_part, procedure_id)) = first_concrete_part_and_procedure_id {

                let procedure = &mut ctx.heap[procedure_id];

                let monomorph_index = procedure.monomorphs.len() as u32;

                procedure.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());

                let concrete_type = ConcreteType{ parts: vec![first_concrete_part] };

                let type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, concrete_type, monomorph_index);

                    root_id,

                    definition_id,

                    reserved_type_id: type_id,

                    reserved_monomorph_index: monomorph_index,

                })

            }

        }

        definitions_section.forget();

    }

    pub(crate) fn handle_module_definition(

                )?;

                let (type_id, monomorph_index) = if let Some(type_id) = ctx.types.get_procedure_monomorph_type_id(&definition_id, &signature_type.parts) {

                    // Procedure is already typechecked

                    let monomorph_index = ctx.types.get_monomorph(type_id).variant.as_procedure().monomorph_index;

                    (type_id, monomorph_index)

                } else {

                    // Procedure is not yet typechecked, reserve a TypeID and a monomorph index

                    let procedure_to_check = &mut ctx.heap[procedure_id];

                    let monomorph_index = procedure_to_check.monomorphs.len() as u32;

                    procedure_to_check.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());

                    let type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, signature_type, monomorph_index);

                    (type_id, monomorph_index)

                };

                ExpressionInfoVariant::Procedure(type_id, monomorph_index)

            } else if let Expression::Select(_expr) = expr {

                ExpressionInfoVariant::Select(infer_node.field_index)

            } else {

                ExpressionInfoVariant::Generic

            };

            infer_node.info_type_id = info_type_id;

        }

        // Write the types of the arguments

        let procedure = &ctx.heap[self.procedure_id];

        for parameter_id in procedure.parameters.iter().copied() {

            let mut concrete = ConcreteType::default();

            let var_data = self.var_data.iter().find(|v| v.var_id == parameter_id).unwrap();

            var_data.var_type.write_concrete_type(&mut concrete);

            let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete)?;

            monomorph.argument_types.push(type_id)

        }

        // Determine if we have already assigned type indices to the expressions

        // before (the indices that, for a monomorph, can retrieve the type of

        // the expression).

        let has_type_indices = self.reserved_monomorph_index > 0;

        if has_type_indices {

            // already have indices, so resize and then index into it

            debug_assert!(monomorph.expr_info.is_empty());

            monomorph.expr_info.resize(num_infer_nodes, ExpressionInfo::new_invalid());

            for infer_node in self.infer_nodes.iter() {

                let type_index = ctx.heap[infer_node.expr_id].type_index();

                monomorph.expr_info[type_index as usize] = infer_node.as_expression_info();

            }

        while self_index < self.parts.len() && other_index < other.parts.len() {

            // Retrieve part and flags

            let (self_bits, _) = self.parts[self_index];

            let (other_bits, _) = other.parts[other_index];

            let self_in_use = (self_bits & Self::KEY_IN_USE) != 0;

            let other_in_use = (other_bits & Self::KEY_IN_USE) != 0;

            // Determine ending indices

            let self_end_index = self.find_end_index(self_index);

            let other_end_index = other.find_end_index(other_index);

            if self_in_use == other_in_use {

                if self_in_use {

                    // Both are in use, so both parts should be equal

                    let delta_self = self_end_index - self_index;

                    let delta_other = other_end_index - other_index;

                    if delta_self != delta_other {

                        // Both in use, but not of equal length, so the types

                        // cannot match

                        return false;

                    }

                    for _ in 0..delta_self {