for char_idx in 0..self.input.len() {

            if self.input[char_idx] == b'\n' {

                lookup.push(char_idx as u32 + 1);

            }

        }

        debug_assert_eq!(self.line as usize + 2, lookup.len(), "remove me: i am a testing assert and sometimes invalid");

        // Return created lookup

        drop(lookup);

        let lookup = self.offset_lookup.read().unwrap();

        return lookup;

    /// preceding carriage feed for \r\n-encoded newlines)

    fn lookup_line_end_offset(&self, line_number: u32) -> u32 {

        let lookup = self.get_lookup();

        let offset = lookup[(line_number + 1) as usize] - 1;

        let offset_usize = offset as usize;

        } else {

            offset

        }

    }

}

                }

            }

        }

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

            let first_idx = first_col as usize - 1;

            let last_idx = last_col as usize - 1;

                }

            }

        }

        // Write source context

        writeln!(f, " | ")?;

        loop {

            let range_idx_usize = range_idx as usize;

            let cur_range = &module.tokens.ranges[range_idx_usize];

            match cur_range.range_kind {

                TokenRangeKind::Module => unreachable!(), // should not be reachable

            }

            if cur_range.next_sibling_idx == NO_SIBLING {

                break;

            } else {

                range_idx = cur_range.next_sibling_idx;

            }

        }

                                    |source, iter, ctx| {

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

                                        consume_token(source, iter, TokenKind::Colon)?;

                                        let value = self.consume_expression(module, iter, ctx)?;

                                        Ok(LiteralStructField{ identifier, value, field_idx: 0 })

                                    },

                                )?;

                                ctx.heap.alloc_literal_expression(|this| LiteralExpression{

                                    this,

                                    span: InputSpan::from_positions(ident_span.begin, last_token),

                                    value: Literal::Struct(LiteralStruct{

                            Definition::Union(_) => {

                                // Union literal: consume the variant

                                consume_token(&module.source, iter, TokenKind::ColonColon)?;

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

                                // Consume any possible embedded values

                                ctx.heap.alloc_literal_expression(|this| LiteralExpression{

                                    this,

                                    span: InputSpan::from_positions(ident_span.begin, end_pos),

                                    value: Literal::Union(LiteralUnion{

                                        parser_type, variant, values,

                        ))

                    }

                }

            } else {

                // Check for builtin keywords or builtin functions

                if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {

                    // Parse builtin literal

                    let value = match ident_text {

                        KW_LIT_NULL => Literal::Null,

                        KW_LIT_TRUE => Literal::True,

                        KW_LIT_FALSE => Literal::False,

                        _ => unreachable!(),

                        span: ident_span,

                        value,

                        parent: ExpressionParent::None,

                        concrete_type: ConcreteType::default(),

                    }).upcast()

                } else {

                    iter.consume();

                        return Err(ParseError::new_error_str_at_span(&module.source, ident_span, "unknown identifier"));

                    }

                    let ident_text = ctx.pool.intern(ident_text);

                    let identifier = Identifier { span: ident_span, value: ident_text };

                    ctx.heap.alloc_variable_expression(|this| VariableExpression {

/// a builtin type or a user-defined type. The fact that it may contain

/// polymorphic arguments makes it a tree-like structure. Because we cannot rely

/// on knowing the exact number of polymorphic arguments we do not check for

/// these.

///

/// Note that the first depth index is used as a hack.

fn consume_parser_type(

    source: &InputSource, iter: &mut TokenIter, symbols: &SymbolTable, heap: &Heap, poly_vars: &[Identifier],

    cur_scope: SymbolScope, wrapping_definition: DefinitionId, allow_inference: bool, first_angle_depth: i32,

) -> Result<ParserType, ParseError> {

    struct Entry{

        element: ParserTypeElement,

        depth: i32,

    }

    fn insert_array_before(elements: &mut Vec<Entry>, depth: i32, span: InputSpan) {

        let index = elements.iter().rposition(|e| e.depth == depth).unwrap();

        elements.insert(index, Entry{

            element: ParserTypeElement{ full_span: span, variant: ParserTypeVariant::Array },

            depth,

        });

    }

    // Most common case we just have one type, perhaps with some array

    let element = consume_parser_type_ident(source, iter, symbols, heap, poly_vars, cur_scope, wrapping_definition, allow_inference)?;

    if iter.next() != Some(TokenKind::OpenAngle) {

        let mut num_array = 0;

        while iter.next() == Some(TokenKind::OpenSquare) {

            iter.consume();

            consume_token(source, iter, TokenKind::CloseSquare)?;

            num_array += 1;

        }

        let array_span = element.full_span;

        for _ in 0..num_array {

            elements.push(ParserTypeElement{ full_span: array_span, variant: ParserTypeVariant::Array });

        }

        elements.push(element);

        return Ok(ParserType{ elements });

    };

    // We have a polymorphic specification. So we start by pushing the item onto

    // our stack, then start adding entries together with the angle-brace depth

    // at which they're found.

                    elements.insert(idx + 1, Entry{

                        element: ParserTypeElement{ full_span: inserted_span, variant: ParserTypeVariant::Inferred },

                        depth: inserted_depth,

                    });

                }

            } else {

                let maybe_infer_text = if allow_inference {

                    " (or none, to perform implicit type inference)"

                } else {

                    ""

                };

                return Err(ParseError::new_error_at_span(

                    source, cur_element.element.full_span,

                    format!(

                    )

                ));

            }

        }

        idx += 1;

                loop {

                    match &last_symbol.variant {

                        SymbolVariant::Module(symbol_module) => {

                            // Expecting more identifiers

                            if Some(TokenKind::ColonColon) != iter.next() {

                            }

                            consume_token(source, iter, TokenKind::ColonColon)?;

                            // Consume next part of type and prepare for next

                            // lookup loop

                            type_text = next_text;

                            type_span.end = next_span.end;

                            scope = SymbolScope::Module(symbol_module.root_id);

                            let new_symbol = symbols.get_symbol_by_name_defined_in_scope(scope, type_text);

                            if new_symbol.is_none() {

                                    format!(

                                    )

                                ));

                            }

                            last_symbol = new_symbol.unwrap();

                        },

                        SymbolVariant::Definition(symbol_definition) => {

            }

            let next = iter.next();

            if Some(TokenKind::Ident) == next {

                // Importing a single symbol

                let (imported_symbol, symbol_definition) = consume_symbol_and_maybe_alias(

                    &module.source, &mut iter, ctx, &module_identifier.value, target_root_id

                )?;

                let alias_identifier = match imported_symbol.alias.as_ref() {

                    Some(alias) => alias.clone(),

        // 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_registered_idx = target.ranges[0].end;

        let last_token_idx = target.tokens.len() as u32;

        if last_registered_idx != last_token_idx {

        }

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

        has_newline

    }

    fn add_code_range(

        &mut self, target: &mut TokenBuffer, parent_idx: i32,

    ) {

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

        let parent_range = &mut target.ranges[parent_idx as usize];

        let sibling_idx = parent_range.last_child_idx;

        parent_range.last_child_idx = new_range_idx;

        parent_range.end = code_end_idx;

        parent_range.num_child_ranges += 1;

            curly_depth,

            start: code_start_idx,

            end: code_end_idx,

            num_child_ranges: 0,

            first_child_idx: NO_RELATION,

            last_child_idx: NO_RELATION,

        });

        // Fix up the sibling indices

        if sibling_idx != NO_RELATION {

            let sibling_range = &mut target.ranges[sibling_idx as usize];

            sibling_range.next_sibling_idx = new_range_idx;

        if parent_range.first_child_idx == NO_RELATION {

            parent_range.first_child_idx = new_range_idx;

        }

        let last_registered_idx = parent_range.end;

        if last_registered_idx != first_token_idx {

        }

        // Push the new range

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

        let curly_depth = self.curly_stack.len() as u32;

        target.ranges.push(TokenRange{

fn is_integer_literal_start(c: u8) -> bool {

    return c >= b'0' && c <= b'9';

}

fn maybe_number_remaining(c: u8) -> bool {

    return

            c == b'_';

}

#[cfg(test)]

mod tests {

    use super::*;

                });

                if variant_idx.is_none() {

                    let literal = ctx.heap[id].value.as_union();

                    let ast_definition = ctx.heap[literal.definition].as_union();

                    return Err(ParseError::new_error_at_span(

                        &ctx.module.source, literal.parser_type.elements[0].full_span, format!(

                            literal.variant.value.as_str(), ast_definition.identifier.value.as_str()

                        )

                    ));

                }

                literal.variant_idx = variant_idx.unwrap();

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

        Err(err) => Err(err)

    }

}

/// Consumes an integer literal, may be binary, octal, hexadecimal or decimal,

/// and may have separating '_'-characters.

pub(crate) fn consume_integer_literal(source: &InputSource, iter: &mut TokenIter, buffer: &mut String) -> Result<(u64, InputSpan), ParseError> {

    if Some(TokenKind::Integer) != iter.next() {

        return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected an integer literal"));

    }

    let integer_span = iter.next_span();

    iter.consume();

    buffer.clear();

    for char_idx in input_offset..integer_text.len() {

        let char = integer_text[char_idx];

        if char == b'_' {

            continue;

        }

            return Err(ParseError::new_error_at_span(

                source, integer_span,

                format!("incorrectly formatted {} number", radix_name)

            ));

        }

        buffer.push(char::from(char));

        .with_source("

        #module external

        struct Foo { s32 field }

        ")

        .with_source("

        import external;

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

            return a.field;

        }

        ")

        .compile()

        .expect_ok();

        .with_source("

        #module external.domain

        struct Foo { s32 field }

        ")

        .with_source("

        import external.domain;

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

            return a.field;

        }

        ")

        .compile()

        .expect_ok();

        .with_source("

        #module external

        struct Foo { s32 field }

        ")

        .with_source("

        import external as aliased;

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

            return a.field;

        }

        ")

        .compile()

        .expect_ok();

        .with_source("

        #module external

        struct Foo { s32 field }

        ")

        .with_source("

        import external::Foo;

            auto a = Foo{ field: 1 };

            auto b = Foo{ field: 2 };

            return a.field + b.field;

        }")

        .compile()

        .expect_ok();

        .with_source("

        #module external

        struct Foo { s32 field }

        ")

        .with_source("

        import external::Foo as Bar;

            return Bar{ field: 0 }.field;

        }

        ")

        .compile()

        .expect_ok();

        #module external

        struct Foo { s8 f }

        struct Bar { s8 b }

        ")

        .with_source("

        import external::{Foo, Bar};

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

        }

        ")

        .compile()

        .expect_ok();

        #module external

        struct Foo { s8 in_foo }

        struct Bar { s8 in_bar }

        ")

        .with_source("

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

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

        }")

        .compile()

        .expect_ok();

}

#[test]

fn test_illegal_import_use() {

    Tester::new("unexpected polymorphic args")

        .with_source("

        #module external

        struct Foo { s8 f }

        ")

        .with_source("

        import external;

            auto foo = external::Foo<s32>{ f: 0 };

            return foo.f;

        }

        ")

        .compile()

        .expect_err()

        .error(|e| { e

        });

    Tester::new("mismatched polymorphic args")

        .with_source("

        #module external

        struct Foo<T>{ T f }

        ")

        .with_source("

        import external;

            auto foo = external::Foo<s8, s32>{ f: 0 };

            return foo.f;

        }")

        .compile()

        .expect_err()

        .error(|e| { e

            .assert_msg_has(0, "expected 1 polymorphic")

        });

    Tester::new("module as type")

        .with_source("

        #module external

        ")

        .with_source("

        import external;

            auto foo = external{ f: 0 };

            return 0;

        }

        ")

        .compile()

        .expect_err()

        .error(|e| { e

        });

        .with_source("

        #module external

        ")

        .with_source("

        .compile()

        .expect_err()

        .error(|e| { e

        });

    Tester::new("import from another import")

        .with_source("

        #module mod1

        struct Foo { s8 f }

        #module mod2

        import mod1::Foo;

        struct Bar { Foo f }

        ")

        .with_source("

        import mod2;

            auto bar = mod2::Bar{ f: mod2::Foo{ f: 0 } };

            return var.f.f;

        }")

        .compile()

        .expect_err()

        .error(|e| { e

        });

}

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

            .assert_parser_type("auto")

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

        });

    });