pub fn seek(&mut self, pos: InputPosition) {

        debug_assert!(pos.offset < self.input.len());

        self.line = pos.line;

        self.column = pos.column;

        self.offset = pos.offset;

    }

    pub fn is_eof(&self) -> bool {

        self.next() == None

    }

    pub fn next(&self) -> Option<u8> {

        if self.offset < self.input.len() {

                break;

            }

            end += 1;

        }

        &source.input[start..end]

    }

    fn eval_error<S: ToString>(&self, message: S) -> EvalError {

        EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }

    }

    pub(crate) fn col(&self) -> usize { self.column }

}

        Ok(())

    }

}

#[derive(Debug)]

    pub(crate) statements: Vec<ParseErrorStatement>

}

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        if self.statements.is_empty() {

            return Ok(())

        }

        self.statements[0].fmt(f)?;

        }

        Ok(())

    }

}

    pub fn empty() -> Self {

        Self{ statements: Vec::new() }

    }

    pub fn new_error(source: &InputSource, position: InputPosition, msg: &str) -> Self {

        Self{ statements: vec!(ParseErrorStatement::from_source(ParseErrorType::Error, source, position, msg))}

}

impl Lexer<'_> {

    pub fn new(source: &mut InputSource) -> Lexer {

        Lexer { source, level: 0 }

    }

    }

        let mut result: Vec<u8> = Vec::new();

        let mut next = self.source.next();

        while next.is_some() && next != Some(b'\n') && next != Some(b'\r') {

            if !(is_vchar(next) || is_wsp(next)) {

                return Err(self.error_at_pos("Expected visible character or whitespace"));

            }

        }

        if next == Some(b'\r') && self.source.next() == Some(b'\n') {

            self.source.consume();

        }

        Ok(result)

    }

        let mut found = false;

        let mut next = self.source.next();

        while next.is_some() {

            if next == Some(b' ')

                || next == Some(b'\t')

                || next == Some(b'\r')

        // Word boundary

        let next = self.source.lookahead(keyword.len());

        if next.is_none() { return true; }

        return !is_ident_rest(next);

    }

        let len = keyword.len();

        for i in 0..len {

            let expected = Some(lowercase(keyword[i]));

            let next = self.source.next();

            if next != expected {

                return Err(self.error_at_pos(&format!("Expected keyword '{}'", String::from_utf8_lossy(keyword))));

        }

        Ok(())

    }

    fn has_string(&self, string: &[u8]) -> bool {

        self.source.has(string)

    }

        let len = string.len();

        for i in 0..len {

            let expected = Some(string[i]);

            let next = self.source.next();

            if next != expected {

                return Err(self.error_at_pos(&format!("Expected {}", String::from_utf8_lossy(string))));

    /// `Ok(None)` will be returned. Otherwise will consume the comma separated

    /// values, allowing a trailing comma. If no comma is found and the closing

    /// delimiter is not found, then a parse error with `expected_end_msg` is

    /// returned.

    fn consume_comma_separated<T, F>(

        &mut self, h: &mut Heap, open: u8, close: u8, expected_end_msg: &str, func: F

    {

        if Some(open) != self.source.next() {

            return Ok(None)

        }

        self.source.consume();

        loop {

            if Some(close) == self.source.next() {

                self.source.consume();

                break;

            } else if !had_comma {

                    &self.source, self.source.pos(), expected_end_msg

                ));

            }

            elements.push(func(self, h)?);

            self.consume_whitespace(false)?;

            if had_comma {

                self.source.consume();

                if self.consume_whitespace(false).is_err() { return Err(()); }

            }

        }

    }

        if !self.has_identifier() {

            return Err(self.error_at_pos("Expected identifier"));

        }

        let mut result = Vec::new();

        let mut next = self.source.next();

        result.push(next.unwrap());

        }

        Ok(result)

    }

    fn has_integer(&mut self) -> bool {

        is_integer_start(self.source.next())

    }

        let position = self.source.pos();

        let mut data = Vec::new();

        let mut next = self.source.next();

        while is_integer_rest(next) {

            data.push(next.unwrap());

            self.source.consume();

                // Assume decimal

                let data = String::from_utf8_lossy(&data);

                i64::from_str_radix(&data, 10)

            };

            if let Err(_err) = parsed {

            }

            Ok(parsed.unwrap())

        }

    }

        if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {

            return false;

        }

        let next = self.source.next();

        is_ident_start(next)

    }

        if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {

            return Err(self.error_at_pos("Expected identifier"));

        }

        let position = self.source.pos();

        let value = self.consume_ident()?;

        Ok(Identifier{ position, value })

    }

        if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {

            return Err(self.error_at_pos("Expected identifier"));

        }

        self.consume_ident()?;

        Ok(())

    }

        if self.has_reserved() {

            return Err(self.error_at_pos("Encountered reserved keyword"));

        }

        // Consumes a part of the namespaced identifier, returns a boolean

        // indicating whether polymorphic arguments were specified.

        //  arguments, assume we have reached the end of the namespaced 

        //  identifier and are instead dealing with a less-than operator. Ugly?

        //  Yes. Needs tokenizer? Yes. 

        fn consume_part(

            l: &mut Lexer, h: &mut Heap, ident: &mut NamespacedIdentifier,

            backup_pos: &mut InputPosition

            // Consume identifier

            if !ident.value.is_empty() {

                ident.value.extend(b"::");

            }

            let ident_start = ident.value.len();

            ident.value.extend(l.consume_ident()?);

        }

        self.source.seek(backup_pos);

        Ok(ident)

    }

        if self.has_reserved() {

            return Err(self.error_at_pos("Encountered reserved keyword"));

        }

        debug_log!("consume_nsident2_spilled: {}", debug_line!(self.source));

            l.consume_ident()?;

            *backup_pos = l.source.pos();

            l.consume_whitespace(false)?;

            match l.maybe_consume_poly_args_spilled_without_pos_recovery() {

                Ok(true) => { *backup_pos = l.source.pos(); },

                Ok(false) => {},

    // Types and type annotations

    /// Consumes a type definition. When called the input position should be at

    /// the type specification. When done the input position will be at the end

    /// of the type specifications (hence may be at whitespace).

        // Small helper function to convert in/out polymorphic arguments. Not

        // pretty, but return boolean is true if the error is due to inference

        // not being allowed

        let reduce_port_poly_args = |

            heap: &mut Heap,

            port_pos: &InputPosition,

                1 => Ok(args[0]),

                _ => Err(false)

            }

        };

        // Consume the type

        let pos = self.source.pos();

        let parser_type_variant = if self.has_keyword(b"msg") {

            self.consume_keyword(b"msg")?;

            ParserTypeVariant::Message

        } else if self.has_keyword(b"boolean") {

            self.consume_keyword(b"boolean")?;

            ParserTypeVariant::Long

        } else if self.has_keyword(b"str") {

            self.consume_keyword(b"str")?;

            ParserTypeVariant::String

        } else if self.has_keyword(b"auto") {

            if !allow_inference {

                        &self.source, pos,

                        "Type inference is not allowed here"

                ));

            }

            self.consume_keyword(b"auto")?;

                .map_err(|infer_error|  {

                    let msg = if infer_error {

                        "Type inference is not allowed here"

                    } else {

                        "Type 'in' only allows for 1 polymorphic argument"

                    };

                })?;

            ParserTypeVariant::Input(poly_arg)

        } else if self.has_keyword(b"out") {

            self.consume_keyword(b"out")?;

            let poly_args = self.consume_polymorphic_args(h, allow_inference)?.unwrap_or_default();

            let poly_arg = reduce_port_poly_args(h, &pos, poly_args)

                .map_err(|infer_error| {

                    let msg = if infer_error {

                        "Type inference is not allowed here"

                    } else {

                        "Type 'out' only allows for 1 polymorphic argument, but {} were specified"

                    };

                })?;

            ParserTypeVariant::Output(poly_arg)

        } else {

            // Must be a symbolic type

            let identifier = self.consume_namespaced_identifier(h)?;

            ParserTypeVariant::Symbolic(SymbolicParserType{identifier, variant: None, poly_args2: Vec::new()})

        // If the type was a basic type (not supporting polymorphic type

        // arguments), then we make sure the user did not specify any of them.

        let mut backup_pos = self.source.pos();

        if !parser_type_variant.supports_polymorphic_args() {

            self.consume_whitespace(false)?;

            if let Some(b'<') = self.source.next() {

                    &self.source, self.source.pos(),

                    "This type does not allow polymorphic arguments"

                ));

            }

            self.source.seek(backup_pos);

                });

                backup_pos = self.source.pos();

                // In case we're dealing with another array

                self.consume_whitespace(false)?;

            } else {

                    &self.source, pos,

                    "Expected a closing ']'"

                ));

            }

        }

    /// the input position will remain unmodified and an empty vector will be

    /// returned.

    ///

    /// Polymorphic arguments represent the specification of the parametric

    /// types of a polymorphic type: they specify the value of the polymorphic

    /// type's polymorphic variables.

        self.consume_comma_separated(

            h, b'<', b'>', "Expected the end of the polymorphic argument list",

        )

    }

    /// Consumes polymorphic variables. These are identifiers that are used

    /// within polymorphic types. The input position may be at whitespace. If

    /// polymorphic variables are present then the whitespace, wrapping

    /// delimiters and the polymorphic variables are consumed. Otherwise the

    /// input position will stay where it is. If no polymorphic variables are

    /// present then an empty vector will be returned.

        let backup_pos = self.source.pos();

        match self.consume_comma_separated(

            h, b'<', b'>', "Expected the end of the polymorphic variable list",

            |lexer, _heap| lexer.consume_identifier()

        )? {

            Some(poly_vars) => Ok(poly_vars),

            }

        }

    }

    // Parameters

        self.consume_whitespace(true)?;

        let position = self.source.pos();

        let identifier = self.consume_identifier()?;

        let id =

            h.alloc_parameter(|this| Parameter { this, position, parser_type, identifier });

        Ok(id)

    }

        match self.consume_comma_separated(

            h, b'(', b')', "Expected the end of the parameter list",

            |lexer, heap| lexer.consume_parameter(heap)

        )? {

            Some(params) => Ok(params),

            None => {

                    &self.source, self.source.pos(),

                    "Expected a parameter list"

                ))

            }

        }

    }

    // ====================

    // Expressions

    // ====================

        self.consume_string(b"(")?;

        self.consume_whitespace(false)?;

        let result = self.consume_expression(h)?;

        self.consume_whitespace(false)?;

        self.consume_string(b")")?;

        Ok(result)

    }

        if self.level >= MAX_LEVEL {

            return Err(self.error_at_pos("Too deeply nested expression"));

        }

        self.level += 1;

        let result = self.consume_assignment_expression(h);

        self.level -= 1;

        result

    }

        let result = self.consume_conditional_expression(h)?;

        self.consume_whitespace(false)?;

        if self.has_assignment_operator() {

            let position = self.source.pos();

            let left = result;

            let operation = self.consume_assignment_operator()?;

            || self.has_string(b"<<=")

            || self.has_string(b">>=")

            || self.has_string(b"&=")

            || self.has_string(b"^=")

            || self.has_string(b"|=")

    }

        if self.has_string(b"=") {

            self.consume_string(b"=")?;

            Ok(AssignmentOperator::Set)

        } else if self.has_string(b"*=") {

            self.consume_string(b"*=")?;

            Ok(AssignmentOperator::Multiplied)

            self.consume_string(b"|=")?;

            Ok(AssignmentOperator::BitwiseOred)

        } else {

            Err(self.error_at_pos("Expected assignment operator"))

        }

    }

        let result = self.consume_concat_expression(h)?;

        self.consume_whitespace(false)?;

        if self.has_string(b"?") {

            let position = self.source.pos();

            let test = result;

            self.consume_string(b"?")?;

            })

            .upcast())

        } else {

            Ok(result)

        }

    }

        let mut result = self.consume_lor_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"@") {

            let position = self.source.pos();

            let left = result;

            self.consume_string(b"@")?;

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_land_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"||") {

            let position = self.source.pos();

            let left = result;

            self.consume_string(b"||")?;

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_bor_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"&&") {

            let position = self.source.pos();

            let left = result;

            self.consume_string(b"&&")?;

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_xor_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"|") && !self.has_string(b"||") && !self.has_string(b"|=") {

            let position = self.source.pos();

            let left = result;

            self.consume_string(b"|")?;

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_band_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"^") && !self.has_string(b"^=") {

            let position = self.source.pos();

            let left = result;

            self.consume_string(b"^")?;

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_eq_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"&") && !self.has_string(b"&&") && !self.has_string(b"&=") {

            let position = self.source.pos();

            let left = result;

            self.consume_string(b"&")?;

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_rel_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"==") || self.has_string(b"!=") {

            let position = self.source.pos();

            let left = result;

            let operation;

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_shift_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"<=")

            || self.has_string(b">=")

            || self.has_string(b"<") && !self.has_string(b"<<=")

            || self.has_string(b">") && !self.has_string(b">>=")

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_add_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"<<") && !self.has_string(b"<<=")

            || self.has_string(b">>") && !self.has_string(b">>=")

        {

            let position = self.source.pos();

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_mul_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"+") && !self.has_string(b"+=")

            || self.has_string(b"-") && !self.has_string(b"-=")

        {

            let position = self.source.pos();

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        let mut result = self.consume_prefix_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"*") && !self.has_string(b"*=")

            || self.has_string(b"/") && !self.has_string(b"/=")

            || self.has_string(b"%") && !self.has_string(b"%=")

        {

                    concrete_type: ConcreteType::default(),

                })

                .upcast();

        }

        Ok(result)

    }

        if self.has_string(b"+")

            || self.has_string(b"-")

            || self.has_string(b"~")

            || self.has_string(b"!")

        {

            let position = self.source.pos();

                    concrete_type: ConcreteType::default(),

                })

                .upcast());

        }

        self.consume_postfix_expression(h)

    }

        let mut result = self.consume_primary_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"++")

            || self.has_string(b"--")

            || self.has_string(b"[")

            || (self.has_string(b".") && !self.has_string(b".."))

                    })

                    .upcast();

            }

        }

        Ok(result)

    }

        if self.has_string(b"(") {

            return self.consume_paren_expression(h);

        }

        if self.has_string(b"{") {

            return Ok(self.consume_array_expression(h)?.upcast());

        }

        }

        if self.has_call_expression() {

            return Ok(self.consume_call_expression(h)?.upcast());

        }

        Ok(self.consume_variable_expression(h)?.upcast())

    }

        let position = self.source.pos();

        let mut elements = Vec::new();

        self.consume_string(b"{")?;

        self.consume_whitespace(false)?;

        if !self.has_string(b"}") {

            while self.source.next().is_some() {

            || self.has_keyword(b"true")

            || self.has_keyword(b"false")

    }

    fn consume_builtin_literal_expression(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        let value;

        if self.has_keyword(b"null") {

            self.consume_keyword(b"null")?;

            value = Literal::Null;

        } else if self.has_keyword(b"true") {

            self.source.next() == Some(b'{');

        self.source.seek(backup_pos);

        return result;

    }

        // Consume identifier and polymorphic arguments

        debug_log!("consume_struct_literal_expression: {}", debug_line!(self.source));

        let position = self.source.pos();

        let identifier = self.consume_namespaced_identifier(h)?;

        self.consume_whitespace(false)?;

                let value = lexer.consume_expression(heap)?;

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

            }

        )? {

            Some(fields) => fields,

                self.source, self.source.pos(),

                "A struct literal must be followed by its field values"

            ))

        };

        Ok(h.alloc_literal_expression(|this| LiteralExpression{

            result = true;

        }

        self.source.seek(backup_pos);

        return result;

    }

        let position = self.source.pos();

        // Consume method identifier

        // TODO: @token Replace this conditional polymorphic arg parsing once we have a tokenizer.

        debug_log!("consume_call_expression: {}", debug_line!(self.source));

        let method;

            concrete_type: ConcreteType::default(),

        }))

    }

    fn consume_variable_expression(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        debug_log!("consume_variable_expression: {}", debug_line!(self.source));

        // TODO: @token Reimplement when tokenizer is implemented, prevent ambiguities

        let identifier = identifier_as_namespaced(self.consume_identifier()?);

    /// statement is nested too deeply.

    ///

    /// `wrap_in_block` may be set to true to ensure that the parsed statement

    /// will be wrapped in a block statement if it is not already a block

    /// statement. This is used to ensure that all `if`, `while` and `sync`

    /// statements have a block statement as body.

        if self.level >= MAX_LEVEL {

            return Err(self.error_at_pos("Too deeply nested statement"));

        }

        self.level += 1;

        let result = self.consume_statement_impl(h, wrap_in_block);

        self.level -= 1;

            // next character is ':', second character is NOT ':'

            result = Some(b':') == self.source.next() && Some(b':') != self.source.lookahead(1)

        }

        self.source.seek(backup_pos);

        return result;

    }

        // Parse and allocate statement

        let mut must_wrap = true;

        let mut stmt_id = if self.has_string(b"{") {

            must_wrap = false;

            self.consume_block_statement(h)?

        } else if self.has_keyword(b"skip") {

            }

        }

        self.source.seek(backup_pos);

        return result;

    }

        let position = self.source.pos();

        let mut statements = Vec::new();

        self.consume_string(b"{")?;

        self.consume_whitespace(false)?;

        while self.has_local_statement() {

            let (local_id, stmt_id) = self.consume_local_statement(h)?;

                locals: Vec::new(),

                labels: Vec::new(),

            })

            .upcast())

        }

    }

        if self.has_keyword(b"channel") {

            let local_id = self.consume_channel_statement(h)?.upcast();

            Ok((local_id, None))

        } else {

            let (memory_id, stmt_id) = self.consume_memory_statement(h)?;

            Ok((memory_id.upcast(), Some(stmt_id)))