}

        }

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

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

                }

            }

        }

            match cur_range.range_kind {

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

            }

            if cur_range.next_sibling_idx == NO_SIBLING {

                break;

            } else {

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

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

                                    },

                                )?;

                                ctx.heap.alloc_literal_expression(|this| LiteralExpression{

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

                                // Consume any possible embedded values

                                ctx.heap.alloc_literal_expression(|this| LiteralExpression{

                                    this,

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

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

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

        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{

    }

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

        }

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

    };

                    });

                }

            } else {

                let maybe_infer_text = if allow_inference {

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

                return Err(ParseError::new_error_at_span(

                    source, cur_element.element.full_span,

                    format!(

                    )

                ));

            }

                        SymbolVariant::Module(symbol_module) => {

                            // Expecting more identifiers

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

                            }

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

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

                            if new_symbol.is_none() {

                                    format!(

                                    )

                                ));

                            }

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

    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;

            num_child_ranges: 0,

            first_child_idx: NO_RELATION,

            last_child_idx: NO_RELATION,

        });

        // Fix up the sibling indices

        let last_registered_idx = parent_range.end;

        if last_registered_idx != first_token_idx {

        }

        // Push the new range

}

fn maybe_number_remaining(c: u8) -> bool {

    return

            c == b'_';

}

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

                        )

                    ));

        );

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

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

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

        if char == b'_' {

            continue;

        }

            return Err(ParseError::new_error_at_span(

                source, integer_span,

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

        ")

        .with_source("

        import external;

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

            return a.field;

        }

        ")

        .with_source("

        import external.domain;

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

            return a.field;

        }

        ")

        .with_source("

        import external as aliased;

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

            return a.field;

        }

        ")

        .with_source("

        import external::Foo;

            auto a = Foo{ field: 1 };

            auto b = Foo{ field: 2 };

            return a.field + b.field;

        ")

        .with_source("

        import external::Foo as Bar;

            return Bar{ field: 0 }.field;

        }

        ")

        ")

        .with_source("

        import external::{Foo, Bar};

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

        }

        ")

        ")

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

        ")

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

        import external;

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

            return foo.f;

        }")

        .expect_err()

        .error(|e| { e

            .assert_msg_has(0, "expected 1 polymorphic")

        });

    Tester::new("module as type")

        ")

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

        import mod2;

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

            return var.f.f;

        }")

        .compile()

        .expect_err()

        .error(|e| { e

        });

}

        });

    });

}

#[test]

        "no polymorphic vars",

        "

        enum Choice { A, B }

            auto foo = Choice::A;

            auto bar = Choice::B;

            return 0;

            B,

        }

        func fix_as_s8(Choice<s8> arg) -> s32 { return 0; }

            auto choice_s8 = Choice::A;

            auto choice_s32_1 = Choice::B;

            Choice<auto> choice_s32_2 = Choice::B;

            fix_as_s8(choice_s8);

            fix_as_s32(choice_s32_1);

        }

        "

    ).for_function("test_instances", |f| { f

            .assert_parser_type("auto")

            .assert_concrete_type("Choice<s8>");

        })

            .assert_parser_type("auto")

        })

            .assert_parser_type("Choice<auto>")

        });

    });

        "two polymorphic vars",

        "

        enum Choice<T1, T2>{ A, B, }

            Choice<s8, auto> choice1 = Choice::A;

            Choice<auto, auto> choice3 = Choice::B;

            auto choice4 = Choice::B;

            fix_t1(choice1); fix_t1(choice2); fix_t1(choice3); fix_t1(choice4);

    ).for_function("test_instances", |f| { f

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

            .assert_parser_type("Choice<s8,auto>")

        })

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

        })

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

            .assert_parser_type("Choice<auto,auto>")

        })

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

            .assert_parser_type("auto")

        });

    });

}

        "struct literal inference mismatch",

        "

        struct Pair<T>{ T first, T second }

            s8 first_arg = 5;

            s64 second_arg = 2;

            auto pair = Pair{ first: first_arg, second: second_arg };

        func call() -> s32 {

            auto a = Uninteresting::Variant;

            fix_t<s8>(a);

            return 4;

        }

        "

    ).error(|e| { e

        .assert_num(2)

        .assert_any_msg_has("type 'Uninteresting<s8>'")

    });

    Tester::new_single_source_expect_err(

        .assert_occurs_at(0, ".")

        .assert_msg_has(0, "Conflicting type for polymorphic variable 'Shazam'")

        .assert_msg_has(1, "inferred it to 's8'")

    });

    // TODO: Needs better error messages anyway, but this failed before

        "single polymorph",

        "

        struct Number<T>{ T number }

            auto a = Number<s8>{ number: 0 };

            auto b = Number<s8>{ number: 1 };

            auto c = Number<s32>{ number: 2 };

        "no polymorph",

        "

        enum Answer{ Yes, No }