///

/// It is unsafe because we're using pointers to circumvent borrowing rules in

/// the name of code cleanliness. The correctness of use is checked in debug

use std::iter::FromIterator;

}

}

impl<T: Sized> ScopedBuffer<T> {

    pub(crate) fn with_capacity(capacity: usize) -> Self {

    }

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

        ScopedSection {

            inner: &mut self.inner,

            start_size,

        }

    }

}

    }

}

impl<T: Sized> ScopedSection<T> {

    #[inline]

    pub(crate) fn push(&mut self, value: T) {

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

        vec.push(value);

    }

    pub(crate) fn len(&self) -> usize {

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

        return vec.len() - self.start_size as usize;

    }

    #[allow(unused_mut)] // used in debug mode

    pub(crate) fn forget(mut self) {

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

            debug_assert_eq!(

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

                "trying to forget section, but size is larger than expected"

            );

            self.cur_size = self.start_size;

        vec.truncate(self.start_size as usize);

    }

    #[allow(unused_mut)] // used in debug mode

    pub(crate) fn into_vec(mut self) -> Vec<T> {

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

            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

    }

    }

}

    type Output = T;

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

    }

}

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

    fn drop(&mut self) {

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

        vec.truncate(self.start_size as usize);

    }

}

pub(crate) struct ScopedIter<T: Copy> {

    inner: *mut Vec<T>,

    cur_index: u32,

    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {

        if self.cur_index >= self.last_index {

            return None;

        }

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

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

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

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

    reserved_idx: i32,

    definition_type: DefinitionType,

    poly_vars: Vec<ConcreteType>,

    var_buffer: ScopedBuffer<VariableId>,

    expr_buffer: ScopedBuffer<ExpressionId>,

    stmt_buffer: ScopedBuffer<StatementId>,

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

            var_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),

            expr_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),

            stmt_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),

            var_types: HashMap::new(),

            expr_types: Vec::new(),

            extra_data: Vec::new(),

                progress_expr

            },

            Literal::Array(data) => {

                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

                    }

                }

                // And the output should be an array of the element types

                let mut progress_expr = self.apply_template_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;

                    let first_arg_id = expr_elements[0];

                    let (inner_expr_progress, arg_progress) = self.apply_equal2_constraint(

                        ctx, upcast_id, upcast_id, 1, first_arg_id, 0

                debug_log!(" * After:");

                debug_log!("   - Expr type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));

                progress_expr

            },

            Literal::Tuple(data) => {

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

                debug_log!(" * Before:");

                debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));

                // The elements of the tuple can have any type, but they must

                // end up as arguments to the output tuple type.

                debug_log!(" * During (checking expressions constituting tuple):");

                    // For the current expression index, (re)compute the

                    // position in the tuple type where the types should match.

                    let mut start_index = 1; // first element is Tuple type, second is the first child

                    // Apply the constraint

                    let (member_progress_expr, member_progress) = self.apply_equal2_constraint(

                    )?;

                    debug_log!("   - Member {} type | {}", member_expr_index, self.debug_get_display_name(ctx, *member_expr_id));

                    progress_expr = progress_expr || member_progress_expr;

                    if member_progress {

                    }

                }

                progress_expr

            }

        };

        Ok((progress_expr, progress_arg1, progress_arg2))

    }

    fn apply_equal_n_constraint(

        // Early exit

        match args.len() {

        }

        // Do pairwise inference, keep track of the last entry we made progress

        // on. Once done we need to update everything to the most-inferred type.

        let mut last_lhs_progressed = 0;

        let mut lhs_arg_idx = 0;

        while let Some(next_arg_id) = arg_iter.next() {

            let last_expr_idx = ctx.heap[last_arg_id].get_unique_id_in_definition(); // TODO: @Temp

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

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

            };

            if res == DualInferenceResult::Incompatible {

            }

            if res.modified_lhs() {

            }

            progress[lhs_arg_idx + 1] = res.modified_rhs();

            lhs_arg_idx += 1;

        }

        // Re-infer everything. Note that we do not need to re-infer the type

        // exactly at `last_lhs_progressed`, but only everything up to it.

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

        for arg_idx in 0..last_lhs_progressed {

            let other_arg_expr_idx = ctx.heap[args[arg_idx]].get_unique_id_in_definition();

            progress[arg_idx] = true;

        }

    }

    /// Determines the `InferenceType` for the expression based on the

        let root = &ctx.heap[ctx.module().root_id];

        let section = self.definition_buffer.start_section_initialized(&root.definitions);

            self.visit_definition(ctx, definition_id)?;

        }

        section.forget();

            _ => unreachable!(),

        } ;

            let var = &mut ctx.heap[var_id];

            var.unique_id_in_scope = var_counter;

            var_counter += 1;