parser.rs

    pub fn peek(&mut self, n: usize) -> Result<Lexeme> {
        return self.get_lexeme(self.offset + n);
    }

    pub fn take(&mut self) -> Result<Lexeme> {
        self.offset += 1;

        return self.get_lexeme(self.offset - 1);
    }

    pub fn predict(&mut self, wants: Vec<LexemeType>) -> Result<()> {
        for (i, v) in wants.iter().enumerate() {
            let lexeme = self.peek(i)?;

            if !self.matched(lexeme.lexeme_type(), v) {
                return Err(ParserError::new(ParserErrorVariant::UnexpectedLexeme(lexeme, wants, "predict".to_string())));
            }
        }

        return Ok(());
    }

    pub fn consume(&mut self, wants: Vec<LexemeType>) -> Result<()> {
        let length = wants.len();

        self.predict(wants)?;

        for _ in 1..=length {
            self.take()?;
        }

        return Ok(());
    }

    pub fn parse_class(&mut self, tag: Option<Tag>) -> Result<Class> {
        let class_keyword = self.peek(0)?;
        self.consume(vec![LexemeType::Class])?;

        let class_name = self.parse_identifier()?;
        let mut parents = vec![];

        if self.consume(vec![LexemeType::IsSubTypeOf]).is_ok() {
            while self.peek(0)?.lexeme_type() != &LexemeType::LeftAngleBracket {
                parents.push(self.parse_identifier()?);

                if self.consume(vec![LexemeType::Comma]).is_err() {
                    break;
                }
                else {}
            }
        }

        let type_parameters = if self.predict(vec![LexemeType::LeftAngleBracket]).is_ok() {
            self.parse_type_parameters()?
        }
        else {
            vec![]
        };

        self.consume(vec![LexemeType::OpenBraces]);

        let members = self.parse_class_members()?;

        self.consume(vec![LexemeType::CloseBraces]);

        Ok(Class::new(
            class_keyword.lexeme_location().clone(),
            tag,
            parents,
            class_name,
            type_parameters,
            members,
        ))
    }

    pub fn parse_class_members(&mut self) -> Result<Vec<ClassMember>> {
        let mut members = vec![];

        while self.peek(0)?.lexeme_type() != &LexemeType::CloseBraces {
            if self.predict(vec![LexemeType::Identifier, LexemeType::Identifier]).is_ok() {
                let field = self.parse_class_field()?;

                members.push(ClassMember::Field(field));
            }
            else {
                let tag = self.parse_tag()?;

                if self.consume(vec![LexemeType::Accessor]).is_ok() {
                    members.push(ClassMember::StaticMethod(self.parse_method(tag)?));
                }
                else {
                    let method = self.parse_method(tag)?;

                    members.push(ClassMember::Method(method));
                }
            }
        }

        Ok(members)
    }

    pub fn parse_class_field(&mut self) -> Result<Field> {
        let location = self.peek(0)?.lexeme_location();

        let typ = self.parse_type()?;
        let field_name = self.parse_access_identifier()?;

        if self.consume(vec![LexemeType::Equal]).is_ok() {
            let expr = self.parse_expression(None, None)?;
            self.consume(vec![LexemeType::Semicolon]);

            Ok(Field::new(location, field_name, typ, Some(expr)))
        }
        else {
            self.consume(vec![LexemeType::Semicolon]);

            Ok(Field::new(location, field_name, typ, None))
        }
    }

    pub fn parse_method(&mut self, tag: Option<Tag>) -> Result<Method> {
        let location = self.peek(0)?.lexeme_location();

        let return_type = self.parse_type()?;
        let method_name = self.parse_identifier()?;

        let lexeme = self.peek(0)?;

        if lexeme.lexeme_type() == &LexemeType::OpenParenthesis {
            let parameters = self.parse_parameters()?;

            if self.predict(vec![LexemeType::Semicolon]).is_ok() {
                self.take()?;

                Ok(Method::new_declaration(location, tag, method_name, parameters, return_type))
            }
            else if self.predict_one_of(vec![LexemeType::OpenBraces, LexemeType::Equal]).is_ok() {
                let body = self.parse_body()?;

                Ok(Method::new(location, tag, method_name, parameters, return_type, body))
            }
            else {
                Err(ParserError::new(
                    ParserErrorVariant::UnexpectedLexeme(self.peek(0)?,
                                                         vec![LexemeType::OpenBraces, LexemeType::Semicolon, LexemeType::Equal],
                                                         "parse_method".to_string())
                ))
            }
        }
        else {
            Err(ParserError::new(
                ParserErrorVariant::UnexpectedLexeme(lexeme, vec![LexemeType::OpenParenthesis], "parse_method".to_string())
            ))
        }
    }

    fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
        self.consume(vec![LexemeType::OpenParenthesis])?;

        let mut params = vec![];

        while self.peek(0)?.lexeme_type() != &LexemeType::CloseParenthesis {
            // self.take()?;
            let typ = self.parse_type()?;

            self.predict(vec![LexemeType::Identifier])?;
            let param_name = self.take()?.lexeme_value();

            params.push(Parameter::new(param_name, typ));

            let lexeme = self.peek(0)?;

            match lexeme.lexeme_type() {
                LexemeType::Comma => {
                    self.take()?;
                    ()
                },
                LexemeType::CloseParenthesis => (),
                _ => {
                    return Err(ParserError::new(
                        ParserErrorVariant::UnexpectedLexeme(lexeme,
                                                             vec![LexemeType::Comma, LexemeType::CloseParenthesis],
                                                             "parse_parameters".to_string())
                    ));
                }
            }
        }

        self.consume(vec![LexemeType::CloseParenthesis])?;

        return Ok(params);
    }

    fn parse_identifier(&mut self) -> Result<String> {
        self.predict(vec![LexemeType::Identifier]);

        return Ok(self.take()?.lexeme_value());
    }

    pub fn parse_access_identifier(&mut self) -> Result<String> {
        let mut chain = vec![];

        self.predict(vec![LexemeType::Identifier])?;

        chain.push(self.take()?.lexeme_value());

        while self.peek(0)?.lexeme_type() == &LexemeType::Accessor {
            self.consume(vec![LexemeType::Accessor]);
            self.consume(vec![LexemeType::Identifier]);

            chain.push(self.take()?.lexeme_value());
        }

        return Ok(chain.join("::"));
    }

    pub fn parse_type(&mut self) -> Result<ParsedType> {
        self.predict(vec![LexemeType::Identifier])?;

        let type_name = self.parse_access_identifier()?;

        return if self.predict(vec![LexemeType::LeftAngleBracket]).is_ok() {
            let list = self.parse_many(
                LexemeType::LeftAngleBracket,
                LexemeType::RightAngleBracket,
                LexemeType::Comma,
                |parser| parser.parse_type(),
            )?;

            Ok(ParsedType::generic_type(type_name, list))
        } else {
            Ok(ParsedType::type_name(type_name))
        }
    }