let parser_type = self.type_parser.consume_parser_type(

            iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars, definition_id,

            module_scope, false, None

        )?;

        // Consume block and the definition's scope

        // Assign everything in the preallocated AST node

        let function = ctx.heap[definition_id].as_function_mut();

        function.return_type = parser_type;

        function.parameters = parameters;

        Ok(())

    }

    fn visit_component_definition(

        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

        consume_parameter_list(

            &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id

        )?;

        let parameters = parameter_section.into_vec();

        // Consume block

        // Assign everything in the AST node

        let component = ctx.heap[definition_id].as_component_mut();

        component.parameters = parameters;

        Ok(())

    }

    /// Consumes a statement and returns a boolean indicating whether it was a

    /// block or not.

        // Consume bodies of if-statement

        let true_body = IfStatementCase{

            body: self.consume_statement(module, iter, ctx)?,

            scope: ScopeId::new_invalid(),

        };

            iter.consume();

            let false_body = IfStatementCase{

                body: self.consume_statement(module, iter, ctx)?,

                scope: ScopeId::new_invalid(),

            };

            let false_body_scope_id = false_body.scope;

        } else {

        };

        // Construct AST elements

        let if_stmt_id = ctx.heap.alloc_if_statement(|this| IfStatement{

            this,

            span: if_span,

        let end_if_stmt_id = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{

            this,

            start_if: if_stmt_id,

            next: StatementId::new_invalid(),

        });

        let true_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(if_stmt_id, true)));

        let if_stmt = &mut ctx.heap[if_stmt_id];

        if_stmt.end_if = end_if_stmt_id;

        if_stmt.true_case.scope = true_scope_id;

        if let Some(false_case) = &mut if_stmt.false_case {

        }

        return Ok(if_stmt_id);

    }

    fn consume_while_statement(

        let definition = &ctx.heap[id];

        let body_id = definition.body;

        let section = self.variable_buffer.start_section_initialized(&definition.parameters);

        for variable_idx in 0..section.len() {

            let variable_id = section[variable_idx];

        }

        self.relative_pos_in_parent = section.len() as i32;

        section.forget();

        // Visit statements in component body

        let definition = &ctx.heap[id];

        let body_id = definition.body;

        let section = self.variable_buffer.start_section_initialized(&definition.parameters);

        for variable_idx in 0..section.len() {

            let variable_id = section[variable_idx];

        }

        section.forget();

        // Visit statements in function body

        self.visit_block_stmt(ctx, body_id)?;

        self.pop_scope(old_scope);

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

        let stmt = &ctx.heap[id];

        let expr_id = stmt.initial_expr;

        let variable_id = stmt.variable;

        self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, variable_id)?;

        assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());

        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

        self.expr_parent = ExpressionParent::Memory(id);

        self.visit_assignment_expr(ctx, expr_id)?;

            self.in_select_guard = id;

            self.in_select_arm = index as u32;

            self.visit_stmt(ctx, guard_id)?;

            self.in_select_guard = SelectStatementId::new_invalid();

            // Visit the code associated with the guard

            self.visit_stmt(ctx, case_body_id)?;

            self.pop_scope(old_scope);

            // Link up last statement in block to EndSelect

            assign_then_erase_next_stmt!(self, ctx, end_select_id.upcast());

        }

        // variable expr that is on the LHS of the assignment expr that is

        // associated with a variable declaration)

        let mut variable_id = var_expr.declaration;

        let mut is_binding_target = false;

        // Otherwise try to find it

        if variable_id.is_none() {

            variable_id = self.find_variable(ctx, self.relative_pos_in_parent, &var_expr.identifier);

        }

        // Otherwise try to see if is a variable introduced by a binding expr

        let variable_id = if let Some(variable_id) = variable_id {

        // Set the properties of the pushed scope (it is already created during

        // AST construction, but most values are not yet set to their correct

        // values)

        let old_scope_id = self.cur_scope;

        let scope = &mut ctx.heap[pushed_scope_id];

            scope.parent = Some(old_scope_id);

        }

        scope.relative_pos_in_parent = self.relative_pos_in_parent;

        let old_relative_pos = self.relative_pos_in_parent;

        self.relative_pos_in_parent = 0;

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

    // 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.

        // We immediately go to the parent scope. We check the target scope

        // in the call at the end. That is also where we check for collisions

        // with symbols.

        let mut scope = &ctx.heap[target_scope_id];

        let mut cur_relative_pos = scope.relative_pos_in_parent;

        while let Some(scope_parent_id) = scope.parent {

            scope = &ctx.heap[scope_parent_id];

            // Check for collisions

            for variable_id in scope.variables.iter().copied() {

                    return Err(

                        ParseError::new_error_str_at_span(

                        ).with_info_str_at_span(

                        )

                    );

                }

            }

            cur_relative_pos = scope.relative_pos_in_parent;

        }

        // No collisions in any of the parent scope, attempt to add to scope

    }

    /// Adds a local variable to the specified scope. Will check the specified

    /// scope for variable conflicts and the symbol table for global conflicts.

    /// Will NOT check parent scopes of the specified scope.

    fn checked_at_single_scope_add_local(