}

            None => {}

        }

        // Maybe we actually want to check this in release mode. Then again:

        // a 4 gigabyte source file... Really?

        debug_assert!(self.offset < u32::max_value() as usize);

    }

    fn set_error(&mut self, msg: &str) {

        if self.had_error.is_none() {

            self.had_error = Some(ParseError::new_error_str_at_pos(self, self.pos(), msg));

        }

    }

    fn get_lookup(&self) -> RwLockReadGuard<Vec<u32>> {

        // Once constructed the lookup always contains one element. We use this

        // to see if it is constructed already.

        {

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

            if !lookup.is_empty() {

                return lookup;

            }

        }

        // Lookup was not constructed yet

        let mut lookup = self.offset_lookup.write().unwrap();

        if !lookup.is_empty() {

            // Somebody created it before we had the chance

            drop(lookup);

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

            return lookup;

        }

        // Build the line number (!) to offset lookup, so offset by 1. We 

        // assume the entire source file is scanned (most common case) for

        // preallocation.

        lookup.reserve(self.line as usize + 2);

        lookup.push(0); // line 0: never used

        lookup.push(0); // first line: first character

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

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

                lookup.push(char_idx as u32 + 1);

            }

        }

        lookup.push(self.input.len() as u32 + 1); // for lookup_line_end, intentionally adding one character

        // Return created lookup

        drop(lookup);

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

        return lookup;

    }

    /// Retrieves offset at which line starts (right after newline)

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

        let lookup = self.get_lookup();

        lookup[line_number as usize]

    }

    /// Retrieves offset at which line ends (at the newline character or the

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

        // Compensate for newlines and a potential carriage feed. Note that the

        // end position is exclusive. So we only need to compensate for a

        // "\r\n"

        if offset_usize > 0 && offset_usize < self.input.len() && self.input[offset_usize] == b'\n' && self.input[offset_usize - 1] == b'\r' {

            offset - 1

        } else {

            offset

        }

    }

}

#[derive(Debug)]

pub enum StatementKind {

    Info,

    Error

}

#[derive(Debug)]

pub enum ContextKind {

    SingleLine,

    MultiLine,

}

#[derive(Debug)]

pub struct ErrorStatement {

    pub(crate) statement_kind: StatementKind,

    pub(crate) context_kind: ContextKind,

    pub(crate) start_line: u32,

use super::*;

#[test]

fn test_function_call() {

    Tester::new_single_source_expect_ok("with literal arg", "

    func add_two(u32 value) -> u32 {

        return value + 2;

    }

    func foo() -> u32 {

        return add_two(5);

    }

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

        f.call_ok(Some(Value::UInt32(7)));

    });

    Tester::new_single_source_expect_ok("with variable arg", "

    func add_two(u32 value) -> u32 {

        value += 1;

        return value + 1;

    }

    func foo() -> bool {

        auto initial = 5;

        auto result = add_two(initial);

        return initial == 5 && result == 7;

    }").for_function("foo", |f| {

        f.call_ok(Some(Value::Bool(true)));

    });

}

#[test]

fn test_empty_blocks() {

    // Yes this is silly, but I managed to make this a bug before

    Tester::new_single_source_expect_ok("traversing empty statements", "

    func foo() -> u32 {

        auto val = 128;

        if (true) {}

        while (false) {}

        return val;

    }

    ").for_function("foo", |f| { f.call_ok(Some(Value::UInt32(128))); });

}

        func test() -> u32 {

            return 0b10011001_10012001;

        }

    ").error(|e| { e.assert_msg_has(0, "incorrectly formatted binary number"); });

    Tester::new_single_source_expect_err("no characters", "

        func test() -> u32 { return 0b; }

    ").error(|e| { e.assert_msg_has(0, "incorrectly formatted binary number"); });

    Tester::new_single_source_expect_err("only separators", "

        func test() -> u32 { return 0b____; }

    ").error(|e| { e.assert_msg_has(0, "incorrectly formatted binary number"); });

}

#[test]

fn test_string_literals() {

    Tester::new_single_source_expect_ok("valid", "

        func test() -> string {

            auto v1 = \"Hello, world!\";

            auto v2 = \"\\t\\r\\n\\\\\"; // why hello there, confusing thing

            auto v3 = \"\";

            return \"No way, dude!\";

        }

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

        .for_variable("v1", |v| { v.assert_concrete_type("string"); })

        .for_variable("v2", |v| { v.assert_concrete_type("string"); })

        .for_variable("v3", |v| { v.assert_concrete_type("string"); });

    });

    Tester::new_single_source_expect_err("unterminated simple", "

        func test() -> string { return \"'; }

    ").error(|e| { e

        .assert_num(1)

        .assert_occurs_at(0, "\"")

        .assert_msg_has(0, "unterminated");

    });

    Tester::new_single_source_expect_err("unterminated with preceding escaped", "

        func test() -> string { return \"\\\"; }

    ").error(|e| { e

        .assert_num(1)

        .assert_occurs_at(0, "\"\\")

        .assert_msg_has(0, "unterminated");

    });

    Tester::new_single_source_expect_err("invalid escaped character", "

        func test() -> string { return \"\\y\"; }

    ").error(|e| { e.assert_msg_has(0, "unsupported escape character 'y'"); });

}