impl<T: Sized> std::ops::Index<usize> for ScopedSection<T> {

    type Output = T;

    fn index(&self, idx: usize) -> &Self::Output {

        let vec = unsafe{&*self.inner};

        return &vec[self.start_size as usize + idx]

    }

}

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

const PREFIX_EMPTY: &'static str = "    ";

const PREFIX_ROOT_ID: &'static str = "Root";

const PREFIX_PRAGMA_ID: &'static str = "Prag";

const PREFIX_IMPORT_ID: &'static str = "Imp ";

const PREFIX_TYPE_ANNOT_ID: &'static str = "TyAn";

/// Parses all the tokenized definitions into actual AST nodes.

pub(crate) struct PassDefinitions {

    // State

    cur_definition: DefinitionId,

    // Temporary buffers of various kinds

    buffer: String,

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

            buffer: String::with_capacity(128),

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

        debug_assert_eq!(module.phase, ModuleCompilationPhase::ImportsResolved);

        debug_assert_eq!(module_range.range_kind, TokenRangeKind::Module);

        // Although we only need to parse the definitions, we want to go through

        // code ranges as well such that we can throw errors if we get

        // unexpected tokens at the module level of the source.

        self.cur_definition = definition_id;

        // Parse union definition

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

        let mut variants_section = self.union_variants.start_section();

        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

                })

            },

            &mut variants_section, "a union variant", "a list of union variants", None

        )?;

        // Transfer to AST

        let union_def = ctx.heap[definition_id].as_union_mut();

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

        // Parse function's argument list

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

        consume_parameter_list(

            &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")),

        }

        // Consume block

        let body = self.consume_block_statement_without_leading_curly(module, iter, ctx, open_curly_pos)?;

        // Assign everything in the preallocated AST node

            // Alias for module

            iter.consume();

            let alias_identifier = consume_ident_interned(&module.source, &mut iter, ctx)?;

            let alias_name = alias_identifier.value.clone();

            import_id = ctx.heap.alloc_import(|this| Import::Module(ImportModule{

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

                source: &'a InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,

                module_name: &StringRef<'static>, module_root_id: RootId,

            ) -> Result<(AliasedSymbol, SymbolDefinition), ParseError> {

                // Consume symbol name and make sure it points to an existing definition

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

            if next_sibling_idx == NO_SIBLING {

                break;

            } else {

                range_idx = next_sibling_idx;

            }

        }

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

        let root = &mut ctx.heap[root_id];

        root.pragmas.extend(self.pragmas.drain(..));

        root.definitions.extend(self.definitions.drain(..));

        let module = &mut modules[module_idx];

        module.phase = ModuleCompilationPhase::SymbolsScanned;

            ));

        }

        // Ranges that did not depend on curly braces may have missing tokens.

        // So close all of the active tokens

        while self.stack_idx != 0 {

            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

            for parent_idx in 0..target.ranges.len() {

                let cur_range = &target.ranges[parent_idx];

                if cur_range.num_child_ranges == 0 {

                    assert_eq!(cur_range.first_child_idx, NO_RELATION);

                    assert_eq!(cur_range.last_child_idx, NO_RELATION);

                } else {

                break;

            }

            if c == b'\n' {

                has_newline = true;

            }

            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

            num_child_ranges: 0,

            first_child_idx: NO_RELATION,

            last_child_idx: NO_RELATION,

            next_sibling_idx: NO_RELATION

        })

    }

                )?;

                if progress_expr {

                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

                        self.expr_queued.insert(parent_id);

                    }

                }

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

            }

        };

        if progress_subject { self.queue_expr(subject_id); }

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

        debug_log!(" * After:");

        debug_log!("   - Subject type [{}]: {}", progress_subject, self.expr_types.get(&subject_id).unwrap().display_name(&ctx.heap));

                self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?

            },

            Literal::Character(_) => {

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

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

            },

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

                // Mutually infer field signature/expression types

                for (field_idx, field) in data.fields.iter().enumerate() {

                    let field_expr_id = field.value;

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

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

                    let (_, progress_arg) = Self::apply_equal2_signature_constraint(

                // Check which expressions use the polymorphic arguments. If the

                // polymorphic variables have been progressed then we try to 

                // progress them inside the expression as well.

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

                // For all field expressions

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

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

                    );

                    if progress_arg {

                        self.expr_queued.insert(field_expr_id);

                    }

                }

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

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

                let (_, progress_expr) = Self::apply_equal2_signature_constraint(

                    ctx, upcast_id, None, extra, &mut poly_progress,

                    signature_type, 0, expr_type, 0

                )?;

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

                );

                if progress_expr {

                    // TODO: @cleanup

                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

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

                // Mutually infer union variant values

                for (value_idx, value_expr_id) in data.values.iter().enumerate() {

                    let value_expr_id = *value_expr_id;

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

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

                    let (_, progress_arg) = Self::apply_equal2_signature_constraint(

                    }

                }

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

                // For all embedded values of the union variant

                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)

                    );

                    if progress_arg {

                        self.expr_queued.insert(value_expr_id);

                    }

                }

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

                debug_log!("Array expr ({} elements): {}", expr_elements.len(), upcast_id.index);

                debug_log!(" * Before:");

                debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

                // All elements should have an equal type

                let progress = self.apply_equal_n_constraint(ctx, upcast_id, &expr_elements)?;

        if progress_expr {

            // TODO: @cleanup, cannot call utility self.queue_parent thingo

            if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

                self.expr_queued.insert(parent_id);

            }

        }

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

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

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

            );

            if progress_arg {

                self.expr_queued.insert(arg_expr_id);

            }

        }

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

        );

        if progress_ret {

            self.queue_expr_parent(ctx, upcast_id);

        }

        debug_log!(" * After:");

    /// Applies equal2 constraints on the signature type for each of the 

    /// polymorphic variables. If the signature type is progressed then we 

    /// progress the expression type as well.

    ///

    /// This function assumes that the polymorphic variables have already been

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

        let signature_type = unsafe{&mut *signature_type};

        let expr_type = unsafe{&mut *expr_type};

        // Iterate through markers in signature type to try and make progress

        // on the polymorphic variable        

        let mut seek_idx = 0;

        }

    }

    pub(crate) fn as_definition(&self) -> &SymbolDefinition {

        match self {

            SymbolVariant::Module(_) => unreachable!("called 'as_definition' on {:?}", self),

            SymbolVariant::Definition(v) => v,

        }

    }

}

/// TODO: @Cleanup - remove clone everywhere

pub struct Symbol {

    pub name: StringRef<'static>,

    pub variant: SymbolVariant,

}

impl Symbol {

    pub(crate) fn class(&self) -> SymbolClass {

        match &self.variant {

            SymbolVariant::Module(_) => SymbolClass::Module,

            SymbolVariant::Definition(data) => data.class.as_symbol_class(),

        }

    }

        self.module_lookup.get(&string_ref).map(|v| *v)

    }

    /// Inserts a new symbol scope. The parent must have been added to the

    /// symbol table before.

    pub(crate) fn insert_scope(&mut self, parent_scope: Option<SymbolScope>, new_scope: SymbolScope) {

        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 {

            scope: new_scope,

            parent_scope,

            child_scopes: Vec::with_capacity(RESERVED_SYMBOLS),

            symbols: Vec::with_capacity(RESERVED_SYMBOLS)

        };

        self.scope_lookup.insert(new_scope, scope);

    }

    /// Inserts a symbol into a particular scope. The symbol's name may not

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

                }

            }

            match scoped_symbols.parent_scope {

                Some(parent_scope) => { seek_scope = parent_scope; },

                None => { break; }

            .assert_concrete_type("s8");

        })

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

            .assert_parser_type("auto")

            .assert_concrete_type("s32");

        })

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

            .assert_parser_type("auto")

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

        });

    });