/// A section of the buffer. Keeps track of where we started the section. When

/// done with the section one must call `into_vec` or `forget` to remove the

/// section from the underlying buffer. This will also be done upon dropping the

/// ScopedSection in case errors are being handled.

pub(crate) struct ScopedSection<T: Sized> {

    inner: *mut Vec<T>,

    start_size: u32,

    #[cfg(debug_assertions)] cur_size: u32,

}

impl<T: Sized> ScopedBuffer<T> {

        Self { inner: Vec::with_capacity(capacity) }

    }

    pub(crate) fn start_section(&mut self) -> ScopedSection<T> {

        let start_size = self.inner.len() as u32;

        ScopedSection {

            inner: &mut self.inner,

            start_size,

            #[cfg(debug_assertions)] cur_size: start_size

        }

    }

}

        #[cfg(debug_assertions)]  {

            debug_assert_eq!(

                vec.len(), self.cur_size as usize,

                "trying to turn section into vec, but size is larger than expected"

            );

            self.cur_size = self.start_size;

        }

        let section = Vec::from_iter(vec.drain(self.start_size as usize..));

        section

    }

}

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

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

        #[cfg(debug_assertions)] debug_assert_eq!(vec.len(), self.cur_size as usize);

        vec.truncate(self.start_size as usize);

    }

}

    variables: ScopedBuffer<VariableId>,

    expressions: ScopedBuffer<ExpressionId>,

    statements: ScopedBuffer<StatementId>,

    parser_types: ScopedBuffer<ParserType>,

}

impl PassDefinitions {

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

        Self{

            cur_definition: DefinitionId::new_invalid(),

            type_parser: ParserTypeParser::new(),

            buffer: String::with_capacity(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.

macro_rules! debug_log {

    ($format:literal) => {

        enabled_debug_print!(false, "types", $format);

    };

    ($format:literal, $($args:expr),*) => {

        enabled_debug_print!(false, "types", $format, $($args),*);

    };

}

use std::collections::{HashMap, HashSet};

use crate::protocol::ast::*;

use crate::protocol::input_source::ParseError;

use crate::protocol::parser::ModuleCompilationPhase;

use crate::protocol::parser::type_table::*;

use crate::protocol::parser::token_parsing::*;

use super::visitor::{

    Ctx,

    Visitor,

    VisitorResult

};

const VOID_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Void ];

const MESSAGE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Message, InferenceTypePart::UInt8 ];

const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];

const CHARACTER_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Character ];

const STRING_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::String, InferenceTypePart::Character ];

const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];

const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];

            extra_data_idx: -1,

        }

    }

}

/// This particular visitor will recurse depth-first into the AST and ensures

/// that all expressions have the appropriate types.

pub(crate) struct PassTyping {

    // Current definition we're typechecking.

    reserved_idx: i32,

    definition_type: DefinitionType,

    poly_vars: Vec<ConcreteType>,

    // Buffers for iteration over substatements and subexpressions

    // Mapping from parser type to inferred type. We attempt to continue to

    // specify these types until we're stuck or we've fully determined the type.

    var_types: HashMap<VariableId, VarData>,            // types of variables

    expr_types: Vec<InferenceExpression>,                     // will be transferred to type table at end

    extra_data: Vec<ExtraData>,       // data for polymorph inference

    // Keeping track of which expressions need to be reinferred because the

    // expressions they're linked to made progression on an associated type

    expr_queued: DequeSet<i32>,

}

// TODO: @Rename, this is used for a lot of type inferencing. It seems like

//  there is a different underlying architecture waiting to surface.

    }

    fn new_local(var_type: InferenceType) -> Self {

        Self{ var_type, used_at: Vec::new(), linked_var: None }

    }

}

impl PassTyping {

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

        PassTyping {

            reserved_idx: -1,

            definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),

            poly_vars: Vec::new(),

            var_types: HashMap::new(),

            expr_types: Vec::new(),

            extra_data: Vec::new(),

            expr_queued: DequeSet::new(),

        }

    }

    pub(crate) fn queue_module_definitions(ctx: &mut Ctx, queue: &mut ResolveQueue) {

        debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::ValidatedAndLinked);

        let root_id = ctx.module().root_id;

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

        for definition_id in &root.definitions {

        // Visit the definition, setting up the type resolving process, then

        // (attempt to) resolve all types

        self.visit_definition(ctx, element.definition_id)?;

        self.resolve_types(ctx, queue)?;

        Ok(())

    }

    fn reset(&mut self) {

        self.reserved_idx = -1;

        self.definition_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());

        self.poly_vars.clear();

        self.var_types.clear();

        self.expr_types.clear();

        self.extra_data.clear();

        self.expr_queued.clear();

    }

}

impl Visitor for PassTyping {

    // Definitions

    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {

        self.definition_type = DefinitionType::Component(id);

        let comp_def = &ctx.heap[id];

        debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");

        debug_log!("{}", "-".repeat(50));

        debug_log!("Visiting component '{}': {}", comp_def.identifier.value.as_str(), id.0.index);

        debug_log!("{}", "-".repeat(50));

        // Reserve data for expression types

        debug_assert!(self.expr_types.is_empty());

        self.expr_types.resize(comp_def.num_expressions_in_body as usize, Default::default());

        // Visit parameters

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);

            debug_assert!(var_type.is_done, "expected component arguments to be concrete types");

            self.var_types.insert(param_id, VarData::new_local(var_type));

        }

        // Visit the body and all of its expressions

        let body_stmt_id = ctx.heap[id].body;

        self.visit_block_stmt(ctx, body_stmt_id)

    }

    fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {

        self.definition_type = DefinitionType::Function(id);

        let func_def = &ctx.heap[id];

        debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");

                );

                let _infer_type = InferenceType::new(false, true, infer_type_parts);

                debug_log!(" - [{:03}] {:?}", _idx, _infer_type.display_name(&ctx.heap));

            }

        }

        debug_log!("{}", "-".repeat(50));

        // Reserve data for expression types

        debug_assert!(self.expr_types.is_empty());

        self.expr_types.resize(func_def.num_expressions_in_body as usize, Default::default());

        // Visit parameters

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);

            debug_assert!(var_type.is_done, "expected function arguments to be concrete types");

            self.var_types.insert(param_id, VarData::new_local(var_type));

        }

        // Visit all of the expressions within the body

        let body_stmt_id = ctx.heap[id].body;

        self.visit_block_stmt(ctx, body_stmt_id)

    }

    // Statements

    fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {

        // Transfer statements for traversal

        let block = &ctx.heap[id];

            self.visit_stmt(ctx, stmt_id)?;

        }

        Ok(())

    }

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

        let memory_stmt = &ctx.heap[id];

        let local = &ctx.heap[memory_stmt.variable];

        let var_type = self.determine_inference_type_from_parser_type_elements(&local.parser_type.elements, true);

        self.var_types.insert(memory_stmt.variable, VarData::new_local(var_type));

        Ok(())

    fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let literal_expr = &ctx.heap[id];

        match &literal_expr.value {

            Literal::Null | Literal::False | Literal::True |

            Literal::Integer(_) | Literal::Character(_) | Literal::String(_) => {

                // No subexpressions

            },

            Literal::Struct(literal) => {

                self.insert_initial_struct_polymorph_data(ctx, id);

                    self.visit_expr(ctx, expr_id)?;

                }

            },

            Literal::Enum(_) => {

                // Enumerations do not carry any subexpressions, but may still

                // have a user-defined polymorphic marker variable. For this 

                // reason we may still have to apply inference to this 

                // polymorphic variable

                self.insert_initial_enum_polymorph_data(ctx, id);

            },

            Literal::Union(literal) => {

                // May carry subexpressions and polymorphic arguments

                self.insert_initial_union_polymorph_data(ctx, id);

                    self.visit_expr(ctx, expr_id)?;

                }

            },

            Literal::Array(expressions) | Literal::Tuple(expressions) => {

                    self.visit_expr(ctx, expr_id)?;

                }

            }

        }

        self.progress_literal_expr(ctx, id)

    }

    fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let cast_expr = &ctx.heap[id];

        let subject_expr_id = cast_expr.subject;

    fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        self.insert_initial_call_polymorph_data(ctx, id);

        // By default we set the polymorph idx for calls to 0. If the call ends

        // up not being a polymorphic one, then we will select the default

        // expression types in the type table

        let call_expr = &ctx.heap[id];

        self.expr_types[call_expr.unique_id_in_definition as usize].field_or_monomorph_idx = 0;

        // Visit all arguments

            self.visit_expr(ctx, arg_expr_id)?;

        }

        self.progress_call_expr(ctx, id)

    }

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

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let var_expr = &ctx.heap[id];

        debug_assert!(var_expr.declaration.is_some());

        // Not pretty: if a binding expression, then this is the first time we

            let mut concrete = ConcreteType::default();

            infer_expr.expr_type.write_concrete_type(&mut concrete);

            target.expr_data.push(MonomorphExpression{

                expr_type: concrete,

                field_or_monomorph_idx: infer_expr.field_or_monomorph_idx

            });

        }

        Ok(())

    }

    fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {

        match &ctx.heap[id] {

            Expression::Assignment(expr) => {

                let id = expr.this;

                self.progress_assignment_expr(ctx, id)

            },

            Expression::Binding(expr) => {

                let id = expr.this;

                self.progress_binding_expr(ctx, id)

            },

            Expression::Conditional(expr) => {

                let id = expr.this;

                self.progress_conditional_expr(ctx, id)

                                    "Can only apply field access to structs, got a subject of type '{}'",

                                    subject_type.display_name(&ctx.heap)

                                )

                            ));

                        }

                    }

                }

                // If here then field index is known, and the referenced struct type

                // information is inserted into `extra_data`. Check to see if we can

                // do some mutual inference.

                let poly_data = &mut self.extra_data[extra_idx as usize];

                // Apply to struct's type

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

                let subject_type: *mut _ = &mut self.expr_types[subject_expr_idx as usize].expr_type;

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

                    ctx, upcast_id, Some(subject_id), poly_data, &mut poly_progress,

                    signature_type, 0, subject_type, 0

                )?;

                if progress_subject {

                    self.expr_queued.push_back(subject_expr_idx);

                // And for the union type itself

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

                let expr_type: *mut _ = &mut self.expr_types[expr_idx as usize].expr_type;

                let progress_expr = Self::apply_equal2_polyvar_constraint(

                    extra, &poly_progress, signature_type, expr_type

                );

                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.debug_get_display_name(ctx, upcast_id));

                // All elements should have an equal type

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

                for (progress_arg, arg_id) in progress.iter().zip(expr_elements.iter()) {

                    if *progress_arg {

                        self.queue_expr(ctx, *arg_id);

                    }

                }

 * we assign to each expression in the procedure a unique ID. This is what the

 * "next expression index" field achieves. Each expression simply takes the

 * current value, and then increments this counter.

 */

use crate::collections::{ScopedBuffer};

use crate::protocol::ast::*;

use crate::protocol::input_source::*;

use crate::protocol::parser::symbol_table::*;

use crate::protocol::parser::type_table::*;

use super::visitor::{

    Ctx,

    Visitor,

    VisitorResult

};

use crate::protocol::parser::ModuleCompilationPhase;

#[derive(PartialEq, Eq)]

enum DefinitionType {

    Primitive(ComponentDefinitionId),

    Composite(ComponentDefinitionId),

    Function(FunctionDefinitionId)

}

            in_sync: SynchronousStatementId::new_invalid(),

            in_while: WhileStatementId::new_invalid(),

            in_test_expr: StatementId::new_invalid(),

            in_binding_expr: BindingExpressionId::new_invalid(),

            in_binding_expr_lhs: false,

            cur_scope: Scope::Definition(DefinitionId::new_invalid()),

            prev_stmt: StatementId::new_invalid(),

            expr_parent: ExpressionParent::None,

            def_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),

            must_be_assignable: None,

            relative_pos_in_block: 0,

            next_expr_index: 0,

        }

    }

    fn reset_state(&mut self) {

        self.in_sync = SynchronousStatementId::new_invalid();

        self.in_while = WhileStatementId::new_invalid();

        self.in_test_expr = StatementId::new_invalid();

        self.in_binding_expr = BindingExpressionId::new_invalid();

        self.in_binding_expr_lhs = false;

        self.cur_scope = Scope::Definition(DefinitionId::new_invalid());

        self.def_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());

        self.prev_stmt = StatementId::new_invalid();

use crate::protocol::ast::*;

use crate::protocol::input_source::ParseError;

use crate::protocol::parser::{type_table::*, Module};

use crate::protocol::symbol_table::{SymbolTable};

type Unit = ();

pub(crate) type VisitorResult = Result<Unit, ParseError>;

/// General context structure that is used while traversing the AST.

pub(crate) struct Ctx<'p> {

    pub heap: &'p mut Heap,

    pub modules: &'p mut [Module],

    pub module_idx: usize, // currently considered module

    pub symbols: &'p mut SymbolTable,

    pub types: &'p mut TypeTable,

    pub arch: &'p crate::protocol::TargetArch,

}

impl<'p> Ctx<'p> {