/// scoped_buffer.rs

///

/// Solves the common pattern where we are performing some kind of recursive

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

/// mode.

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

    pub inner: Vec<T>,

}

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

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

    inner: *mut Vec<T>,

    start_size: u32,

    }

    #[inline]

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

        vec.truncate(self.start_size as usize);

    }

    #[inline]

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

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

        section

    }

#[cfg(debug_assertions)]

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

    fn drop(&mut self) {

    }

}

        Self{

            statement_kind,

            context_kind,

            start_column,

            end_column,

            filename: source.filename.clone(),

            context,

        fn extend_annotation(first_col: u32, last_col: u32, source: &str, target: &mut String, extend_char: char) {

            debug_assert!(first_col > 0 && last_col > first_col);

                    break;

                }

            ContextKind::SingleLine => {

                // Write single line of context with indicator for the offending

                // span underneath.

                transform_context(&self.context, &mut context);

                context.push('\n');

                f.write_str(&context)?;

                annotation.push_str(" | ");

                extend_annotation(self.start_column, self.end_column, &self.context, &mut annotation, '~');

                annotation.push('\n');

        // Continue compilation with the remaining phases now that the types

        // are all in the type table

        for module_idx in 0..self.modules.len() {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

        // Perform typechecking on all modules

        let mut queue = ResolveQueue::new();

            let ctx = visitor::Ctx{

                heap: &mut self.heap,

                module,

            let top = queue.pop().unwrap();

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

            self.visit_range(modules, module_idx, ctx, range_idx_usize)?;

            }

        }

                Some(KW_PRIMITIVE) | Some(KW_COMPOSITE) => self.visit_component_definition(module, &mut iter, ctx)?,

                _ => return Err(ParseError::new_error_str_at_pos(

                    &module.source, iter.last_valid_pos(),

                )),

            }

        }

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        // Parse struct definition

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

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        // Parse enum definition

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

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        // Parse union definition

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

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        // Parse function's argument list

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

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        // Parse component's argument list

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

            let id = self.consume_block_statement(module, iter, ctx)?;

            section.push(id.upcast());

        } else if next == TokenKind::Ident {

            if ident == KW_STMT_IF {

                // Consume if statement and place end-if statement directly

                // after it.

                self.visit_import_range(modules, module_idx, ctx, range_idx_usize)?;

            }

            }

        }

                self.visit_pragma_range(modules, module_idx, ctx, range_idx_usize)?;

            }

            }

        }

        // see `push_range` and `pop_range`.

        self.stack_idx = 0;

        target.ranges.push(TokenRange{

            range_kind: TokenRangeKind::Module,

            curly_depth: 0,

            start: 0,

            end: 0,

            num_child_ranges: 0,

        });

        // Main tokenization loop

            ));

        }

        // 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 parent_idx in 0..target.ranges.len() {

                let cur_range = &target.ranges[parent_idx];

                if cur_range.num_child_ranges == 0 {

                } else {

                    let mut child_counter = 0u32;

                        child_idx = child_range.next_sibling_idx;

                        child_counter += 1;

                    }

                    assert_eq!(cur_range.num_child_ranges, child_counter);

                }

            }

        has_newline

    }

            target.ranges.push(TokenRange{

                range_kind: TokenRangeKind::Code,

                num_child_ranges: 0,

            });

            }

        }

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

        target.ranges.push(TokenRange{

            parent_idx,

            range_kind,

            num_child_ranges: 0,

    }

        // Fix up the current range before going back to parent

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

        parent.num_child_ranges += 1;

    }

macro_rules! debug_log {

    ($format:literal) => {

    };

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

    };

}

    Visitor2, 

    VisitorResult

};

#[derive(PartialEq, Eq)]

enum DefinitionType {

    // used as an expression parent)

    expr_parent: ExpressionParent,

    // Keeping track of relative position in block in the breadth-first pass.

    relative_pos_in_block: u32,

    // Single buffer of statement IDs that we want to traverse in a block.

    // Required to work around Rust borrowing rules and to prevent constant

    // cloning of vectors.

            expr_parent: ExpressionParent::None,

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

            relative_pos_in_block: 0,

            statement_buffer: ScopedBuffer::new_reserved(STMT_BUFFER_INIT_CAPACITY),

            expression_buffer: ScopedBuffer::new_reserved(EXPR_BUFFER_INIT_CAPACITY),

        }

}

impl Visitor2 for PassValidationLinking {

    //--------------------------------------------------------------------------

    // Definition visitors

    //--------------------------------------------------------------------------

pub(crate) const KW_STRUCT:    &'static [u8] = b"struct";

pub(crate) const KW_ENUM:      &'static [u8] = b"enum";

pub(crate) const KW_UNION:     &'static [u8] = b"union";

pub(crate) const KW_PRIMITIVE: &'static [u8] = b"primitive";

pub(crate) const KW_COMPOSITE: &'static [u8] = b"composite";

pub(crate) const KW_IMPORT:    &'static [u8] = b"import";

    Code,

}

/// A range of tokens with a specific meaning. Such a range is part of a tree

/// where each parent tree envelops all of its children.

#[derive(Debug)]

pub struct TokenRange {

    // Index of parent in `TokenBuffer.ranges`, does not have a parent if the

    pub range_kind: TokenRangeKind,

    pub curly_depth: u32,

    // Offsets into `TokenBuffer.ranges`: the tokens belonging to this range.

    pub end: u32,               // last token (exclusive index)

    // Child ranges

    pub num_child_ranges: u32,  // Number of subranges

}

pub struct TokenBuffer {

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

pub(crate) struct Ctx<'p> {

    pub heap: &'p mut Heap,

    pub symbols: &'p mut SymbolTable,

    pub types: &'p mut TypeTable,

}

fn test_disallowed_inference() {

    Tester::new_single_source_expect_err(

        "argument auto inference",

    ).error(|e| { e

        .assert_msg_has(0, "inference is not allowed")

        .assert_occurs_at(0, "auto arg");

    Tester::new_single_source_expect_err(

        "return type auto inference",

    ).error(|e| { e

        .assert_msg_has(0, "inference is not allowed")

        .assert_occurs_at(0, "auto func");

    Tester::new_single_source_expect_err(

        "implicit polymorph argument auto inference",

    ).error(|e| { e

        .assert_msg_has(0, "inference is not allowed")

        .assert_occurs_at(0, "in port");

    Tester::new_single_source_expect_err(

        "explicit polymorph argument auto inference",

    ).error(|e| { e

        .assert_msg_has(0, "inference is not allowed")

        .assert_occurs_at(0, "auto> port");

    Tester::new_single_source_expect_ok(

        "single field, no comma",

    ).for_struct("Foo", |t| { t

        .assert_num_fields(1)

        .for_field("field", |f| {

        });

    });

    Tester::new_single_source_expect_ok(

        "single field, with comma",

    ).for_struct("Foo", |t| { t

        .assert_num_fields(1)

        .for_field("field", |f| { f

        });

    });

    Tester::new_single_source_expect_ok(

        "multiple fields, no comma",

    ).for_struct("Foo", |t| { t

        .assert_num_fields(3)

    });

    Tester::new_single_source_expect_ok(

        "multiple fields, with comma",

        "struct Foo{

        }"

    ).for_struct("Foo", |t| { t

        .assert_num_fields(3)

    });

}

    Tester::new("single domain name")

        .with_source("

        #module external

        ")

        .with_source("

        import external;

            auto a = external::Foo{ field: 0 };

            return a.field;

        }

    Tester::new("multi domain name")

        .with_source("

        #module external.domain

        ")

        .with_source("

        import external.domain;

            auto a = domain::Foo{ field: 0 };

            return a.field;

        }

    Tester::new("aliased domain name")

        .with_source("

        #module external

        ")

        .with_source("

        import external as aliased;

            auto a = aliased::Foo{ field: 0 };

            return a.field;

        }

    Tester::new("specific symbol")

        .with_source("

        #module external

        ")

        .with_source("

        import external::Foo;

            auto a = Foo{ field: 1 };

            auto b = Foo{ field: 2 };

            return a.field + b.field;

    Tester::new("specific aliased symbol")

        .with_source("

        #module external

        ")

        .with_source("

        import external::Foo as Bar;

            return Bar{ field: 0 }.field;

        }

        ")

    // Tester::new("import all")

    //     .with_source("

    //     #module external

    //     ")

    //     .with_source("

    //     import external::*;

    //     ")

    //     .compile()

    //     .expect_ok();

    Tester::new("specific symbols")

        .with_source("

        #module external

        ")

        .with_source("

        import external::{Foo, Bar};

            return Foo{f:0}.f + Bar{b:1}.b;

        }

        ")

    Tester::new("aliased symbols")

        .with_source("

        #module external

        ")

        .with_source("

        import external::{Foo as Bar, Bar as Foo};

            return Foo{in_bar:0}.in_bar + Bar{in_foo:0}.in_foo;    

        }")

        .compile()

    // Tester::new("import all")

    //     .with_source("

    //     #module external

    //     ")

    //     .with_source("

    //     import external::*;

    //         auto f = Foo{f:0};

    //         auto b = Bar{b:0};

    //         return f.f + b.b;

    Tester::new("unexpected polymorphic args")

        .with_source("

        #module external

        ")

        .with_source("

        import external;

            return foo.f;

        }

        ")

        ")

        .with_source("

        import external;