pub(crate) fn write_ast<W: IOWrite>(&mut self, w: &mut W, heap: &Heap) {

        for root_id in heap.protocol_descriptions.iter().map(|v| v.this) {

            self.write_module(heap, root_id);

            w.write_all(self.buffer.as_bytes()).expect("flush buffer");

            self.buffer.clear();

        }

    }

    //--------------------------------------------------------------------------

    // Top-level module writing

    //--------------------------------------------------------------------------

    fn write_module(&mut self, heap: &Heap, root_id: RootId) {

        self.kv(0).with_id(PREFIX_ROOT_ID, root_id.index)

            .with_s_key("Module");

        let root = &heap[root_id];

        self.kv(1).with_s_key("Pragmas");

        for pragma_id in &root.pragmas {

            self.write_pragma(heap, *pragma_id, 2);

        }

        self.kv(1).with_s_key("Imports");

        for import_id in &root.imports {

            self.write_import(heap, *import_id, 2);

        }

        self.kv(1).with_s_key("Definitions");

        for def_id in &root.definitions {

            self.write_definition(heap, *def_id, 2);

        }

    }

    fn write_pragma(&mut self, heap: &Heap, pragma_id: PragmaId, indent: usize) {

        match &heap[pragma_id] {

            Pragma::Version(pragma) => {

                self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)

                    .with_s_key("PragmaVersion")

                    .with_disp_val(&pragma.version);

            },

            Pragma::Module(pragma) => {

                self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)

                    .with_s_key("PragmaModule")

                    .with_ascii_val(&pragma.value);

            }

        }

    }

    fn write_import(&mut self, heap: &Heap, import_id: ImportId, indent: usize) {

        let import = &heap[import_id];

        let indent2 = indent + 1;

        match import {

            Import::Module(import) => {

                self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)

                    .with_s_key("ImportModule");

                self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);

                self.kv(indent2).with_s_key("Alias").with_ascii_val(&import.alias.value);

                self.kv(indent2).with_s_key("Target")

                    .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));

            },

            Import::Symbols(import) => {

                self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)

                    .with_s_key("ImportSymbol");

                self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);

                self.kv(indent2).with_s_key("Target")

                    .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));

                self.kv(indent2).with_s_key("Symbols");

                let indent3 = indent2 + 1;

                let indent4 = indent3 + 1;

                for symbol in &import.symbols {

                    self.kv(indent3).with_s_key("AliasedSymbol");

                    self.kv(indent4).with_s_key("Name").with_ascii_val(&symbol.name.value);

                    self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias.value);

                    self.kv(indent4).with_s_key("Definition")

                        .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));

                }

            }

        }

    }

    //--------------------------------------------------------------------------

    // Top-level definition writing

    //--------------------------------------------------------------------------

    fn write_definition(&mut self, heap: &Heap, def_id: DefinitionId, indent: usize) {

        self.cur_definition = Some(def_id);

        let indent2 = indent + 1;

        let indent3 = indent2 + 1;

        let indent4 = indent3 + 1;

        match &heap[def_id] {

            Definition::Enum(def) => {

                self.kv(indent).with_id(PREFIX_ENUM_ID, def.this.0.index)

                    .with_s_key("DefinitionEnum");

                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);

                for poly_var_id in &def.poly_vars {

                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);

                }

                self.kv(indent2).with_s_key("Variants");

                for variant in &def.variants {

                    self.kv(indent3).with_s_key("Variant");

                    self.kv(indent4).with_s_key("Name")

                        .with_ascii_val(&variant.identifier.value);

                }

            },

            Definition::Function(def) => {

                self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)

                    .with_s_key("DefinitionFunction");

                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);

                for poly_var_id in &def.poly_vars {

                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);

                }

                self.kv(indent2).with_s_key("ReturnParserType").with_custom_val(|s| write_parser_type(s, heap, &heap[def.return_type]));

                self.kv(indent2).with_s_key("Parameters");

                for param_id in &def.parameters {

                    self.write_parameter(heap, *param_id, indent3);

                }

                self.kv(indent2).with_s_key("Body");

                self.write_stmt(heap, def.body, indent3);

            },

            Definition::Component(def) => {

                self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)

                    .with_s_key("DefinitionComponent");

                self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);

                self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);

                self.kv(indent2).with_s_key("PolymorphicVariables");

                for poly_var_id in &def.poly_vars {

                    self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);

                }

                self.kv(indent2).with_s_key("Parameters");

                for param_id in &def.parameters {

                    self.write_parameter(heap, *param_id, indent3)

                }

                self.kv(indent2).with_s_key("Body");

                self.write_stmt(heap, def.body, indent3);

            }

        }

    }

    fn write_parameter(&mut self, heap: &Heap, param_id: ParameterId, indent: usize) {

        let indent2 = indent + 1;

        let param = &heap[param_id];

        self.kv(indent).with_id(PREFIX_PARAMETER_ID, param_id.0.index)

            .with_s_key("Parameter");

        self.kv(indent2).with_s_key("Name").with_ascii_val(&param.identifier.value);

        self.kv(indent2).with_s_key("ParserType").with_custom_val(|w| write_parser_type(w, heap, &heap[param.parser_type]));

    }

    fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {

        let stmt = &heap[stmt_id];

        let indent2 = indent + 1;

        let indent3 = indent2 + 1;

        match stmt {

            Statement::Block(stmt) => {

                self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.index)

                    .with_s_key("Block");

                for stmt_id in &stmt.statements {

                    self.write_stmt(heap, *stmt_id, indent2);

                }

            },

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Channel(stmt) => {

                        self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.index)

                            .with_s_key("LocalChannel");

                        self.kv(indent2).with_s_key("From");

                        self.write_local(heap, stmt.from, indent3);

                        self.kv(indent2).with_s_key("To");

                        self.write_local(heap, stmt.to, indent3);

                        self.kv(indent2).with_s_key("Next")

                            .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));

                    },

                    LocalStatement::Memory(stmt) => {

                        self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.index)

                            .with_s_key("LocalMemory");

                        self.kv(indent2).with_s_key("Variable");

                        self.write_local(heap, stmt.variable, indent3);

                        self.kv(indent2).with_s_key("Next")

                            .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));

                    }

                }

            },

            Statement::Skip(stmt) => {

                self.kv(indent).with_id(PREFIX_SKIP_STMT_ID, stmt.this.0.index)

                    .with_s_key("Skip");

                self.kv(indent2).with_s_key("Next")

            }

            let module_root_id = self.modules[module_index].root_id;

            let import_id = {

                let root = &self.heap[module_root_id];

                if import_index >= root.imports.len() {

                    module_index += 1;

                    import_index = 0;

                    continue

                }

                root.imports[import_index]

            };

            let import = &mut self.heap[import_id];

            match import {

                Import::Module(import) => {

                    debug_assert!(import.module_id.is_none(), "module import already resolved");

                    let target_module_id = self.symbol_table.resolve_module(&import.module_name)

                        .expect("module import is resolved by symbol table");

                    import.module_id = Some(target_module_id)

                },

                Import::Symbols(import) => {

                    debug_assert!(import.module_id.is_none(), "module of symbol import already resolved");

                    let target_module_id = self.symbol_table.resolve_module(&import.module_name)

                        .expect("symbol import's module is resolved by symbol table");

                    import.module_id = Some(target_module_id);

                    for symbol in &mut import.symbols {

                        debug_assert!(symbol.definition_id.is_none(), "symbol import already resolved");

                        let (_, target_definition_id) = self.symbol_table.resolve_identifier(module_root_id, &symbol.alias)

                            .expect("symbol import is resolved by symbol table")

                            .as_definition()

                            .expect("symbol import does not resolve to namespace symbol");

                        symbol.definition_id = Some(target_definition_id);

                    }

                }

            }

            import_index += 1;

        }

        // All imports in the AST are now annotated. We now use the symbol table

        // to construct the type table.

        let mut type_ctx = TypeCtx::new(&self.symbol_table, &mut self.heap, &self.modules);

        self.type_table.build_base_types(&mut type_ctx)?;

        Ok(())

    }

    pub fn parse(&mut self) -> Result<(), ParseError> {

        self.resolve_symbols_and_types()?;

        // Validate and link all modules

        let mut visit = ValidityAndLinkerVisitor::new();

        for module in &self.modules {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                module,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

            visit.visit_module(&mut ctx)?;

        }

        // Perform typechecking on all modules

        let mut visit = TypeResolvingVisitor::new();

        let mut queue = ResolveQueue::new();

        for module in &self.modules {

            let ctx = visitor::Ctx{

                heap: &mut self.heap,

                module,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

            TypeResolvingVisitor::queue_module_definitions(&ctx, &mut queue);   

        };

        while !queue.is_empty() {

            let top = queue.pop().unwrap();

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                module: &self.modules[top.root_id.index as usize],

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

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

        }

        // Perform remaining steps

        // TODO: Phase out at some point

        for module in &self.modules {

            let root_id = module.root_id;

            if let Err((position, message)) = Self::parse_inner(&mut self.heap, root_id) {

                return Err(ParseError::new_error(&self.modules[0].source, position, &message))

            }

        }

        Ok(())

    }

    pub fn parse_inner(h: &mut Heap, pd: RootId) -> VisitorResult {

        // TODO: @cleanup, slowly phasing out old compiler

        // NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;

        // ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;

        // FunctionStatementReturns::new().visit_protocol_description(h, pd)?;

        // ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;

        // CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;

        // BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;

        // LinkCallExpressions::new().visit_protocol_description(h, pd)?;

        // BuildScope::new().visit_protocol_description(h, pd)?;

        // ResolveVariables::new().visit_protocol_description(h, pd)?;

        LinkStatements::new().visit_protocol_description(h, pd)?;

        // BuildLabels::new().visit_protocol_description(h, pd)?;

        // ResolveLabels::new().visit_protocol_description(h, pd)?;

        AssignableExpressions::new().visit_protocol_description(h, pd)?;

        IndexableExpressions::new().visit_protocol_description(h, pd)?;

        SelectableExpressions::new().visit_protocol_description(h, pd)?;

        Ok(())

    }

}

                    // Builtin types or types that do not require recursion

                    continue 'resolve_loop;

                },

                PTV::Array(subtype_id) |

                PTV::Input(subtype_id) |

                PTV::Output(subtype_id) => {

                    // Requires recursing

                    self.parser_type_buffer.push(*subtype_id);

                    continue 'resolve_loop;

                },

                PTV::Symbolic(symbolic) => {

                    // Retrieve poly_vars from function/component definition to

                    // match against.

                    let (definition_id, poly_vars) = match self.def_type {

                        DefinitionType::None => unreachable!(),

                        DefinitionType::Primitive(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                        DefinitionType::Composite(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                        DefinitionType::Function(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                    };

                    let mut symbolic_variant = None;

                    for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {

                        if symbolic.identifier.matches_identifier(poly_var) {

                            // Type refers to a polymorphic variable.

                            // TODO: @hkt Maybe allow higher-kinded types?

                            if symbolic.identifier.get_poly_args().is_some() {

                                return Err(ParseError::new_error(

                                    &ctx.module.source, symbolic.identifier.position,

                                    "Polymorphic arguments to a polymorphic variable (higher-kinded types) are not allowed (yet)"

                                ));

                            }

                            symbolic_variant = Some(SymbolicParserTypeVariant::PolyArg(definition_id, poly_var_idx));

                        }

                    }

                    if let Some(symbolic_variant) = symbolic_variant {

                        // Identifier points to a polymorphic argument

                        (symbolic.identifier.position, symbolic_variant, 0)

                    } else {

                        // Must be a user-defined type, otherwise an error

                        let (found_type, ident_iter) = find_type_definition(

                            &ctx.symbols, &ctx.types, ctx.module.root_id, &symbolic.identifier

                        ).as_parse_error(&ctx.module.source)?;

                        // TODO: @function_ptrs: Allow function pointers at some

                        //  point in the future

                        if found_type.definition.type_class().is_proc_type() {

                            return Err(ParseError::new_error(

                                &ctx.module.source, symbolic.identifier.position,

                                &format!(

                                    "This identifier points to a {} type, expected a datatype",

                                    found_type.definition.type_class()

                                )

                            ));

                        }

                        // If the type is polymorphic then we have two cases: if

                        // the programmer did not specify the polyargs then we

                        // assume we're going to infer all of them. Otherwise we

                        // make sure that they match in count.

                        let (_, poly_args) = ident_iter.prev().unwrap();

                        let num_to_infer = match_polymorphic_args_to_vars(

                            found_type, poly_args, symbolic.identifier.position

                        ).as_parse_error(&ctx.heap, &ctx.module.source)?;

                        (

                            symbolic.identifier.position,

                            SymbolicParserTypeVariant::Definition(found_type.ast_definition),

                            num_to_infer

                        )

                    }

                }

            };

            // If here then type is symbolic, perform a mutable borrow (and do

            // some rust shenanigans) to set the required information.

            for _ in 0..num_inferred_to_allocate {

                // TODO: @hack, not very user friendly to manually allocate

                //  `inferred` ParserTypes with the InputPosition of the

                //  symbolic type's identifier.

                // We reuse the `parser_type_buffer` to temporarily store these

                // and we'll take them out later

                self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType{

                    this,

                    pos: symbolic_pos,

                    variant: ParserTypeVariant::Inferred,

                }));

            }

            if let PTV::Symbolic(symbolic) = &mut ctx.heap[parser_type_id].variant {

                if num_inferred_to_allocate != 0 {

                    symbolic.poly_args2.reserve(num_inferred_to_allocate);

                    for _ in 0..num_inferred_to_allocate {

                        symbolic.poly_args2.push(self.parser_type_buffer.pop().unwrap());

                    }

                } else if !symbolic.identifier.poly_args.is_empty() {

                }

                symbolic.variant = Some(symbolic_variant);

            } else {

                unreachable!();

            }

        }

        Ok(())

    }

    //--------------------------------------------------------------------------

    // Utilities

    //--------------------------------------------------------------------------

    /// Adds a local variable to the current scope. It will also annotate the

    /// `Local` in the AST with its relative position in the block.

    fn checked_local_add(&mut self, ctx: &mut Ctx, relative_pos: u32, id: LocalId) -> Result<(), ParseError> {

        debug_assert!(self.cur_scope.is_some());

        // Make sure we do not conflict with any global symbols

        {

            let ident = &ctx.heap[id].identifier;

            if let Some(symbol) = ctx.symbols.resolve_symbol(ctx.module.root_id, &ident.value) {

                return Err(

                    ParseError::new_error(&ctx.module.source, ident.position, "Local variable declaration conflicts with symbol")

                        .with_postfixed_info(&ctx.module.source, symbol.position, "Conflicting symbol is found here")

                );

            }

        }

        let local = &mut ctx.heap[id];

        local.relative_pos_in_block = relative_pos;

        // Make sure we do not shadow any variables in any of the scopes. Note

        // that variables in parent scopes may be declared later

        let local = &ctx.heap[id];

        let mut scope = self.cur_scope.as_ref().unwrap();

        let mut local_relative_pos = self.relative_pos_in_block;

        loop {

            debug_assert!(scope.is_block(), "scope is not a block");

            let block = &ctx.heap[scope.to_block()];

            for other_local_id in &block.locals {

                let other_local = &ctx.heap[*other_local_id];

                // Position check in case another variable with the same name

                // is defined in a higher-level scope, but later than the scope

                // in which the current variable resides.

                if local.this != *other_local_id &&

                    local_relative_pos >= other_local.relative_pos_in_block &&

                    local.identifier == other_local.identifier {

                    // Collision within this scope

                    return Err(

                        ParseError::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable")

                            .with_postfixed_info(&ctx.module.source, other_local.position, "Previous variable is found here")

                    );

                }

            }

            // Current scope is fine, move to parent scope if any

            debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");

            scope = block.parent_scope.as_ref().unwrap();

            if let Scope::Definition(definition_id) = scope {

                // At outer scope, check parameters of function/component

                for parameter_id in ctx.heap[*definition_id].parameters() {

                    let parameter = &ctx.heap[*parameter_id];

                    if local.identifier == parameter.identifier {

                        return Err(

                            ParseError::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter")

                                .with_postfixed_info(&ctx.module.source, parameter.position, "Parameter definition is found here")

                        );

                    }

                }

                break;

            }

            // If here, then we are dealing with a block-like parent block

            local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;

        }

        // No collisions at all

        let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];

        block.locals.push(id);

        Ok(())

    }

    /// Finds a variable in the visitor's scope that must appear before the

    /// specified relative position within that block.

    fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier) -> Result<VariableId, ParseError> {

        debug_assert!(self.cur_scope.is_some());

        debug_assert!(identifier.parts.len() == 1, "implement namespaced seeking of target associated with identifier");

        // TODO: May still refer to an alias of a global symbol using a single

        //  identifier in the namespace.

        // No need to use iterator over namespaces if here

        }

        v.push(']');

        v

    }

}

//------------------------------------------------------------------------------

// Generic utilities

//------------------------------------------------------------------------------

fn has_equal_num_monomorphs<'a>(ctx: TestCtx<'a>, num: usize, definition_id: DefinitionId) -> (bool, usize) {

    let type_def = ctx.types.get_base_definition(&definition_id).unwrap();

    let num_on_type = type_def.monomorphs.len();

    (num_on_type == num, num_on_type)

}

fn has_monomorph<'a>(ctx: TestCtx<'a>, definition_id: DefinitionId, serialized_monomorph: &str) -> (bool, String) {

    let type_def = ctx.types.get_base_definition(&definition_id).unwrap();

    let mut full_buffer = String::new();

    let mut has_match = false;

    full_buffer.push('[');

    for (monomorph_idx, monomorph) in type_def.monomorphs.iter().enumerate() {

        let mut buffer = String::new();

        for (element_idx, monomorph_element) in monomorph.iter().enumerate() {

            if element_idx != 0 { buffer.push(';'); }

            serialize_concrete_type(&mut buffer, ctx.heap, definition_id, monomorph_element);

        }

        if buffer == serialized_monomorph {

            // Found an exact match

            has_match = true;

        }

        if monomorph_idx != 0 {

            full_buffer.push_str(", ");

        }

        full_buffer.push('"');

        full_buffer.push_str(&buffer);

        full_buffer.push('"');

    }

    full_buffer.push(']');

    (has_match, full_buffer)

}

fn serialize_parser_type(buffer: &mut String, heap: &Heap, id: ParserTypeId) {

    use ParserTypeVariant as PTV;

    let p = &heap[id];

    match &p.variant {

        PTV::Message => buffer.push_str("msg"),

        PTV::Bool => buffer.push_str("bool"),

        PTV::Byte => buffer.push_str("byte"),

        PTV::Short => buffer.push_str("short"),

        PTV::Int => buffer.push_str("int"),

        PTV::Long => buffer.push_str("long"),

        PTV::String => buffer.push_str("string"),

        PTV::IntegerLiteral => buffer.push_str("intlit"),

        PTV::Inferred => buffer.push_str("auto"),

        PTV::Array(sub_id) => {

            serialize_parser_type(buffer, heap, *sub_id);

            buffer.push_str("[]");

        },

        PTV::Input(sub_id) => {

            buffer.push_str("in<");

            serialize_parser_type(buffer, heap, *sub_id);

            buffer.push('>');

        },

        PTV::Output(sub_id) => {

            buffer.push_str("out<");

            serialize_parser_type(buffer, heap, *sub_id);

            buffer.push('>');

        },

        PTV::Symbolic(symbolic) => {

            buffer.push_str(&String::from_utf8_lossy(&symbolic.identifier.value));

            if symbolic.poly_args2.len() > 0 {

                buffer.push('<');

                for (poly_idx, poly_arg) in symbolic.poly_args2.iter().enumerate() {

                    if poly_idx != 0 { buffer.push(','); }

                    serialize_parser_type(buffer, heap, *poly_arg);

                }

                buffer.push('>');

            }

        }

    }

}

fn serialize_concrete_type(buffer: &mut String, heap: &Heap, def: DefinitionId, concrete: &ConcreteType) {

    // Retrieve polymorphic variables, if present (since we're dealing with a 

    // concrete type we only expect procedure types)

    let poly_vars = match &heap[def] {

        Definition::Function(definition) => &definition.poly_vars,

        Definition::Component(definition) => &definition.poly_vars,

        Definition::Struct(definition) => &definition.poly_vars,

        _ => unreachable!("Error in testing utility: unexpected type for concrete type serialization"),

    };

    fn serialize_recursive(

        buffer: &mut String, heap: &Heap, poly_vars: &Vec<Identifier>, concrete: &ConcreteType, mut idx: usize

    ) -> usize {

        use ConcreteTypePart as CTP;

        let part = &concrete.parts[idx];

        match part {

            CTP::Marker(poly_idx) => {

                buffer.push_str(&String::from_utf8_lossy(&poly_vars[*poly_idx].value));

            },

            CTP::Void => buffer.push_str("void"),

            CTP::Message => buffer.push_str("msg"),

            CTP::Bool => buffer.push_str("bool"),

            CTP::Byte => buffer.push_str("byte"),

            CTP::Short => buffer.push_str("short"),

            CTP::Int => buffer.push_str("int"),

            CTP::Long => buffer.push_str("long"),

            CTP::String => buffer.push_str("string"),

            CTP::Array => {

                idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);

                buffer.push_str("[]");

                idx += 1;

            },

            CTP::Slice => {

                idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);

                buffer.push_str("[..]");

                idx += 1;

            },

            CTP::Input => {

                buffer.push_str("in<");

                idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);

                buffer.push('>');

                idx += 1;

            },

            CTP::Output => {

                buffer.push_str("out<");

                idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);

                buffer.push('>');

                idx += 1

            },

            CTP::Instance(definition_id, num_sub) => {

                let definition_name = heap[*definition_id].identifier();

                buffer.push_str(&String::from_utf8_lossy(&definition_name.value));

                if *num_sub != 0 {

                    buffer.push('<');

                    for sub_idx in 0..*num_sub {

                        if sub_idx != 0 { buffer.push(','); }

                        idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);

                    }

                    buffer.push('>');

                }

                idx += 1;

            }

        }

        idx

    }

    serialize_recursive(buffer, heap, poly_vars, concrete, 0);

}

fn seek_def_in_modules<'a>(heap: &Heap, modules: &'a [LexedModule], def_id: DefinitionId) -> Option<&'a LexedModule> {

    for module in modules {

        let root = &heap.protocol_descriptions[module.root_id];

        for definition in &root.definitions {

            if *definition == def_id {

                return Some(module)

            }

        }

    }

    None

}

fn seek_stmt<F: Fn(&Statement) -> bool>(heap: &Heap, start: StatementId, f: &F) -> Option<StatementId> {

    let stmt = &heap[start];

    if f(stmt) { return Some(start); }

    // This statement wasn't it, try to recurse

    let matched = match stmt {

        Statement::Block(block) => {

            for sub_id in &block.statements {

                if let Some(id) = seek_stmt(heap, *sub_id, f) {

                    return Some(id);

                }

            }

            None

        },

        Statement::Labeled(stmt) => seek_stmt(heap, stmt.body, f),

        Statement::If(stmt) => {

            if let Some(id) = seek_stmt(heap,stmt.true_body, f) {

                return Some(id);