)?;

        let parameters = parameter_section.into_vec();

        // Consume return types

        consume_token(&module.source, iter, TokenKind::ArrowRight)?;

        let poly_vars = ctx.heap[definition_id].poly_vars();

        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

    ) -> Result<(), ParseError> {

        // Consume component variant and name

        let (_variant_text, _) = consume_any_ident(&module.source, iter)?;

        debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);

        let (ident_text, _) = consume_ident(&module.source, iter)?;

        self.cur_definition = definition_id;

        consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;

        // Parse component's argument list

        let mut parameter_section = self.variables.start_section();

        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.

    fn consume_statement(&mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx) -> Result<StatementId, ParseError> {

        let next = iter.next().expect("consume_statement has a next token");

        if next == TokenKind::OpenCurly {

            let id = self.consume_block_statement(module, iter, ctx)?;

            return Ok(id.upcast());

    ) -> Result<IfStatementId, ParseError> {

        let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;

        consume_token(&module.source, iter, TokenKind::OpenParen)?;

        let test = self.consume_expression(module, iter, ctx)?;

        consume_token(&module.source, iter, TokenKind::CloseParen)?;

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

            test,

            true_case: true_body,

            false_case: false_body,

            end_if: EndIfStatementId::new_invalid(),

        });

        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(

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

    ) -> Result<WhileStatementId, ParseError> {

        let while_span = consume_exact_ident(&module.source, iter, KW_STMT_WHILE)?;

        consume_token(&module.source, iter, TokenKind::OpenParen)?;

        let test = self.consume_expression(module, iter, ctx)?;

        consume_token(&module.source, iter, TokenKind::CloseParen)?;

        };

        self.expr_parent = ExpressionParent::None;

        // Visit parameters and assign a unique scope ID

        let definition_scope_id = definition.scope;

        let old_scope = self.push_scope(ctx, true, definition_scope_id);

        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

        self.visit_block_stmt(ctx, body_id)?;

        self.pop_scope(old_scope);

        // Assign total number of expressions and assign an in-block unique ID

        // to each of the locals in the procedure.

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

        self.expr_parent = ExpressionParent::None;

        // Visit parameters and assign a unique scope ID

        let definition = &ctx.heap[id];

        let definition_scope_id = definition.scope;

        let old_scope = self.push_scope(ctx, true, definition_scope_id);

        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);

        // Assign total number of expressions and assign an in-block unique ID

        // to each of the locals in the procedure.

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

        let definition_scope = definition.scope;

        definition.num_expressions_in_body = self.next_expr_index;

        statement_section.forget();

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

        self.pop_scope(old_scope);

        Ok(())

    }

    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.expr_parent = ExpressionParent::None;

        Ok(())

    }

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

            // following the arm. The reason we parse it separately is to

            // extract all of the "get" calls.

            let old_scope = self.push_scope(ctx, false, case_scope_id);

            // Visit the guard of this arm

            debug_assert!(self.in_select_guard.is_invalid());

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

        }

        self.in_select_guard = SelectStatementId::new_invalid();

        self.prev_stmt = end_select_id.upcast();

        Ok(())

    }

    }

    fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {

        let var_expr = &ctx.heap[id];

        // Check if declaration was already resolved (this occurs for the

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

            variable_id

        } else {

            if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, var_expr.identifier.span, "unresolved variable"

                ));

    /// Pushes a new scope associated with a particular statement. If that

    /// statement already has an associated scope (i.e. scope associated with

    /// sync statement or select statement's arm) then we won't do anything.

    /// In all cases the caller must call `pop_statement_scope` with the scope

    /// and relative scope position returned by this function.

    fn push_scope(&mut self, ctx: &mut Ctx, is_top_level_scope: bool, pushed_scope_id: ScopeId) -> (ScopeId, i32) {

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

        // Link up scopes

        if !is_top_level_scope {

            let old_scope = &mut ctx.heap[old_scope_id];

            old_scope.nested.push(pushed_scope_id);

        }

            }

        }

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

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

        &mut self, ctx: &mut Ctx, scope_id: ScopeId, relative_pos: i32, new_variable_id: VariableId

    ) -> Result<(), ParseError> {

        // Check the symbol table for conflicts

        {

            let cur_scope = SymbolScope::Definition(self.def_type.definition_id());

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