}

}

#[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::*;

use super::token_parsing::*;

const INDENT: usize = 2;

    struct_fields: ScopedBuffer<StructFieldDefinition>,

    enum_variants: ScopedBuffer<EnumVariantDefinition>,

    union_variants: ScopedBuffer<UnionVariantDefinition>,

    parameters: ScopedBuffer<ParameterId>,

    expressions: ScopedBuffer<ExpressionId>,

    statements: ScopedBuffer<StatementId>,

}

impl PassDefinitions {

    pub(crate) fn new() -> Self {

        Self{

            cur_definition: DefinitionId::new_invalid(),

            struct_fields: ScopedBuffer::new_reserved(128),

            enum_variants: ScopedBuffer::new_reserved(128),

            union_variants: ScopedBuffer::new_reserved(128),

            parameters: ScopedBuffer::new_reserved(128),

            expressions: ScopedBuffer::new_reserved(128),

            statements: ScopedBuffer::new_reserved(128),

        }

    }

    pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {

        let module = &modules[module_idx];

        let module_range = &module.tokens.ranges[0];

        consume_comma_separated(

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

            |source, iter, ctx| {

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

                        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

                        )

                    },

                )?;

                let value = if has_embedded {

                } else {

                    UnionVariantValue::None

                };

                Ok(UnionVariantDefinition{

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

                    identifier,

                    value

                })

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

        )?;

        let parameters = parameter_section.into_vec();

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

            0 => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "expected a return type")),

            1 => {},

            _ => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "multiple return types are not (yet) allowed")),

                this,

                span: import_span,

                module: module_identifier,

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

            // Helper function to consume symbols, their alias, and the

            // definition the symbol is pointing to.

            fn consume_symbol_and_maybe_alias<'a>(

        }

        // Add the module's symbol scope and the symbols we just parsed

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

            }

        }

        // Modify the preallocated root

            self.pop_range(target, target.tokens.len() as u32);

        }

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

        //  if the debugging is a little more expedient

        if cfg!(debug_assertions) {

            // For each range make sure its children make sense

            source.consume();

        }

        has_newline

    }

    fn push_range(&mut self, target: &mut TokenBuffer, range_kind: TokenRangeKind, first_token_idx: u32) {

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

        let parent_idx = self.stack_idx as i32;

        let parent_range = &mut target.ranges[self.stack_idx];

        if parent_range.first_child_idx == NO_RELATION {

            parent_range.first_child_idx = new_range_idx;

        }

        }

        // Push the new range

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

        target.ranges.push(TokenRange{

            parent_idx,

            range_kind,

            curly_depth,

            start: first_token_idx,

            end: first_token_idx, // modified when popped

                }

                // Reapply progress in polymorphic variables to struct's type

                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

                );

                (progress_subject, progress_expr)

            }

        };

            Literal::String(_) => {

                self.apply_forced_constraint(ctx, upcast_id, &STRING_TEMPLATE)?;

                todo!("check string literal type inference");

            },

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

                debug_log!(" * During (inferring types from fields and struct type):");

                for field_idx in 0..extra.embedded.len() {

                    debug_assert_eq!(field_idx, data.fields[field_idx].field_idx, "confusing, innit?");

                    let signature_type: *mut _ = &mut extra.embedded[field_idx];

                    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

                    );

                    debug_log!(

                        "   - Field {} type | sig: {}, field: {}", field_idx,

                        unsafe{&*signature_type}.display_name(&ctx.heap),

                // For the return type

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

                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 (inferring types from return type)");

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

                        self.expr_queued.insert(parent_id);

                    }

                }

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

                debug_log!(" * During (inferring types from variant values and union type):");

                for value_idx in 0..extra.embedded.len() {

                    let signature_type: *mut _ = &mut extra.embedded[value_idx];

                    let value_expr_id = data.values[value_idx];

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

                    let progress_arg = Self::apply_equal2_polyvar_constraint(

                    );

                    debug_log!(

                        "   - Value {} type | sig: {}, value: {}", value_idx,

                        unsafe{&*signature_type}.display_name(&ctx.heap),

                        unsafe{&*value_type}.display_name(&ctx.heap)

                // And for the union type itself

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

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

                let progress_expr = Self::apply_equal2_polyvar_constraint(

                );

                progress_expr

            },

            Literal::Array(data) => {

                let expr_elements = data.clone(); // TODO: @performance

        }

        // If we did not have an error in the polymorph inference above, then

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

        //  then this is no longer true

        for arg_idx in 0..extra.embedded.len() {

            let signature_type: *mut _ = &mut extra.embedded[arg_idx];

            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

            );

            debug_log!(

                "   - Arg {} type | sig: {}, arg: {}", arg_idx, 

        }

        // Once more for the return 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!(

            "   - Ret type | sig: {}, arg: {}", 

            unsafe{&*signature_type}.display_name(&ctx.heap), 

            unsafe{&*ret_type}.display_name(&ctx.heap)

    /// progressed as far as possible by calling 

    /// `apply_equal2_signature_constraint`. As such, we expect to not encounter

    /// any errors.

    ///

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

        // Safety: all pointers should be distinct

        //         polymorph_data contains may not be modified

        debug_assert_ptrs_distinct!(signature_type, expr_type);

            SymbolVariant::Definition(v) => v,

        }

    }

}

/// TODO: @Cleanup - remove clone everywhere

pub struct Symbol {

    pub name: StringRef<'static>,

    pub variant: SymbolVariant,

}

impl Symbol {

        debug_assert!(

            parent_scope.is_none() || self.scope_lookup.contains_key(parent_scope.as_ref().unwrap()),

            "inserting scope {:?} but parent {:?} does not exist", new_scope, parent_scope

        );

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

        }

        let scope = ScopedSymbols {

    /// exist in the scope or any of its parents. If it does collide then the

    /// symbol will be returned, together with the symbol that has the same

    /// name.

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

            for existing_symbol in scoped_symbols.symbols.iter() {

                if symbol.name == existing_symbol.name {

                    return Err((symbol, existing_symbol.clone()))

        .for_variable("pair", |v| { v

            .assert_parser_type("auto")

            .assert_concrete_type("Pair<s8,s32>");

        });

    });

}

#[test]

fn test_enum_inference() {

    Tester::new_single_source_expect_ok(

        "no polymorphic vars",