jessebrault/deimos-lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Parser refactoring for Option<Expression>.

Browse Source
This commit is contained in:
Jesse Brault 2026-08-20 20:01:47 -05:00
parent a4b9b958e9
commit 05a1f5d091
1 changed files with 217 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

297
dmc-lib/src/parser.rs
View File

@ -62,7 +62,7 @@ pub fn parse_statement(input: &str) -> ParseResult<Option<Statement>> {
(statement, diagnostics)
}
pub fn parse_expression(input: &str) -> ParseResult<Expression> {
pub fn parse_expression(input: &str) -> ParseResult<Option<Expression>> {
let mut parser = Parser::new(input);
let mut diagnostics = Vec::new();
diagnostics.append(&mut parser.advance());
@ -918,9 +918,9 @@ impl<'a> Parser<'a> {
let initializer = if self.current.is_some() && self.peek_current(TokenKind::Equals) {
diagnostics.append(&mut self.advance()); // equals
let (expression, mut ds) = self.expression();
let (maybe_expression, mut ds) = self.expression();
diagnostics.append(&mut ds);
Some(expression)
maybe_expression
} else {
None
};
@ -961,10 +961,7 @@ impl<'a> Parser<'a> {
Some(let_statement) => (Some(Statement::Let(let_statement)), diagnostics),
}
}
_ => {
let (statement, diagnostics) = self.expression_statement_or_assign_statement();
(Some(statement), diagnostics)
}
_ => self.expression_statement_or_assign_statement(),
}
}
@ -987,65 +984,100 @@ impl<'a> Parser<'a> {
let (_, mut ds) = self.expect_advance(TokenKind::Equals);
diagnostics.append(&mut ds);
let (expression, mut ds) = self.expression();
let (maybe_expression, mut ds) = self.expression();
diagnostics.append(&mut ds);
if let Some(identifier) = maybe_identifier {
let let_statement = LetStatement::new(
self.next_node_id(),
self.token_text(&identifier),
SourceRange::new(identifier.start(), identifier.end()),
is_mut,
expression,
);
(Some(let_statement), diagnostics)
} else {
(None, diagnostics)
}
let identifier = match maybe_identifier {
Some(identifier) => identifier,
None => {
return (None, diagnostics);
}
};
let expression = match maybe_expression {
Some(expression) => expression,
None => {
return (None, diagnostics);
}
};
let let_statement = LetStatement::new(
self.next_node_id(),
self.token_text(&identifier),
SourceRange::new(identifier.start(), identifier.end()),
is_mut,
expression,
);
(Some(let_statement), diagnostics)
}
fn expression_statement_or_assign_statement(&mut self) -> ParseResult<Statement> {
fn expression_statement_or_assign_statement(&mut self) -> ParseResult<Option<Statement>> {
let mut diagnostics = Vec::new();
let (base, mut ds) = self.expression();
let (maybe_base, mut ds) = self.expression();
diagnostics.append(&mut ds);
let base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
if self.current.is_some() && self.peek_current(TokenKind::Equals) {
let (assign_statement, mut ds) = self.assign_rhs(base);
let (maybe_assign_statement, mut ds) = self.assign_rhs(base);
diagnostics.append(&mut ds);
(Statement::Assign(assign_statement), diagnostics)
if let Some(assign_statement) = maybe_assign_statement {
(Some(Statement::Assign(assign_statement)), diagnostics)
} else {
(None, diagnostics)
}
} else {
(
Statement::Expression(ExpressionStatement::new(base)),
Some(Statement::Expression(ExpressionStatement::new(base))),
diagnostics,
)
}
}
fn assign_rhs(&mut self, destination: Expression) -> ParseResult<AssignStatement> {
fn assign_rhs(&mut self, destination: Expression) -> ParseResult<Option<AssignStatement>> {
let mut diagnostics = Vec::new();
let (_, mut ds) = self.expect_advance(TokenKind::Equals);
diagnostics.append(&mut ds);
let (value, mut ds) = self.expression();
let (maybe_value, mut ds) = self.expression();
diagnostics.append(&mut ds);
(AssignStatement::new(destination, value), diagnostics)
if let Some(value) = maybe_value {
(Some(AssignStatement::new(destination, value)), diagnostics)
} else {
(None, diagnostics)
}
}
fn expression(&mut self) -> ParseResult<Expression> {
fn expression(&mut self) -> ParseResult<Option<Expression>> {
self.bitwise_or_expression()
}
fn bitwise_or_expression(&mut self) -> ParseResult<Expression> {
fn bitwise_or_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
let (mut base, mut ds) = self.bitwise_xor_expression();
let (maybe_base, mut ds) = self.bitwise_xor_expression();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while self.current.is_some() && self.peek_current(TokenKind::Bar) {
diagnostics.append(&mut self.advance()); // |
let (rhs, mut ds) = self.bitwise_xor_expression();
let (maybe_rhs, mut ds) = self.bitwise_xor_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
base = Expression::Binary(BinaryExpression::new(
@ -1056,19 +1088,32 @@ impl<'a> Parser<'a> {
source_range,
));
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn bitwise_xor_expression(&mut self) -> ParseResult<Expression> {
fn bitwise_xor_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
let (mut base, mut ds) = self.bitwise_and_expression();
let (maybe_base, mut ds) = self.bitwise_and_expression();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while self.current.is_some() && self.peek_current(TokenKind::Caret) {
diagnostics.append(&mut self.advance()); // ^
let (rhs, mut ds) = self.bitwise_and_expression();
let (maybe_rhs, mut ds) = self.bitwise_and_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
base = Expression::Binary(BinaryExpression::new(
@ -1079,19 +1124,31 @@ impl<'a> Parser<'a> {
source_range,
));
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn bitwise_and_expression(&mut self) -> ParseResult<Expression> {
fn bitwise_and_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
let (mut base, mut ds) = self.shift_expression();
let (maybe_base, mut ds) = self.shift_expression();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while self.current.is_some() && self.peek_current(TokenKind::Ampersand) {
diagnostics.append(&mut self.advance()); // &
let (rhs, mut ds) = self.shift_expression();
let (maybe_rhs, mut ds) = self.shift_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1103,14 +1160,20 @@ impl<'a> Parser<'a> {
source_range,
));
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn shift_expression(&mut self) -> ParseResult<Expression> {
fn shift_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
let (mut base, mut ds) = self.additive_expression();
let (maybe_base, mut ds) = self.additive_expression();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while self.current.is_some() {
let current = self.current.as_ref().unwrap();
@ -1122,8 +1185,14 @@ impl<'a> Parser<'a> {
self.expect_immediately_after_advance(TokenKind::Lt, &previous_cloned); // second <
diagnostics.append(&mut ds);
let (rhs, mut ds) = self.additive_expression();
let (maybe_rhs, mut ds) = self.additive_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1142,8 +1211,14 @@ impl<'a> Parser<'a> {
self.expect_immediately_after_advance(TokenKind::Gt, &previous_cloned); // second >
diagnostics.append(&mut ds);
let (rhs, mut ds) = self.additive_expression();
let (maybe_rhs, mut ds) = self.additive_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1159,22 +1234,34 @@ impl<'a> Parser<'a> {
}
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn additive_expression(&mut self) -> ParseResult<Expression> {
fn additive_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
let (mut base, mut ds) = self.multiplicative_expression();
let (maybe_base, mut ds) = self.multiplicative_expression();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while self.current.is_some() {
let current = self.current.as_ref().unwrap();
match current.kind() {
TokenKind::Plus => {
diagnostics.append(&mut self.advance()); // plus
let (rhs, mut ds) = self.multiplicative_expression();
let (maybe_rhs, mut ds) = self.multiplicative_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1188,8 +1275,14 @@ impl<'a> Parser<'a> {
}
TokenKind::Minus => {
diagnostics.append(&mut self.advance()); // minus
let (rhs, mut ds) = self.multiplicative_expression();
let (maybe_rhs, mut ds) = self.multiplicative_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1204,22 +1297,34 @@ impl<'a> Parser<'a> {
_ => break,
}
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn multiplicative_expression(&mut self) -> ParseResult<Expression> {
fn multiplicative_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
let (mut base, mut ds) = self.prefix_expression();
let (maybe_base, mut ds) = self.prefix_expression();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while self.current.is_some() {
let current = self.current.as_ref().unwrap();
match current.kind() {
TokenKind::Star => {
diagnostics.append(&mut self.advance()); // multiply
let (rhs, mut ds) = self.prefix_expression();
let (maybe_rhs, mut ds) = self.prefix_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1233,8 +1338,14 @@ impl<'a> Parser<'a> {
}
TokenKind::Slash => {
diagnostics.append(&mut self.advance()); // slash
let (rhs, mut ds) = self.prefix_expression();
let (maybe_rhs, mut ds) = self.prefix_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1248,8 +1359,14 @@ impl<'a> Parser<'a> {
}
TokenKind::Modulo => {
diagnostics.append(&mut self.advance()); // modulo
let (rhs, mut ds) = self.prefix_expression();
let (maybe_rhs, mut ds) = self.prefix_expression();
diagnostics.append(&mut ds);
let rhs = match maybe_rhs {
Some(rhs) => rhs,
None => {
return (None, diagnostics);
}
};
let source_range =
SourceRange::new(base.source_range().start(), rhs.source_range().end());
@ -1264,10 +1381,10 @@ impl<'a> Parser<'a> {
_ => break,
}
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn prefix_expression(&mut self) -> ParseResult<Expression> {
fn prefix_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
// first, collect all consecutive operators
@ -1286,8 +1403,14 @@ impl<'a> Parser<'a> {
// now go in reverse and build up expressions
// the parser is currently just after the prefix operators, so we need a suffix expression
// as a base
let (mut base, mut ds) = self.suffix_expression();
let (maybe_base, mut ds) = self.suffix_expression();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while let Some(operator_token) = operator_tokens.pop() {
let source_range = SourceRange::new(operator_token.start(), base.source_range().end());
@ -1302,14 +1425,20 @@ impl<'a> Parser<'a> {
_ => unreachable!(),
}
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn suffix_expression(&mut self) -> ParseResult<Expression> {
fn suffix_expression(&mut self) -> ParseResult<Option<Expression>> {
let mut diagnostics = Vec::new();
let (mut base, mut ds) = self.expression_base();
let (maybe_base, mut ds) = self.expression_base();
diagnostics.append(&mut ds);
let mut base = match maybe_base {
Some(base) => base,
None => {
return (None, diagnostics);
}
};
while self.current.is_some() {
let current = self.current.as_ref().unwrap();
@ -1323,10 +1452,10 @@ impl<'a> Parser<'a> {
}
}
(base, diagnostics)
(Some(base), diagnostics)
}
fn expression_base(&mut self) -> ParseResult<Expression> {
fn expression_base(&mut self) -> ParseResult<Option<Expression>> {
let current = match self.current.as_ref() {
None => {
let mut ds = Diagnostics::new();
@ -1334,7 +1463,7 @@ impl<'a> Parser<'a> {
&EXPRESSION_FIRSTS,
self.input.len(),
));
return (todo!(), ds);
return (None, ds);
}
Some(current) => current,
};
@ -1345,11 +1474,11 @@ impl<'a> Parser<'a> {
let source_range = SourceRange::new(current.start(), current.end());
diagnostics.append(&mut self.advance());
(
Expression::Integer(IntegerLiteral::new(
Some(Expression::Integer(IntegerLiteral::new(
self.next_node_id(),
i32::from_str(raw).unwrap(),
source_range,
)),
))),
diagnostics,
)
}
@ -1358,11 +1487,11 @@ impl<'a> Parser<'a> {
let source_range = SourceRange::new(current.start(), current.end());
diagnostics.append(&mut self.advance());
(
Expression::Double(DoubleLiteral::new(
Some(Expression::Double(DoubleLiteral::new(
self.next_node_id(),
f64::from_str(raw).unwrap(),
source_range,
)),
))),
diagnostics,
)
}
@ -1371,11 +1500,11 @@ impl<'a> Parser<'a> {
let source_range = SourceRange::new(current.start(), current.end());
diagnostics.append(&mut self.advance());
(
Expression::String(StringLiteral::new(
Some(Expression::String(StringLiteral::new(
self.next_node_id(),
&with_quotes[1..with_quotes.len() - 1],
source_range,
)),
))),
diagnostics,
)
}
@ -1384,11 +1513,11 @@ impl<'a> Parser<'a> {
let source_range = SourceRange::new(current.start(), current.end());
diagnostics.append(&mut self.advance());
(
Expression::Identifier(Identifier::new(
Some(Expression::Identifier(Identifier::new(
self.next_node_id(),
declared_name,
source_range,
)),
))),
diagnostics,
)
}
@ -1430,14 +1559,18 @@ impl<'a> Parser<'a> {
let mut expressions = vec![];
let mut diagnostics = Vec::new();
let (expression, mut ds) = self.expression();
expressions.push(expression);
let (maybe_expression, mut ds) = self.expression();
if let Some(expression) = maybe_expression {
expressions.push(expression);
}
diagnostics.append(&mut ds);
while self.current.is_some() && self.peek_current(TokenKind::Comma) {
diagnostics.append(&mut self.advance()); // comma
let (expression, mut ds) = self.expression();
expressions.push(expression);
let (maybe_expression, mut ds) = self.expression();
if let Some(expression) = maybe_expression {
expressions.push(expression);
}
diagnostics.append(&mut ds);
}
@ -1677,11 +1810,15 @@ mod concrete_tests {
}
fn assert_expression(input: &str) -> Expression {
let (expression, diagnostics) = parse_expression(input);
let (maybe_expression, diagnostics) = parse_expression(input);
if !diagnostics.is_empty() {
report_diagnostics(&diagnostics);
}
expression
if let Some(expression) = maybe_expression {
expression
} else {
panic!("parse_expression produced a None")
}
}
fn assert_function_in<'a>(