#[cfg(debug_assertions)]

impl<T: Sized> Drop for ScopedSection<T> {

    fn drop(&mut self) {

        debug_assert_eq!(vec.len(), self.cur_size as usize);

        vec.truncate(self.start_size as usize);

    }

#![allow(dead_code)]

use std::io::Write as IOWrite;

use super::ast::*;

    parameters: ScopedBuffer<ParameterId>,

    expressions: ScopedBuffer<ExpressionId>,

    statements: ScopedBuffer<StatementId>,

}

impl PassDefinitions {

            parameters: ScopedBuffer::new_reserved(128),

            expressions: ScopedBuffer::new_reserved(128),

            statements: ScopedBuffer::new_reserved(128),

        }

    }

                let identifier = consume_ident_interned(source, iter, ctx)?;

                let mut close_pos = identifier.span.end;

                let has_embedded = maybe_consume_comma_separated(

                    TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,

                    |source, iter, ctx| {

                            module_scope, definition_id, false, 0

                        )

                    },

                )?;

                let value = if has_embedded {

                } else {

                    UnionVariantValue::None

                };

                Ok(UnionVariantDefinition{

                    span: InputSpan::from_positions(identifier.span.begin, close_pos),

        // Consume return types

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

        consume_comma_separated_until(

            TokenKind::OpenCurly, &module.source, iter, ctx,

            |source, iter, ctx| {

                let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...

                consume_parser_type(source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope, definition_id, false, 0)

            },

        )?;

        // TODO: @ReturnValues

        match return_types.len() {

                alias: alias_identifier,

                module_id: target_root_id

            }));

                name: alias_name,

                variant: SymbolVariant::Module(SymbolModule{

                    root_id: target_root_id,

                    introduced_at: import_id,

                }),

        } else if Some(TokenKind::ColonColon) == next {

            iter.consume();

        let module_scope = SymbolScope::Module(root_id);

        ctx.symbols.insert_scope(None, module_scope);

        for symbol in self.symbols.drain(..) {

            if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(module_scope, symbol) {

                return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol))

            }

        // And finally, we may have a token range at the end that doesn't belong

        // to a range yet, so insert a "code" range if this is the case.

        debug_assert_eq!(self.stack_idx, 0);

        let last_token_idx = target.tokens.len() as u32;

        }

        // TODO: @remove once I'm sure the algorithm works. For now it is better

        has_newline

    }

        let new_range_idx = target.ranges.len() as i32;

        let sibling_idx = parent_range.last_child_idx;

        parent_range.last_child_idx = new_range_idx;

        parent_range.end = code_end_idx;

        parent_range.num_child_ranges += 1;

        target.ranges.push(TokenRange{

            parent_idx,

            range_kind: TokenRangeKind::Code,

        }

    }

        // Push the new range

        self.stack_idx = target.ranges.len();

        target.ranges.push(TokenRange{

            parent_idx,

            range_kind,

                let signature_type: *mut _ = &mut poly_data.embedded[0];

                let subject_type: *mut _ = self.expr_types.get_mut(&subject_id).unwrap();

                    poly_data, &poly_progress, signature_type, subject_type

                );

                let signature_type: *mut _ = &mut poly_data.returned;

                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

                    poly_data, &poly_progress, signature_type, expr_type

                );

            },

            Literal::Struct(data) => {

                let extra = self.extra_data.get_mut(&upcast_id).unwrap();

                }

                let mut poly_progress = HashSet::new();

                debug_assert_eq!(extra.embedded.len(), data.fields.len());

                    let field_expr_id = data.fields[field_idx].value;

                    let field_type: *mut _ = self.expr_types.get_mut(&field_expr_id).unwrap();

                        extra, &poly_progress, signature_type, field_type

                    );

                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

                let progress_expr = Self::apply_equal2_polyvar_constraint(

                );

                progress_expr

            },

            Literal::Enum(_) => {

                let extra = self.extra_data.get_mut(&upcast_id).unwrap();

                }

                let mut poly_progress = HashSet::new();

                debug_log!(" * During (reinferring from progress polyvars):");

                let progress_expr = Self::apply_equal2_polyvar_constraint(

                );

                progress_expr

            },

            Literal::Union(data) => {

                let extra = self.extra_data.get_mut(&upcast_id).unwrap();

                }

                let mut poly_progress = HashSet::new();

                debug_assert_eq!(extra.embedded.len(), data.values.len());

                    let value_type: *mut _ = self.expr_types.get_mut(&value_expr_id).unwrap();

                    let progress_arg = Self::apply_equal2_polyvar_constraint(

                    );

                    debug_log!(

                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

                let progress_expr = Self::apply_equal2_polyvar_constraint(

                );

                progress_expr

        // reapplying the polymorph type to each argument type and the return

        // type should always succeed.

        debug_log!(" * During (reinferring from progressed polyvars):");

        }

        // TODO: @performance If the algorithm is changed to be more "on demand

        //  argument re-evaluation", instead of "all-argument re-evaluation",

            let arg_expr_id = expr.arguments[arg_idx];

            let arg_type: *mut _ = self.expr_types.get_mut(&arg_expr_id).unwrap();

                extra, &poly_progress,

                signature_type, arg_type

            );

        let signature_type: *mut _ = &mut extra.returned;

        let ret_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

            extra, &poly_progress, signature_type, ret_type

        );

        debug_log!(

    ///

    /// This function returns true if the expression's type has been progressed

    fn apply_equal2_polyvar_constraint(

        polymorph_data: &ExtraData, _polymorph_progress: &HashSet<usize>,

        signature_type: *mut InferenceType, expr_type: *mut InferenceType

    ) -> bool {

}

/// TODO: @Cleanup - remove clone everywhere

pub struct Symbol {

    pub name: StringRef<'static>,

    pub variant: SymbolVariant,

        );

        debug_assert!(!self.scope_lookup.contains_key(&new_scope), "inserting scope {:?}, but it already exists", new_scope);

        if let Some(parent_scope) = parent_scope {

            let parent = self.scope_lookup.get_mut(&parent_scope).unwrap();

            parent.child_scopes.push(new_scope);

    // Note: we do not return a reference because Rust doesn't like it.

    pub(crate) fn insert_symbol(&mut self, in_scope: SymbolScope, symbol: Symbol) -> Result<(), (Symbol, Symbol)> {

        debug_assert!(self.scope_lookup.contains_key(&in_scope), "inserting symbol {}, but scope {:?} does not exist", symbol.name.as_str(), in_scope);

        let mut seek_scope = in_scope;

        loop {

            let scoped_symbols = self.scope_lookup.get(&seek_scope).unwrap();

        });

    });

}

#[test]