refactor(ast): Split parser to multiple file
This commit is contained in:
@@ -0,0 +1,310 @@
|
||||
use crate::{
|
||||
ast::types::{
|
||||
ArrayDimension, CompileUnit, FuncDeclStmt, GlobalDeclStmt, Param, VarDeclStmt, VarDeclStmtValue,
|
||||
},
|
||||
diagnostic::span::Span,
|
||||
lexer::{
|
||||
err::ParseError,
|
||||
types::{TokenValue, TypeIdent},
|
||||
},
|
||||
};
|
||||
|
||||
use super::{ParseProcessError, ParseType, Parser};
|
||||
|
||||
impl Parser {
|
||||
pub(super) fn parse_compile_unit(&mut self) -> CompileUnit {
|
||||
let mut global_decls = vec![];
|
||||
while !self.is_eof() {
|
||||
if let Some(decl) = self.parse_global_decl_stmt() {
|
||||
global_decls.push(decl);
|
||||
} else {
|
||||
self.until_next_token(&[TokenValue::Semicolon, TokenValue::RBrace]);
|
||||
}
|
||||
}
|
||||
CompileUnit { global_decls }
|
||||
}
|
||||
|
||||
fn parse_global_decl_stmt(&mut self) -> Option<GlobalDeclStmt> {
|
||||
assert!(!self.is_eof());
|
||||
match self.parse_func_decl_stmt() {
|
||||
Ok(func_decl) => return Some(GlobalDeclStmt::FuncDecl(func_decl)),
|
||||
Err(ParseProcessError::ErrorInMatch) => {
|
||||
return None
|
||||
},
|
||||
_ => {}
|
||||
};
|
||||
match self.parse_var_decl_stmt(ParseType::MustParse) {
|
||||
Ok(var_decl) => return Some(GlobalDeclStmt::VarDecl(var_decl)),
|
||||
Err(ParseProcessError::ErrorInMatch) => {
|
||||
return None
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
let token = self.next().clone();
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::UnexpectedToken(token.value, "ident"),
|
||||
token.span,
|
||||
);
|
||||
None
|
||||
}
|
||||
// fn until_next_stmt(&mut self) {
|
||||
// // skip tokens until we find a semicolon or a right brace, which may indicate the end of the declaration
|
||||
// while let Some(t) = self.peek() {
|
||||
// if matches!(t.value, TokenValue::Semicolon | TokenValue::RBrace) {
|
||||
// self.advance(1);
|
||||
// break;
|
||||
// }
|
||||
// self.advance(1);
|
||||
// }
|
||||
// }
|
||||
fn parse_type_and_name(&mut self, parse_type: ParseType) -> Result<(TypeIdent, String, Span, Span), ParseProcessError> {
|
||||
assert!(!self.is_eof());
|
||||
let type_token = self.peek().clone();
|
||||
let type_ident = match self.peek().value.as_type_ident() {
|
||||
Some(ti) => ti,
|
||||
None => {
|
||||
if matches!(parse_type, ParseType::MustParse) {
|
||||
let token = self.next().clone();
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::UnexpectedToken(token.value, "type ident"),
|
||||
token.span,
|
||||
);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
return Err(ParseProcessError::TryNext);
|
||||
},
|
||||
};
|
||||
let type_span = type_token.span;
|
||||
self.advance(1);
|
||||
let name = match self.peek().value.as_ident() {
|
||||
None if self.is_eof() => {
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::ExpectButEof("ident"),
|
||||
type_span,
|
||||
);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
},
|
||||
None => {
|
||||
let next_span = self.peek().span;
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::CantCombineWith(type_token.value),
|
||||
next_span
|
||||
);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
Some(ident) => ident,
|
||||
};
|
||||
let name_span = self.peek().span;
|
||||
self.advance(1);
|
||||
Ok((type_ident, name, type_span, name_span))
|
||||
}
|
||||
fn parse_func_decl_stmt(&mut self) -> Result<FuncDeclStmt, ParseProcessError> {
|
||||
assert!(!self.is_eof());
|
||||
let (return_type, name, ret_type_span, name_span) = self.parse_type_and_name(ParseType::MustParse)?;
|
||||
if matches!(self.peek().value, TokenValue::LParen) {
|
||||
} else {
|
||||
self.back(2);
|
||||
return Err(ParseProcessError::TryNext);
|
||||
}
|
||||
// from here we can be sure it's a function declaration, so we can report error if the syntax is wrong
|
||||
let params = self.parse_param_list()?;
|
||||
let body = if self.is_eof() {
|
||||
let span = self.next().span;
|
||||
self.diagnostics
|
||||
.add_from_frontend_error(ParseError::ExpectButEof("function body"), span);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
} else {
|
||||
self.parse_block_stmt(ParseType::MustParse)?
|
||||
};
|
||||
Ok(FuncDeclStmt {
|
||||
return_type: return_type.into(),
|
||||
name,
|
||||
params,
|
||||
body,
|
||||
ret_type_span,
|
||||
name_span,
|
||||
})
|
||||
}
|
||||
fn parse_param_list(&mut self) -> Result<Vec<Param>, ParseProcessError> {
|
||||
assert!(!self.is_eof());
|
||||
if self.peek().value != TokenValue::LParen {
|
||||
let token = self.next().clone();
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::UnexpectedToken(token.value, "`(`"),
|
||||
token.span,
|
||||
);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
self.advance(1);
|
||||
let mut params = vec![];
|
||||
let mut last_is_var = false;
|
||||
while !self.is_eof() {
|
||||
if self.peek().value == TokenValue::RParen {
|
||||
self.advance(1);
|
||||
break;
|
||||
}
|
||||
if last_is_var {
|
||||
self.must_match_token(&TokenValue::Comma, "`,` or `)`")
|
||||
.inspect_err(|_| self.until_next_token(&[TokenValue::RBrace]))?;
|
||||
}
|
||||
match self.parse_param() {
|
||||
Ok(param) => {
|
||||
params.push(param);
|
||||
last_is_var = true;
|
||||
}
|
||||
Err(_e) => {
|
||||
self.until_next_token(&[TokenValue::RParen]);
|
||||
if self.last().value == TokenValue::RParen {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(params)
|
||||
}
|
||||
fn parse_param(&mut self) -> Result<Param, ParseProcessError> {
|
||||
assert!(!self.is_eof());
|
||||
let (param_type, name, type_span, name_span) = self.parse_type_and_name(ParseType::MustParse)?;
|
||||
Ok(Param {
|
||||
param_type: param_type.into(),
|
||||
name,
|
||||
dimensions: self.parse_array_dimensions(true)?,
|
||||
name_span,
|
||||
type_span,
|
||||
})
|
||||
}
|
||||
// fn must_match_semicolon(&mut self) -> Option<()> {
|
||||
// if self
|
||||
// .peek()
|
||||
// .is_some_and(|t| matches!(t.value, TokenValue::Semicolon))
|
||||
// {
|
||||
// self.advance(1);
|
||||
// Some(())
|
||||
// } else {
|
||||
// let token = self.next().clone();
|
||||
// self.diagnostics
|
||||
// .add_from_frontend_error(ParseError::UnexpectedToken(token.value, "`;`"), token.span);
|
||||
// while let Some(t) = self.peek() {
|
||||
// if matches!(t.value, TokenValue::Semicolon) {
|
||||
// self.advance(1);
|
||||
// break;
|
||||
// }
|
||||
// if matches!(t.value, TokenValue::RBrace) {
|
||||
// break;
|
||||
// }
|
||||
// self.advance(1);
|
||||
// }
|
||||
// None
|
||||
// }
|
||||
// }
|
||||
pub(super) fn parse_var_decl_stmt(&mut self, parse_type: ParseType) -> Result<VarDeclStmt, ParseProcessError> {
|
||||
self.parse_var_decl_stmt_inner(parse_type, true)
|
||||
}
|
||||
|
||||
pub(super) fn parse_var_decl_stmt_inner(&mut self, parse_type: ParseType, consume_semicolon: bool) -> Result<VarDeclStmt, ParseProcessError> {
|
||||
assert!(!self.is_eof());
|
||||
let mut values = vec![];
|
||||
let (var_type, name, type_span, name_span) = match self.parse_type_and_name(parse_type) {
|
||||
Ok(res) => res,
|
||||
Err(_e) => {
|
||||
if matches!(parse_type, ParseType::TryParse) {
|
||||
return Err(ParseProcessError::TryNext);
|
||||
} else {
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
}
|
||||
};
|
||||
let dimensions = self.parse_array_dimensions(false)?;
|
||||
let value = if self.peek().value == TokenValue::Equal {
|
||||
self.advance(1);
|
||||
Some(self.parse_expr()?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
values.push(VarDeclStmtValue { name, name_span, dimensions, value });
|
||||
let mut last_name = true; // indicate whether the last parsed token is a variable name
|
||||
while !self.is_eof() {
|
||||
if matches!(self.peek().value, TokenValue::Semicolon) { // statement end
|
||||
break;
|
||||
}
|
||||
if last_name { // expect a comma after a variable name
|
||||
self.must_match_token(&TokenValue::Comma, "`,` or `;`")?;
|
||||
last_name = false;
|
||||
}
|
||||
// check eof again
|
||||
if self.is_eof() {
|
||||
let span = self.last().span;
|
||||
self.diagnostics
|
||||
.add_from_frontend_error(ParseError::ExpectButEof("`,` or `;`"), span);
|
||||
break;
|
||||
}
|
||||
if let Some(ident) = self.peek().value.as_ident() {
|
||||
let span = self.next().span;
|
||||
let dimensions = self.parse_array_dimensions(false)?;
|
||||
let value = if self.peek().value == TokenValue::Equal {
|
||||
self.advance(1);
|
||||
Some(self.parse_expr()?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
values.push(VarDeclStmtValue { name: ident, name_span: span, dimensions, value });
|
||||
last_name = true;
|
||||
} else {
|
||||
let token = self.next().clone();
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::CantCombineWith(TokenValue::TypeIdent(var_type)),
|
||||
token.span,
|
||||
);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
}
|
||||
if consume_semicolon {
|
||||
self.must_match_token(&TokenValue::Semicolon, "`;`")?;
|
||||
}
|
||||
Ok(VarDeclStmt { values, type_span, data_type: var_type.into() })
|
||||
}
|
||||
|
||||
fn parse_array_dimensions(&mut self, allow_empty_first: bool) -> Result<Vec<ArrayDimension>, ParseProcessError> {
|
||||
let mut dimensions = vec![];
|
||||
while self.peek().value == TokenValue::LBracket {
|
||||
let start_span = self.next().span;
|
||||
let value = if self.peek().value == TokenValue::RBracket {
|
||||
if !allow_empty_first || !dimensions.is_empty() {
|
||||
let span = self.peek().span;
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::UnexpectedToken(TokenValue::RBracket, "array dimension expression"),
|
||||
span,
|
||||
);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
None
|
||||
} else {
|
||||
Some(self.parse_expr()?)
|
||||
};
|
||||
let end_span = match &self.peek().value {
|
||||
TokenValue::RBracket => {
|
||||
let span = self.peek().span;
|
||||
self.advance(1);
|
||||
span
|
||||
}
|
||||
TokenValue::Eof => {
|
||||
self.diagnostics.add_from_frontend_error(ParseError::ExpectButEof("`]`"), start_span);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
_ => {
|
||||
let token = self.next();
|
||||
self.diagnostics.add_from_frontend_error(
|
||||
ParseError::UnexpectedToken(token.value, "`]`"),
|
||||
token.span,
|
||||
);
|
||||
return Err(ParseProcessError::ErrorInMatch);
|
||||
}
|
||||
};
|
||||
dimensions.push(ArrayDimension {
|
||||
value,
|
||||
span: Span::from_two(start_span, end_span),
|
||||
});
|
||||
}
|
||||
Ok(dimensions)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user