mclang/mclangc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: mclang:f338f07e7dbb45505309c929c28f3d4fc168a33e
Branches Tags
mclang:main
mclang:old
..
compare: mclang:323d3342a3d37ef37710664ecb885036c39544ce
Branches Tags
mclang:main
mclang:old

No commits in common. "f338f07e7dbb45505309c929c28f3d4fc168a33e" and "323d3342a3d37ef37710664ecb885036c39544ce" have entirely different histories.
f338f07e7d ... 323d3342a3

21 changed files with 646 additions and 1886 deletions
Show Stats Expand all files Collapse all files

27
src/common/loc.rs
View File

@ -1,4 +1,6 @@
use std::fmt::{Debug, Display}; use std::fmt::Display;
#[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Eq)] #[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Eq)]
pub struct Loc { pub struct Loc {
@ -7,7 +9,6 @@ pub struct Loc {
col: usize, col: usize,
} }
#[allow(dead_code)]
impl Loc { impl Loc {
pub fn new(s: impl ToString, line: usize, col: usize) -> Self { pub fn new(s: impl ToString, line: usize, col: usize) -> Self {
Self { Self {
@ -26,28 +27,6 @@ impl Loc {
} }
} }
#[derive(Debug, Clone)]
pub struct LocBox<T: Clone + Debug> {
inner: T,
loc: Loc
}
impl<T: Clone + Debug> LocBox<T> {
pub fn new(loc: &Loc, inner: T) -> Self {
Self { loc: loc.clone(), inner }
}
pub fn inner(&self) -> &T {
&self.inner
}
pub fn inner_mut(&mut self) -> &mut T {
&mut self.inner
}
pub fn loc(&self) -> &Loc {
&self.loc
}
}
impl Display for Loc { impl Display for Loc {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}:{}:{}", self.file, self.line, self.col) write!(f, "{}:{}:{}", self.file, self.line, self.col)

22
src/main.rs
View File

@ -7,7 +7,7 @@ mod logger;
fn main() -> anyhow::Result<()> { fn main() -> ExitCode {
let cli = mclangc::cli::CliArgs::parse(); let cli = mclangc::cli::CliArgs::parse();
cli.set_log_level(); cli.set_log_level();
cli.validate(); cli.validate();
@ -15,17 +15,25 @@ fn main() -> anyhow::Result<()> {
let fp = PathBuf::from(file); let fp = PathBuf::from(file);
if !fp.exists() { if !fp.exists() {
error!("File {fp:?} doesnt exits, exiting"); error!("File {fp:?} doesnt exits, exiting");
anyhow::bail!("") return ExitCode::FAILURE;
} }
let data = std::fs::read_to_string(fp).unwrap(); let data = std::fs::read_to_string(fp).unwrap();
info!("Tokenising {file}"); info!("Tokenising {file}");
let tokens = mclangc::tokeniser::tokenise(&data, &file)?; let Ok(tokens) = mclangc::tokeniser::tokenise(&data, &file) else {
error!("Failed to tokenise file, exiting");
return ExitCode::FAILURE;
};
info!("Parsing {file}"); info!("Parsing {file}");
let mut prog = mclangc::parser::parse_program(tokens)?; let Ok(prog) = mclangc::parser::parse_program(tokens) else {
error!("Failed to parse file, exiting");
return ExitCode::FAILURE;
};
info!("Validating {file}"); info!("Validating {file}");
mclangc::validator::validate_code(&mut prog)?; let Ok(validated) = mclangc::validator::validate_code(&prog) else {
dbg!(&prog); error!("Failed to validate file, exiting");
return ExitCode::FAILURE;
};
} }
Ok(()) ExitCode::SUCCESS
} }

46
src/parser/ast/expr.rs
View File

@ -1,55 +1,55 @@
use std::collections::HashMap; use std::collections::HashMap;
use crate::{common::loc::LocBox, tokeniser::tokentype::*}; use crate::tokeniser::tokentype::*;
use super::{typ::Type, Ast}; use super::{typ::Type, Ast};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Expr { pub enum Expr {
// Comment(Comment), // Comment(Comment),
Group(Box<LocBox<Expr>>), Group(Box<Expr>),
UnOp { UnOp {
typ: Punctuation, typ: Punctuation,
right: Box<LocBox<Expr>>, right: Box<Expr>,
}, },
BinOp { BinOp {
typ: Punctuation, typ: Punctuation,
left: Box<LocBox<Expr>>, left: Box<Expr>,
right: Box<LocBox<Expr>>, right: Box<Expr>,
}, },
Literal(super::literal::Literal), Literal(super::literal::Literal),
ArrayIndex { ArrayIndex {
name: Box<LocBox<Expr>>, name: Box<Expr>,
index: Box<LocBox<Expr>>, index: Box<Expr>,
}, },
Path(Path), Path(Path),
Call { Call {
path: Box<LocBox<Expr>>, path: Box<Expr>,
params: CallParams, // LocBox<Expr> ~ (, Expr)* params: CallParams, // Expr ~ (, Expr)*
}, },
//MethodCall { //MethodCall {
// var_name: Box<LocBox<Expr>>, // var_name: Box<Expr>,
// method_name: Ident, // method_name: Ident,
// params: CallParams, // params: CallParams,
//}, //},
/// the left side only exists on the /.|->/ chain /// the left side only exists on the /.|->/ chain
FieldAccess { FieldAccess {
left: Box<Option<LocBox<Expr>>>, left: Box<Option<Expr>>,
right: Box<LocBox<Expr>>, right: Box<Expr>,
}, },
PtrFieldAccess { PtrFieldAccess {
left: Box<Option<LocBox<Expr>>>, left: Box<Option<Expr>>,
right: Box<LocBox<Expr>>, right: Box<Expr>,
}, },
ForLoop { ForLoop {
init: Box<Ast>, init: Box<Ast>,
test: Box<LocBox<Expr>>, test: Box<Expr>,
on_loop: Box<LocBox<Expr>>, on_loop: Box<Expr>,
body: Block, body: Block,
}, },
WhileLoop { WhileLoop {
test: Box<LocBox<Expr>>, test: Box<Expr>,
body: Block, body: Block,
}, },
InfLoop { InfLoop {
@ -58,14 +58,14 @@ pub enum Expr {
If(IfExpr), If(IfExpr),
Struct { Struct {
path: Path, path: Path,
fields: HashMap<Ident, LocBox<Expr>>, fields: HashMap<Ident, Expr>,
}, },
Return(Box<Option<LocBox<Expr>>>), Return(Box<Option<Expr>>),
Break, Break,
Continue, Continue,
Cast { Cast {
left: Box<LocBox<Expr>>, left: Box<Expr>,
right: Box<LocBox<Type>> right: Box<Type>
}, },
} }
@ -79,7 +79,7 @@ impl Expr {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct CallParams(pub Vec<LocBox<Expr>>); pub struct CallParams(pub Vec<Expr>);
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Block(pub Vec<Ast>); pub struct Block(pub Vec<Ast>);
@ -90,7 +90,7 @@ pub struct Path(pub Vec<Ident>);
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct IfExpr { pub struct IfExpr {
pub test: Box<LocBox<Expr>>, pub test: Box<Expr>,
pub body: Block, pub body: Block,
pub else_if: Option<IfBranchExpr> pub else_if: Option<IfBranchExpr>
} }

8
src/parser/ast/literal.rs
View File

@ -1,6 +1,6 @@
use std::collections::HashMap; use std::collections::HashMap;
use crate::{common::loc::LocBox, tokeniser::tokentype::*}; use crate::tokeniser::tokentype::*;
use super::{expr::Expr, typ::Type, Ast}; use super::{expr::Expr, typ::Type, Ast};
@ -10,10 +10,10 @@ pub enum Literal {
Ident(Ident), Ident(Ident),
String(TString), String(TString),
Char(Char), Char(Char),
Array(Vec<LocBox<Expr>>), Array(Vec<Expr>),
ArrayRepeat { ArrayRepeat {
typ: Box<LocBox<Type>>, typ: Box<Type>,
count: Box<LocBox<Expr>>, count: Box<Expr>,
}, },
Struct { Struct {
name: Ident, name: Ident,

17
src/parser/ast/mod.rs
View File

@ -1,8 +1,7 @@
use std::collections::HashMap; use std::collections::HashMap;
use statement::{Enum, Function, Struct}; use typ::Type;
use crate::{common::loc::LocBox, validator::predefined::TypeType};
pub use crate::tokeniser::tokentype::*; pub use crate::tokeniser::tokentype::*;
pub mod expr; pub mod expr;
@ -13,17 +12,17 @@ pub mod typ;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Program { pub struct Program {
pub ast: expr::Block, pub ast: expr::Block,
pub structs: HashMap<Ident, LocBox<Struct>>, pub structs: HashMap<Ident, HashMap<Ident, usize>>,
pub enums: HashMap<Ident, LocBox<Enum>>, pub enums: HashMap<Ident, usize>,
pub types: HashMap<Ident, TypeType>, pub types: HashMap<Type, Type>,
pub functions: HashMap<Ident, LocBox<Function>>, pub functions: HashMap<Ident, (Vec<(Ident, Type)>, Type)>,
pub member_functions: HashMap<Ident, HashMap<Ident, LocBox<Function>>>, pub member_functions: HashMap<Ident, HashMap<Ident, (Vec<(Ident, Type)>, Type)>>,
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Ast { pub enum Ast {
Expr(LocBox<expr::Expr>), Expr(expr::Expr),
Statement(LocBox<statement::Statement>), Statement(statement::Statement),
} }

70
src/parser/ast/statement.rs
View File

@ -1,56 +1,44 @@
use std::collections::HashMap;
use crate::common::{loc::LocBox, Loc};
use super::{expr::{Block, Expr}, typ::Type, Ident, TString}; use super::{expr::{Block, Expr}, typ::Type, Ident, TString};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Statement { pub enum Statement {
Fn(Function), Fn {
TypeAlias(TypeAlias), struct_name: Option<Ident>,
Struct(Struct), name: Ident,
Enum(Enum), params: Vec<(Ident, Type)>,
ret_type: Option<Type>,
qual_const: bool,
qual_extern: Option<TString>, // abi
body: Option<Block>, // If None then its a type declaration
},
TypeAlias {
name: Ident,
typ: Type,
},
Struct {
name: Ident,
fields: Vec<(Ident, Type)>,
},
Enum {
name: Ident,
fields: Vec<Ident>,
},
ConstVar { ConstVar {
name: Ident, name: Ident,
typ: LocBox<Type>, typ: Type,
val: LocBox<Expr> val: Expr
}, },
StaticVar { StaticVar {
name: Ident, name: Ident,
typ: LocBox<Type>, typ: Type,
val: LocBox<Expr>, val: Expr,
}, },
Let { Let {
name: Ident, name: Ident,
typ: Option<LocBox<Type>>, typ: Option<Type>,
val: Option<LocBox<Expr>>, val: Option<Expr>,
}, },
} }
#[derive(Debug, Clone)]
pub struct TypeAlias {
pub name: Ident,
pub typ: LocBox<Type>,
}
#[derive(Debug, Clone)]
pub struct Struct {
pub name: Ident,
pub fields: Vec<(Ident, LocBox<Type>)>,
}
#[derive(Debug, Clone)]
pub struct Enum {
pub name: Ident,
pub fields: Vec<Ident>,
}
#[derive(Debug, Clone)]
pub struct Function {
pub struct_name: Option<Ident>,
pub name: Ident,
pub params: Vec<(Ident, LocBox<Type>)>,
pub ret_type: Option<LocBox<Type>>,
pub qual_const: bool,
pub qual_extern: Option<TString>, // abi
pub body: Option<Block>, // If None then its a type declaration
}

6
src/parser/ast/typ.rs
View File

@ -1,6 +1,4 @@
use crate::common::{loc::LocBox, Loc}; use super::{expr::Expr, Ident, Number};
use super::{expr::Expr, Ident};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum Type { pub enum Type {
@ -13,7 +11,7 @@ pub enum Type {
}, },
ArrayRepeat { ArrayRepeat {
inner: Box<Type>, inner: Box<Type>,
count: LocBox<Expr>, count: Expr,
}, },
Owned(Ident), Owned(Ident),
} }

180
src/parser/expr.rs
View File

@ -2,7 +2,7 @@ use std::collections::HashMap;
use anyhow::{bail, Result}; use anyhow::{bail, Result};
use crate::{common::loc::LocBox, debug, error, lerror, parser::{typ::parse_type, Punctuation}, tokeniser::Token}; use crate::{debug, error, lerror, parser::{typ::parse_type, Punctuation}, tokeniser::Token};
use super::{ast::{expr::{Block, CallParams, Expr, IfBranchExpr, IfExpr, Path}, literal::Literal, TokenType}, parse_item, utils, Delimiter, Keyword}; use super::{ast::{expr::{Block, CallParams, Expr, IfBranchExpr, IfExpr, Path}, literal::Literal, TokenType}, parse_item, utils, Delimiter, Keyword};
@ -37,14 +37,14 @@ const BINOP_LIST: &[TokenType] = &[
TokenType::Punct(Punctuation::Ge), TokenType::Punct(Punctuation::Ge),
]; ];
pub fn parse_expr(tokens: &mut Vec<Token>, precedence: usize, consume_semi: bool) -> Result<Option<LocBox<Expr>>> { pub fn parse_expr(tokens: &mut Vec<Token>, precedence: usize, consume_semi: bool) -> Result<Option<Expr>> {
let res = if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::ParenL)) { let res = if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::ParenL)) {
Some(parse_group(tokens)?) Some(parse_group(tokens)?)
} else } else
if let Some(_) = utils::check(tokens, TokenType::ident("")) { if let Some(_) = utils::check(tokens, TokenType::ident("")) {
let p = parse_path(tokens)?; let p = parse_path(tokens)?;
if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyL)) { if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyL)) {
Some(parse_struct_literal(tokens, p.inner().unwrap_path())?) Some(parse_struct_literal(tokens, p.unwrap_path())?)
} else { } else {
Some(p) Some(p)
} }
@ -73,33 +73,37 @@ pub fn parse_expr(tokens: &mut Vec<Token>, precedence: usize, consume_semi: bool
return Ok(Some(parse_inf_loop(tokens)?)); return Ok(Some(parse_inf_loop(tokens)?));
} else if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::Return)) { } else if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::Return)) {
return Ok(Some(parse_return(tokens)?)); return Ok(Some(parse_return(tokens)?));
} else if let Some(kw) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Break)) { } else if let Some(_) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Break)) {
return Ok(Some(LocBox::new(kw.loc(), Expr::Break))); return Ok(Some(Expr::Break));
} else if let Some(kw) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Continue)) { } else if let Some(_) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Continue)) {
return Ok(Some(LocBox::new(kw.loc(), Expr::Continue))); return Ok(Some(Expr::Continue));
} else if let Some(kw) = utils::check(tokens, TokenType::Keyword(Keyword::If)) { } else if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::If)) {
return Ok(Some(LocBox::new(&kw.loc().clone(), Expr::If(parse_if(tokens)?)))); return Ok(Some(Expr::If(parse_if(tokens)?)));
} else { } else {
None None
}; };
if let Some(mut res) = res { if let Some(res) = res {
if utils::check(tokens, TokenType::Punct(Punctuation::Fieldaccess)).is_some() { // check for binop
res = parse_field_access(tokens, res)?; let res = match res {
} _ if utils::check(tokens, TokenType::Punct(Punctuation::Fieldaccess)).is_some() => {
if utils::check(tokens, TokenType::Punct(Punctuation::Arrow)).is_some() { parse_field_access(tokens, res)?
res =parse_ptr_field_access(tokens, res)?; }
} _ if utils::check(tokens, TokenType::Punct(Punctuation::Arrow)).is_some() => {
if utils::check(tokens, TokenType::Delim(Delimiter::ParenL)).is_some() { parse_ptr_field_access(tokens, res)?
res = parse_fn_call(tokens, res)?; }
} _ if utils::check(tokens, TokenType::Delim(Delimiter::ParenL)).is_some() => {
if utils::check(tokens, TokenType::Keyword(Keyword::As)).is_some() { parse_fn_call(tokens, res)?
res = parse_cast(tokens, res)?; }
} _ if utils::check(tokens, TokenType::Keyword(Keyword::As)).is_some() => {
if utils::check(tokens, TokenType::Delim(Delimiter::SquareL)).is_some() { parse_cast(tokens, res)?
res = parse_array_index(tokens, res)?; }
} _ if utils::check(tokens, TokenType::Delim(Delimiter::SquareL)).is_some() => {
parse_array_index(tokens, res)?
}
_ => res
};
if let Some(_) = utils::check_from_many(tokens, BINOP_LIST) { if let Some(_) = utils::check_from_many(tokens, BINOP_LIST) {
return Ok(Some(parse_binop(tokens, res, precedence)?)); return Ok(Some(parse_binop(tokens, res, precedence)?));
@ -113,19 +117,19 @@ pub fn parse_expr(tokens: &mut Vec<Token>, precedence: usize, consume_semi: bool
Ok(res) Ok(res)
} }
fn parse_return(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_return(tokens: &mut Vec<Token>) -> Result<Expr> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Return), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Return));
let item = parse_expr(tokens, 0, true)?; let item = parse_expr(tokens, 0, true)?;
Ok(LocBox::new(kw.loc(), Expr::Return(Box::new(item)))) Ok(Expr::Return(Box::new(item)))
} }
fn parse_cast(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result<LocBox<Expr>> { fn parse_cast(tokens: &mut Vec<Token>, left: Expr) -> Result<Expr> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::As), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::As), "")?;
let typ = parse_type(tokens)?; let typ = parse_type(tokens)?;
Ok(LocBox::new(kw.loc(), Expr::Cast { Ok(Expr::Cast {
left: Box::new(left), left: Box::new(left),
right: Box::new(typ) right: Box::new(typ)
})) })
} }
fn parse_if(tokens: &mut Vec<Token>) -> Result<IfExpr> { fn parse_if(tokens: &mut Vec<Token>) -> Result<IfExpr> {
let loc = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::If), "")?; let loc = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::If), "")?;
@ -168,50 +172,50 @@ fn parse_if(tokens: &mut Vec<Token>) -> Result<IfExpr> {
}) })
} }
} }
fn parse_while_loop(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_while_loop(tokens: &mut Vec<Token>) -> Result<Expr> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::While), "")?; let loc = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::While), "")?;
let Some(test) = parse_expr(tokens, 0, false)? else { let Some(test) = parse_expr(tokens, 0, false)? else {
lerror!(kw.loc(), "Expected test comparrison for while loop, got nothing"); lerror!(loc.loc(), "Expected test comparrison for while loop, got nothing");
bail!("") bail!("")
}; };
let block = parse_block(tokens)?; let block = parse_block(tokens)?;
Ok(LocBox::new(kw.loc(), Expr::WhileLoop { Ok(Expr::WhileLoop {
test: Box::new(test), test: Box::new(test),
body: block body: block
})) })
} }
fn parse_for_loop(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_for_loop(tokens: &mut Vec<Token>) -> Result<Expr> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::For), "")?; let loc = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::For), "")?;
let Some(pre) = parse_item(tokens)? else { let Some(pre) = parse_item(tokens)? else {
lerror!(kw.loc(), "Expected init stat for a for loop, got nothing"); lerror!(loc.loc(), "Expected init stat for a for loop, got nothing");
bail!("") bail!("")
}; };
// Semicolon parsed out by parse_item above // Semicolon parsed out by parse_item above
let Some(test) = parse_expr(tokens, 0, false)? else { let Some(test) = parse_expr(tokens, 0, false)? else {
lerror!(kw.loc(), "Expected test comparrison for a for loop, got nothing"); lerror!(loc.loc(), "Expected test comparrison for a for loop, got nothing");
bail!("") bail!("")
}; };
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), ""); _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "");
let Some(post) = parse_expr(tokens, 0, false)? else { let Some(post) = parse_expr(tokens, 0, false)? else {
lerror!(kw.loc(), "Expected post expression (usually an index increment) for a for loop, got nothing"); lerror!(loc.loc(), "Expected post expression (usually an index increment) for a for loop, got nothing");
bail!("") bail!("")
}; };
let block = parse_block(tokens)?; let block = parse_block(tokens)?;
Ok(LocBox::new(kw.loc(), Expr::ForLoop { Ok(Expr::ForLoop {
init: Box::new(pre), init: Box::new(pre),
test: Box::new(test), test: Box::new(test),
on_loop: Box::new(post), on_loop: Box::new(post),
body: block body: block
})) })
} }
fn parse_inf_loop(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_inf_loop(tokens: &mut Vec<Token>) -> Result<Expr> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Loop), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Loop), "");
let block = parse_block(tokens)?; let block = parse_block(tokens)?;
Ok(LocBox::new(kw.loc(), Expr::InfLoop { body: block })) Ok(Expr::InfLoop { body: block })
} }
fn parse_fn_call(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result<LocBox<Expr>> { fn parse_fn_call(tokens: &mut Vec<Token>, left: Expr) -> Result<Expr> {
let start = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenL), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenL), "");
let mut params = Vec::new(); let mut params = Vec::new();
while !tokens.is_empty() { while !tokens.is_empty() {
@ -228,23 +232,23 @@ fn parse_fn_call(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result<LocBox<E
} }
} }
_ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenR), ""); _ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenR), "");
Ok(LocBox::new(start.loc(), Expr::Call { path: Box::new(left), params: CallParams(params) })) Ok(Expr::Call { path: Box::new(left), params: CallParams(params) })
} }
fn parse_array_index(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result<LocBox<Expr>> { fn parse_array_index(tokens: &mut Vec<Token>, left: Expr) -> Result<Expr> {
let start = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareL), "")?; let loc = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareL), "")?;
let Some(idx) = parse_expr(tokens, 0, false)? else { let Some(idx) = parse_expr(tokens, 0, false)? else {
lerror!(start.loc(), "Expected index for in array index but found nothing."); lerror!(loc.loc(), "Expected index for in array index but found nothing.");
bail!("") bail!("")
}; };
_ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), ""); _ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "");
Ok(LocBox::new(start.loc(), Expr::ArrayIndex { Ok(Expr::ArrayIndex {
name: Box::new(left), name: Box::new(left),
index: Box::new(idx) index: Box::new(idx)
})) })
} }
fn parse_field_access(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result<LocBox<Expr>> { fn parse_field_access(tokens: &mut Vec<Token>, left: Expr) -> Result<Expr> {
let start = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Fieldaccess), "unreachable")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Fieldaccess), "unreachable")?;
let right = if let Some(_) = utils::check_2_last(tokens, TokenType::Punct(Punctuation::Arrow)) { let right = if let Some(_) = utils::check_2_last(tokens, TokenType::Punct(Punctuation::Arrow)) {
let right = parse_path(tokens)?; let right = parse_path(tokens)?;
@ -255,14 +259,14 @@ fn parse_field_access(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result<Loc
} else { } else {
parse_path(tokens)? parse_path(tokens)?
}; };
Ok(LocBox::new(start.loc(), Expr::FieldAccess { Ok(Expr::FieldAccess {
left: Box::new(Some(left)), left: Box::new(Some(left)),
right: Box::new(right) right: Box::new(right)
})) })
} }
fn parse_ptr_field_access(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result<LocBox<Expr>> { fn parse_ptr_field_access(tokens: &mut Vec<Token>, left: Expr) -> Result<Expr> {
let start = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Arrow), "unreachable")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Arrow), "unreachable")?;
let right = if let Some(_) = utils::check_2_last(tokens, TokenType::Punct(Punctuation::Arrow)) { let right = if let Some(_) = utils::check_2_last(tokens, TokenType::Punct(Punctuation::Arrow)) {
let right = parse_path(tokens)?; let right = parse_path(tokens)?;
parse_ptr_field_access(tokens, right)? parse_ptr_field_access(tokens, right)?
@ -272,28 +276,28 @@ fn parse_ptr_field_access(tokens: &mut Vec<Token>, left: LocBox<Expr>) -> Result
} else { } else {
parse_path(tokens)? parse_path(tokens)?
}; };
Ok(LocBox::new(start.loc(), Expr::PtrFieldAccess { Ok(Expr::PtrFieldAccess {
left: Box::new(Some(left)), left: Box::new(Some(left)),
right: Box::new(right) right: Box::new(right)
})) })
} }
fn parse_literal(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_literal(tokens: &mut Vec<Token>) -> Result<Expr> {
if let Some(tkn) = utils::check_consume(tokens, TokenType::string("", false)) { if let Some(tkn) = utils::check_consume(tokens, TokenType::string("", false)) {
let TokenType::String(str) = tkn.tt() else {unreachable!()}; let TokenType::String(str) = tkn.tt() else {unreachable!()};
return Ok(LocBox::new(tkn.loc(), Expr::Literal(Literal::String(str.clone())))); return Ok(Expr::Literal(Literal::String(str.clone())));
} else } else
if let Some(tkn) = utils::check_consume(tokens, TokenType::number(0, 0, false)) { if let Some(tkn) = utils::check_consume(tokens, TokenType::number(0, 0, false)) {
let TokenType::Number(val) = tkn.tt() else {unreachable!()}; let TokenType::Number(val) = tkn.tt() else {unreachable!()};
return Ok(LocBox::new(tkn.loc(), Expr::Literal(Literal::Number(val.clone())))); return Ok(Expr::Literal(Literal::Number(val.clone())));
} else } else
if let Some(tkn) = utils::check_consume(tokens, TokenType::char('\0')) { if let Some(tkn) = utils::check_consume(tokens, TokenType::char('\0')) {
let TokenType::Char(val) = tkn.tt() else {unreachable!()}; let TokenType::Char(val) = tkn.tt() else {unreachable!()};
return Ok(LocBox::new(tkn.loc(), Expr::Literal(Literal::Char(val.clone())))); return Ok(Expr::Literal(Literal::Char(val.clone())));
} else } else
if let Some(start) = utils::check_consume(tokens, TokenType::Delim(Delimiter::SquareL)) { if let Some(start) = utils::check_consume(tokens, TokenType::Delim(Delimiter::SquareL)) {
if let Some(_) = utils::check_consume(tokens, TokenType::Delim(Delimiter::SquareR)) { if let Some(_) = utils::check_consume(tokens, TokenType::Delim(Delimiter::SquareR)) {
return Ok(LocBox::new(start.loc(), Expr::Literal(Literal::Array(Vec::new())))); return Ok(Expr::Literal(Literal::Array(Vec::new())));
} }
if *tokens[tokens.len()-2].tt() == TokenType::Punct(Punctuation::Comma) { if *tokens[tokens.len()-2].tt() == TokenType::Punct(Punctuation::Comma) {
let first = parse_expr(tokens, 0, false)?; let first = parse_expr(tokens, 0, false)?;
@ -310,15 +314,15 @@ fn parse_literal(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> {
} }
} }
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?; utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?;
return Ok(LocBox::new(start.loc(), Expr::Literal(Literal::Array(values)))); return Ok(Expr::Literal(Literal::Array(values)));
} else if *tokens[tokens.len()-2].tt() == TokenType::Punct(Punctuation::Semi) { } else if *tokens[tokens.len()-2].tt() == TokenType::Punct(Punctuation::Semi) {
let typ = parse_type(tokens)?; let typ = parse_type(tokens)?;
let count = parse_expr(tokens, 0, false)?.unwrap(); let count = parse_expr(tokens, 0, false)?.unwrap();
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?; utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?;
return Ok(LocBox::new(start.loc(), Expr::Literal(Literal::ArrayRepeat { return Ok(Expr::Literal(Literal::ArrayRepeat {
typ: Box::new(typ), typ: Box::new(typ),
count: Box::new(count) count: Box::new(count)
}))); }));
} else { } else {
if let Some(curr) = tokens.last() { if let Some(curr) = tokens.last() {
lerror!(start.loc(), "Expected a , or ; as a separator in a literal array (normal, or repeating, respectively), but found {}", curr.tt()); lerror!(start.loc(), "Expected a , or ; as a separator in a literal array (normal, or repeating, respectively), but found {}", curr.tt());
@ -331,8 +335,8 @@ fn parse_literal(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> {
unreachable!() unreachable!()
} }
fn parse_struct_literal(tokens: &mut Vec<Token>, name: Path) -> Result<LocBox<Expr>> { fn parse_struct_literal(tokens: &mut Vec<Token>, name: Path) -> Result<Expr> {
let start = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyL), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyL), "")?;
let mut fields = HashMap::new(); let mut fields = HashMap::new();
while !tokens.is_empty() { while !tokens.is_empty() {
if let Some(_) = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyR)) { if let Some(_) = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyR)) {
@ -348,21 +352,21 @@ fn parse_struct_literal(tokens: &mut Vec<Token>, name: Path) -> Result<LocBox<Ex
break; break;
} }
} }
Ok(LocBox::new(start.loc(), Expr::Struct { path: name, fields })) Ok(Expr::Struct { path: name, fields })
} }
fn parse_group(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_group(tokens: &mut Vec<Token>) -> Result<Expr> {
let start = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenL), "")?; let loc = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenL), "")?;
let Some(expr) = parse_expr(tokens, 0, false)? else { let Some(expr) = parse_expr(tokens, 0, false)? else {
lerror!(start.loc(), "Expected expr found nothing"); lerror!(loc.loc(), "Expected expr found nothing");
bail!("") bail!("")
}; };
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenR), "")?; utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenR), "")?;
Ok(LocBox::new(start.loc(), Expr::Group(Box::new(expr)))) Ok(Expr::Group(Box::new(expr)))
} }
fn parse_path(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_path(tokens: &mut Vec<Token>) -> Result<Expr> {
let mut buf = Vec::new(); let mut buf = Vec::new();
let part = utils::check_consume(tokens, TokenType::ident("")).unwrap(); let part = utils::check_consume(tokens, TokenType::ident("")).unwrap();
@ -375,10 +379,10 @@ fn parse_path(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> {
buf.push(part.tt().unwrap_ident()); buf.push(part.tt().unwrap_ident());
} }
Ok(LocBox::new(part.loc(), Expr::Path(Path(buf)))) Ok(Expr::Path(Path(buf)))
} }
fn parse_unop(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> { fn parse_unop(tokens: &mut Vec<Token>) -> Result<Expr> {
let typ = utils::check_consume_or_err_from_many(tokens, &[ let typ = utils::check_consume_or_err_from_many(tokens, &[
TokenType::Punct(Punctuation::Not), TokenType::Punct(Punctuation::Not),
TokenType::Punct(Punctuation::Plus), TokenType::Punct(Punctuation::Plus),
@ -393,20 +397,18 @@ fn parse_unop(tokens: &mut Vec<Token>) -> Result<LocBox<Expr>> {
lerror!(&loc, "Expected expression after unary token, found nothing"); lerror!(&loc, "Expected expression after unary token, found nothing");
bail!("") bail!("")
}; };
Ok(LocBox::new(&loc, Expr::UnOp { Ok(Expr::UnOp {
typ, typ,
right: Box::new(right) right: Box::new(right)
})) })
} }
fn parse_binop(tokens: &mut Vec<Token>, mut lhs: LocBox<Expr>, precedence: usize) -> Result<LocBox<Expr>> { fn parse_binop(tokens: &mut Vec<Token>, mut lhs: Expr, precedence: usize) -> Result<Expr> {
// TODO: https://en.wikipedia.org/wiki/Operator-precedence_parser#Pseudocode // TODO: https://en.wikipedia.org/wiki/Operator-precedence_parser#Pseudocode
loop { loop {
let op_loc;
let op = match tokens.last() { let op = match tokens.last() {
Some(op) if BINOP_LIST.contains(&op.tt()) => { Some(op) if BINOP_LIST.contains(&op.tt()) => {
op_loc = op.loc().clone();
let TokenType::Punct(op) = op.tt() else {unreachable!()}; let TokenType::Punct(op) = op.tt() else {unreachable!()};
op.clone() op.clone()
} }
@ -431,11 +433,11 @@ fn parse_binop(tokens: &mut Vec<Token>, mut lhs: LocBox<Expr>, precedence: usize
_ = tokens.pop(); _ = tokens.pop();
let Some(rhs) = parse_expr(tokens, rp, false)? else {break;}; let Some(rhs) = parse_expr(tokens, rp, false)? else {break;};
lhs = LocBox::new(&op_loc, Expr::BinOp { lhs = Expr::BinOp {
typ: op, typ: op,
left: Box::new(lhs), left: Box::new(lhs),
right: Box::new(rhs) right: Box::new(rhs)
}); };
} }

2
src/parser/mod.rs
View File

@ -8,7 +8,7 @@ pub mod ast;
mod expr; mod expr;
mod stat; mod stat;
mod utils; mod utils;
pub mod typ; mod typ;
type Result<T> = anyhow::Result<T>; type Result<T> = anyhow::Result<T>;

55
src/parser/stat.rs
View File

@ -1,6 +1,5 @@
use anyhow::bail; use anyhow::bail;
use crate::common::loc::LocBox;
use crate::lerror; use crate::lerror;
use crate::parser::ast::TokenType; use crate::parser::ast::TokenType;
use crate::parser::expr::parse_expr; use crate::parser::expr::parse_expr;
@ -10,11 +9,11 @@ use super::ast::typ::Type;
use super::expr::parse_block; use super::expr::parse_block;
use super::typ::parse_type; use super::typ::parse_type;
use super::utils; use super::utils;
use super::ast::statement::{Enum, Function, Statement, Struct, TypeAlias}; use super::ast::statement::Statement;
type Result<T> = anyhow::Result<T>; type Result<T> = anyhow::Result<T>;
pub fn parse_statement(tokens: &mut Vec<Token>) -> Result<Option<LocBox<Statement>>> { pub fn parse_statement(tokens: &mut Vec<Token>) -> Result<Option<Statement>> {
if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::Fn)) { if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::Fn)) {
Ok(Some(parse_fn(tokens)?)) Ok(Some(parse_fn(tokens)?))
} else } else
@ -40,8 +39,8 @@ pub fn parse_statement(tokens: &mut Vec<Token>) -> Result<Option<LocBox<Statemen
} }
} }
fn parse_enum(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> { fn parse_enum(tokens: &mut Vec<Token>) -> Result<Statement> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Enum), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Enum));
let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident(); let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident();
_ = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyL)); _ = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyL));
let mut fields = Vec::new(); let mut fields = Vec::new();
@ -61,11 +60,11 @@ fn parse_enum(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> {
fields.push(field_name); fields.push(field_name);
} }
Ok(LocBox::new(kw.loc(), Statement::Enum(Enum { name, fields }))) Ok(Statement::Enum { name, fields })
} }
fn parse_struct(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> { fn parse_struct(tokens: &mut Vec<Token>) -> Result<Statement> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Struct), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Struct));
let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident(); let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident();
_ = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyL)); _ = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyL));
let mut fields = Vec::new(); let mut fields = Vec::new();
@ -87,11 +86,11 @@ fn parse_struct(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> {
fields.push((field_name, typ)); fields.push((field_name, typ));
} }
Ok(LocBox::new(kw.loc(), Statement::Struct(Struct { name, fields }))) Ok(Statement::Struct { name, fields })
} }
fn parse_static(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> { fn parse_static(tokens: &mut Vec<Token>) -> Result<Statement> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Static), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Static));
let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident(); let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident();
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Colon), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Colon), "")?;
@ -102,11 +101,11 @@ fn parse_static(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> {
bail!("") bail!("")
}; };
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?;
Ok(LocBox::new(kw.loc(), Statement::StaticVar { name, typ, val })) Ok(Statement::StaticVar { name, typ, val })
} }
fn parse_let(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> { fn parse_let(tokens: &mut Vec<Token>) -> Result<Statement> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Let), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Let));
let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident(); let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident();
let mut typ = None; let mut typ = None;
let mut val = None; let mut val = None;
@ -121,10 +120,10 @@ fn parse_let(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> {
val = Some(_val); val = Some(_val);
} }
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?;
Ok(LocBox::new(kw.loc(), Statement::Let { name, typ, val })) Ok(Statement::Let { name, typ, val })
} }
fn parse_constant(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> { fn parse_constant(tokens: &mut Vec<Token>) -> Result<Statement> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Const), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Const));
if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::Fn)) { if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::Fn)) {
unimplemented!() unimplemented!()
@ -138,22 +137,22 @@ fn parse_constant(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> {
bail!("") bail!("")
}; };
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?;
Ok(LocBox::new(kw.loc(), Statement::ConstVar { name, typ, val })) Ok(Statement::ConstVar { name, typ, val })
} }
fn parse_type_alias(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> { fn parse_type_alias(tokens: &mut Vec<Token>) -> Result<Statement> {
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Type), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Type));
let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident(); let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident();
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Eq), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Eq), "")?;
let typ = parse_type(tokens)?; let typ = parse_type(tokens)?;
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?;
Ok(LocBox::new(kw.loc(), Statement::TypeAlias(TypeAlias { name, typ }))) Ok(Statement::TypeAlias { name, typ })
} }
fn parse_fn(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> { fn parse_fn(tokens: &mut Vec<Token>) -> Result<Statement> {
// Just remove the kw since we checked it before // Just remove the kw since we checked it before
let kw = utils::check_consume_or_err(tokens, TokenType::Keyword(Keyword::Fn), "")?; _ = utils::check_consume(tokens, TokenType::Keyword(Keyword::Fn));
let mut struct_name = None; let mut struct_name = None;
let mut name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident(); let mut name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?.tt().unwrap_ident();
@ -177,8 +176,7 @@ fn parse_fn(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> {
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "")?;
body = None; body = None;
} }
Ok(Statement::Fn {
Ok(LocBox::new(kw.loc(), Statement::Fn(Function{
struct_name, struct_name,
name, name,
params, params,
@ -186,18 +184,15 @@ fn parse_fn(tokens: &mut Vec<Token>) -> Result<LocBox<Statement>> {
qual_const: false, qual_const: false,
qual_extern: None, qual_extern: None,
body, body,
}))) })
} }
fn parse_fn_params(tokens: &mut Vec<Token>) -> Result<Vec<(Ident, LocBox<Type>)>> { fn parse_fn_params(tokens: &mut Vec<Token>) -> Result<Vec<(Ident, Type)>> {
let mut args = Vec::new(); let mut args = Vec::new();
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenL), "")?; utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::ParenL), "")?;
while !tokens.is_empty() { while !tokens.is_empty() {
if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::ParenR)) {
break;
}
let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?; let name = utils::check_consume_or_err(tokens, TokenType::ident(""), "")?;
utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Colon), "")?; utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Colon), "")?;
//dbg!(&name); //dbg!(&name);

22
src/parser/typ.rs
View File

@ -1,16 +1,12 @@
use anyhow::Result; use anyhow::Result;
use crate::{common::loc::LocBox, parser::Delimiter, tokeniser::Token}; use crate::{parser::Delimiter, tokeniser::Token};
use super::{ast::{typ::Type, TokenType}, expr::parse_expr, utils, Keyword, Punctuation}; use super::{ast::{typ::Type, TokenType}, expr::parse_expr, utils, Keyword, Punctuation};
pub fn parse_type(tokens: &mut Vec<Token>) -> Result<LocBox<Type>> { pub fn parse_type(tokens: &mut Vec<Token>) -> Result<Type> {
let mut ref_cnt = Vec::new(); let mut ref_cnt = Vec::new();
let mut loc = None;
while let Some(tok) = utils::check_consume(tokens, TokenType::Punct(Punctuation::Ampersand)) { while let Some(tok) = utils::check_consume(tokens, TokenType::Punct(Punctuation::Ampersand)) {
if let None = loc {
loc = Some(tok.loc().clone());
}
if let Some(tok) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Mut)) { if let Some(tok) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Mut)) {
ref_cnt.push(tok.clone()); ref_cnt.push(tok.clone());
} else { } else {
@ -19,29 +15,23 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<LocBox<Type>> {
} }
let mut typ; let mut typ;
if let Some(start) = utils::check_consume(tokens, TokenType::Delim(super::Delimiter::SquareL)) { if let Some(_) = utils::check_consume(tokens, TokenType::Delim(super::Delimiter::SquareL)) {
if let None = loc {
loc = Some(start.loc().clone());
}
let itm_typ = parse_type(tokens)?; let itm_typ = parse_type(tokens)?;
if let Some(_) = utils::check_consume(tokens, TokenType::Punct(Punctuation::Semi)) { if let Some(_) = utils::check_consume(tokens, TokenType::Punct(Punctuation::Semi)) {
let count = parse_expr(tokens, 0, false)?.unwrap(); let count = parse_expr(tokens, 0, false)?.unwrap();
typ = Type::ArrayRepeat { typ = Type::ArrayRepeat {
inner: Box::new(itm_typ.inner().clone()), inner: Box::new(itm_typ),
count count
} }
} else { } else {
typ = Type::Array { typ = Type::Array {
inner: Box::new(itm_typ.inner().clone()), inner: Box::new(itm_typ),
} }
} }
_ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?; _ = utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::SquareR), "")?;
} else { } else {
let ident = utils::check_consume_or_err(tokens, TokenType::ident(""), "a")?; let ident = utils::check_consume_or_err(tokens, TokenType::ident(""), "a")?;
typ = Type::Owned(ident.tt().unwrap_ident()); typ = Type::Owned(ident.tt().unwrap_ident());
if let None = loc {
loc = Some(ident.loc().clone());
}
} }
while let Some(reft) = ref_cnt.pop() { while let Some(reft) = ref_cnt.pop() {
match reft.tt() { match reft.tt() {
@ -60,5 +50,5 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<LocBox<Type>> {
_ => unreachable!() _ => unreachable!()
} }
} }
Ok(LocBox::new(&loc.unwrap(), typ)) Ok(typ)
} }

74
src/validator/mod.rs
View File

@ -1,74 +1,8 @@
use std::collections::HashMap; use crate::parser::ast::Program;
use crate::{common::loc::LocBox, parser::ast::{expr::Block, statement::{Statement, TypeAlias}, Ast, Program}};
pub mod predefined;
pub fn validate_code(prog: &mut Program) -> anyhow::Result<()> {
let Block(items) = prog.ast.clone();
predefined::load_builtin(prog);
collect_types(prog, &items);
//dbg!(&prog.types);
//dbg!(&prog.structs);
//dbg!(&prog.enums);
//dbg!(&prog.member_functions);
//dbg!(&prog.functions);
for item in items {
match item {
Ast::Statement(stat) => {
match stat.inner() {
Statement::Fn(func) => {}
Statement::Let { name, typ, val } => {}
Statement::ConstVar { name, typ, val } => {}
Statement::StaticVar { name, typ, val } => {}
Statement::Enum(enm) => {}
Statement::Struct(strct) => {}
Statement::TypeAlias(alias) => {}
}
}
Ast::Expr(_) => unreachable!()
}
}
pub fn validate_code(prog: &Program) -> anyhow::Result<()> {
Ok(()) Ok(())
} }
fn collect_types(prog: &mut Program, items: &Vec<Ast>) {
for item in items {
match item {
Ast::Statement(stat) => {
match stat.inner() {
Statement::Fn(func)=> {
if let Some(struct_name) = &func.struct_name {
if let Some(v) = prog.member_functions.get_mut(&struct_name) {
v.insert(func.name.clone(), LocBox::new(stat.loc(), func.clone()));
} else {
let mut v = HashMap::new();
v.insert(func.name.clone(), LocBox::new(stat.loc(), func.clone()));
prog.member_functions.insert(struct_name.clone(), v);
}
} else {
prog.functions.insert(func.name.clone(), LocBox::new(stat.loc(), func.clone()));
}
}
Statement::Enum(enm) => {
prog.enums.insert(enm.name.clone(), LocBox::new(stat.loc(), enm.clone()));
}
Statement::Struct(strct) => {
prog.structs.insert(strct.name.clone(), LocBox::new(stat.loc(), strct.clone()));
}
Statement::TypeAlias(alias) => {
let typ = alias.clone().typ.inner().clone();
prog.types.insert(alias.name.clone(), predefined::TypeType::Normal(LocBox::new(stat.loc(), typ)));
}
Statement::Let { .. } |
Statement::ConstVar { .. } |
Statement::StaticVar { .. } => (),
}
}
Ast::Expr(_) => unreachable!()
}
}
}

71
src/validator/predefined.rs
View File

@ -1,71 +0,0 @@
use std::collections::HashMap;
use lazy_static::lazy_static;
use crate::common::Loc;
use crate::parser::typ::parse_type;
use crate::{common::loc::LocBox, parser::ast::{statement::Function, typ::Type, Ident, Program}};
#[cfg(target_arch="x86_64")]
const SIZE: usize = 8;
#[cfg(target_arch="x86")]
const SIZE: usize = 4;
lazy_static!(
pub static ref TYPES_RAW: HashMap<&'static str, usize> = [
("void", 0),
("usize", SIZE),
("isize", SIZE),
("u8", 1),
("u16", 2),
("u32", 4),
("u64", 8),
("i8", 1),
("i16", 2),
("i32", 4),
("i64", 8),
].into();
pub static ref FUNCTIONS: HashMap<&'static str, (Vec<(&'static str, &'static str)>, &'static str)> = [
("syscall", (vec![
("arg_count", "&u8"),
("sc_num", "usize"),
("args", "&[&void]")
], "usize")),
].into();
);
#[derive(Debug, Clone)]
pub enum TypeType {
Normal(LocBox<Type>),
Builtin(usize),
}
pub fn load_builtin(prog: &mut Program) {
for (name, size) in TYPES_RAW.iter() {
prog.types.insert(Ident(name.to_string()), TypeType::Builtin(*size));
}
for (name, (args, ret_typ)) in FUNCTIONS.iter() {
let mut params = Vec::new();
let mut ret_type = None;
if ret_typ.len() > 0 {
let mut ret_t_tokens = crate::tokeniser::tokenise(&ret_typ, "(internal)").unwrap();
let typ = parse_type(&mut ret_t_tokens).unwrap();
ret_type = Some(LocBox::new(&Loc::default(), typ.inner().clone()));
}
for (name, typ) in args {
let mut tokens = crate::tokeniser::tokenise(&typ, "(internal)").unwrap();
let typ = parse_type(&mut tokens).unwrap();
params.push((Ident(name.to_string()), LocBox::new(&Loc::new("(internal)", 0, 0), typ.inner().clone())));
}
let f = Function {
struct_name: None,
name: Ident(name.to_string()),
params,
ret_type,
qual_const: false,
qual_extern: None,
body: None
};
prog.functions.insert(Ident(name.to_string()), LocBox::new(&Loc::new("(internal)", 0, 0), f));
}
}

101
test.mcl
View File

@ -1,21 +1,86 @@
//type str = [u8];
// enum Wah {
//struct Foo { A,
// a: usize, B,
// b: &str C,
//} D
// }
//fn Foo.new(a: usize, b: &str) -> Foo {
// return Foo { struct Baz {
// a: a, owo: i32,
// b: b uwu: usize
// }; }
//}
// /// Type definitions
// // type Rah = &Baz;
//fn main() {
// let obj = Foo::new(); /// Different kinds of functions
// // Normal function
// fn main(a: &Foo, b: Rah) -> Nya {
/// General expressions (math)
// Works
// let a = 1 * 3 == 4;
// let b = 3/4 == *a;
// let c = (a->b.c->d) / 2;
// let d = 2 / a->b.c->d;
// let e = a->b.c->d / 2;
// let f = a.b.c.d / 2;
// let g = a.b[a.c] * 5;
// No worky
// nothing! yay!
/// Struct literals
// let a = Baz {
// owo: a,
// uwu: b + c / d
// };
/// If statement
// if 1 > 3 {
// ";3"
// } else
// if *a == 3 {
// ":0"
// } else {
// ">:("
// }
/// 3 kinds of loops all doing the same thing
/// While loops
// let iw = 0;
// while iw < 10 {
// println("Owo");
// }
/// For loops
// for let ifr = 0 ; ifr < 20 ; ifr += 1 {
// println("nya");
// }
/// Infinite loops
// let il = 0;
// loop {
// if il > 10 {
// break;
// }
// println("Rah");
// }
/// Function Calls
// println(":3");
//} //}
// Struct member function with inner data
//fn Baz.main(self: &mut Baz, a: &Foo, b: &mut Bar) -> &Nya;
// Struct member function without any data a.k.a a static member func
//fn Baz.main(a: &Foo, b: &mut Bar) -> &Nya;

54
tests/parser/enumerations.exp
View File

@ -2,47 +2,29 @@ Program {
ast: Block( ast: Block(
[ [
Statement( Statement(
LocBox { Enum {
inner: Enum( name: Ident(
Enum { "Foo",
name: Ident(
"Foo",
),
fields: [],
},
), ),
loc: Loc { fields: [],
file: "parser/enumerations.mcl",
line: 1,
col: 5,
},
}, },
), ),
Statement( Statement(
LocBox { Enum {
inner: Enum( name: Ident(
Enum { "Bar",
name: Ident(
"Bar",
),
fields: [
Ident(
"A",
),
Ident(
"B",
),
Ident(
"C",
),
],
},
), ),
loc: Loc { fields: [
file: "parser/enumerations.mcl", Ident(
line: 3, "A",
col: 5, ),
}, Ident(
"B",
),
Ident(
"C",
),
],
}, },
), ),
], ],

929
tests/parser/expressions.exp
View File

@ -1,901 +1,54 @@
Program { Program {
ast: Block( ast: Block(
[ [
Statement( Expr(
LocBox { BinOp {
inner: Let { typ: Eq,
name: Ident( left: UnOp {
"a", typ: Star,
), right: Path(
typ: None, Path(
val: Some( [
LocBox { Ident(
inner: BinOp { "a",
typ: EqEq, ),
left: LocBox { ],
inner: BinOp { ),
typ: Star,
left: LocBox {
inner: Literal(
Number(
Number {
val: 1,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 1,
col: 10,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 1,
col: 14,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 1,
col: 12,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 4,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 1,
col: 18,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 1,
col: 16,
},
},
), ),
}, },
loc: Loc { right: BinOp {
file: "parser/expressions.mcl", typ: EqEq,
line: 1, left: BinOp {
col: 4, typ: Star,
}, left: Literal(
}, Number(
), Number {
Statement( val: 1,
LocBox { base: 10,
inner: Let { signed: false,
name: Ident(
"b",
),
typ: None,
val: Some(
LocBox {
inner: BinOp {
typ: EqEq,
left: LocBox {
inner: BinOp {
typ: Div,
left: LocBox {
inner: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 10,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 4,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 12,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 11,
},
}, },
right: LocBox { ),
inner: UnOp { ),
typ: Star, right: Literal(
right: LocBox { Number(
inner: Path( Number {
Path( val: 3,
[ base: 10,
Ident( signed: false,
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 17,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 16,
},
}, },
),
),
},
right: Literal(
Number(
Number {
val: 4,
base: 10,
signed: false,
}, },
loc: Loc { ),
file: "parser/expressions.mcl",
line: 2,
col: 14,
},
},
), ),
}, },
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 4,
},
},
),
Statement(
LocBox {
inner: Let {
name: Ident(
"c",
),
typ: None,
val: Some(
LocBox {
inner: BinOp {
typ: Div,
left: LocBox {
inner: Group(
LocBox {
inner: PtrFieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 11,
},
},
),
right: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"b",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 13,
},
},
),
right: LocBox {
inner: PtrFieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"c",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 15,
},
},
),
right: LocBox {
inner: Path(
Path(
[
Ident(
"d",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 17,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 16,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 14,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 12,
},
},
),
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 10,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 2,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 22,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 20,
},
},
),
},
loc: Loc {
file: "parser/expressions.mcl",
line: 3,
col: 4,
},
},
),
Statement(
LocBox {
inner: Let {
name: Ident(
"d",
),
typ: None,
val: Some(
LocBox {
inner: BinOp {
typ: Div,
left: LocBox {
inner: Literal(
Number(
Number {
val: 2,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 10,
},
},
right: LocBox {
inner: PtrFieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 14,
},
},
),
right: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"b",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 16,
},
},
),
right: LocBox {
inner: PtrFieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"c",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 18,
},
},
),
right: LocBox {
inner: Path(
Path(
[
Ident(
"d",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 20,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 19,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 17,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 15,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 12,
},
},
),
},
loc: Loc {
file: "parser/expressions.mcl",
line: 4,
col: 4,
},
},
),
Statement(
LocBox {
inner: Let {
name: Ident(
"e",
),
typ: None,
val: Some(
LocBox {
inner: BinOp {
typ: Div,
left: LocBox {
inner: PtrFieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 10,
},
},
),
right: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"b",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 12,
},
},
),
right: LocBox {
inner: PtrFieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"c",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 14,
},
},
),
right: LocBox {
inner: Path(
Path(
[
Ident(
"d",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 16,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 15,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 13,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 11,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 2,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 20,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 18,
},
},
),
},
loc: Loc {
file: "parser/expressions.mcl",
line: 5,
col: 4,
},
},
),
Statement(
LocBox {
inner: Let {
name: Ident(
"f",
),
typ: None,
val: Some(
LocBox {
inner: BinOp {
typ: Div,
left: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 10,
},
},
),
right: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"b",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 12,
},
},
),
right: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"c",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 14,
},
},
),
right: LocBox {
inner: Path(
Path(
[
Ident(
"d",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 16,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 15,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 13,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 11,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 2,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 20,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 18,
},
},
),
},
loc: Loc {
file: "parser/expressions.mcl",
line: 6,
col: 4,
},
},
),
Statement(
LocBox {
inner: Let {
name: Ident(
"g",
),
typ: None,
val: Some(
LocBox {
inner: BinOp {
typ: Star,
left: LocBox {
inner: ArrayIndex {
name: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 10,
},
},
),
right: LocBox {
inner: Path(
Path(
[
Ident(
"b",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 12,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 11,
},
},
index: LocBox {
inner: UnOp {
typ: Star,
right: LocBox {
inner: FieldAccess {
left: Some(
LocBox {
inner: Path(
Path(
[
Ident(
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 15,
},
},
),
right: LocBox {
inner: Path(
Path(
[
Ident(
"c",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 17,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 16,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 14,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 13,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 5,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 22,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 20,
},
},
),
},
loc: Loc {
file: "parser/expressions.mcl",
line: 7,
col: 4,
},
}, },
), ),
], ],

14
tests/parser/expressions.mcl
View File

@ -1,8 +1,8 @@
let a = 1 * 3 == 4; *a = 1 * 3 == 4;
let b = 3/4 == *a; b.c = 3/4 == *a;
let c = (a->b.c->d) / 2; c->d = (a->b.c->d) / 2;
let d = 2 / a->b.c->d; *d->e.f = 2 / a->b.c->d;
let e = a->b.c->d / 2; e = a->b.c->d / 2;
let f = a.b.c.d / 2; f = a.b.c.d / 2;
let g = a.b[*a.c] * 5; g = a.b[*a.c] * 5;

423
tests/parser/functions.exp
View File

@ -2,298 +2,187 @@ Program {
ast: Block( ast: Block(
[ [
Statement( Statement(
LocBox { Fn {
inner: Fn( struct_name: None,
Function { name: Ident(
struct_name: None, "main",
name: Ident( ),
"main", params: [
(
Ident(
"argc",
), ),
params: [ Owned(
( Ident(
Ident( "i32",
"argc",
),
LocBox {
inner: Owned(
Ident(
"i32",
),
),
loc: Loc {
file: "parser/functions.mcl",
line: 1,
col: 18,
},
},
), ),
( ),
Ident( ),
"argv", (
), Ident(
LocBox { "argv",
inner: Ref { ),
inner: Array { Ref {
inner: Owned( inner: Array {
Ident(
"Str",
),
),
},
mutable: false,
},
loc: Loc {
file: "parser/functions.mcl",
line: 1,
col: 27,
},
},
),
],
ret_type: Some(
LocBox {
inner: Owned( inner: Owned(
Ident( Ident(
"i32", "Str",
), ),
), ),
loc: Loc {
file: "parser/functions.mcl",
line: 1,
col: 39,
},
}, },
mutable: false,
},
),
],
ret_type: Some(
Owned(
Ident(
"i32",
), ),
qual_const: false, ),
qual_extern: None, ),
body: Some( qual_const: false,
Block( qual_extern: None,
[ body: Some(
Expr( Block(
LocBox { [
inner: Return( Expr(
Some( Return(
LocBox { Some(
inner: Literal( Literal(
Number( Number(
Number { Number {
val: 0, val: 0,
base: 10, base: 10,
signed: false, signed: false,
}, },
), ),
), ),
loc: Loc { ),
file: "parser/functions.mcl", ),
line: 2, ),
col: 13, ],
}, ),
},
),
),
loc: Loc {
file: "parser/functions.mcl",
line: 2,
col: 11,
},
},
),
],
),
),
},
), ),
loc: Loc {
file: "parser/functions.mcl",
line: 1,
col: 3,
},
}, },
), ),
Statement( Statement(
LocBox { Fn {
inner: Fn( struct_name: Some(
Function { Ident(
struct_name: Some( "Baz",
),
),
name: Ident(
"main",
),
params: [
(
Ident(
"self",
),
Ref {
inner: Owned(
Ident(
"Baz",
),
),
mutable: true,
},
),
(
Ident(
"a",
),
Ref {
inner: Owned(
Ident(
"Foo",
),
),
mutable: false,
},
),
(
Ident(
"b",
),
Ref {
inner: Owned(
Ident(
"Bar",
),
),
mutable: true,
},
),
],
ret_type: Some(
Ref {
inner: Owned(
Ident( Ident(
"Baz", "Nya",
), ),
), ),
name: Ident( mutable: false,
"main",
),
params: [
(
Ident(
"self",
),
LocBox {
inner: Ref {
inner: Owned(
Ident(
"Baz",
),
),
mutable: true,
},
loc: Loc {
file: "parser/functions.mcl",
line: 4,
col: 20,
},
},
),
(
Ident(
"a",
),
LocBox {
inner: Ref {
inner: Owned(
Ident(
"Foo",
),
),
mutable: false,
},
loc: Loc {
file: "parser/functions.mcl",
line: 4,
col: 33,
},
},
),
(
Ident(
"b",
),
LocBox {
inner: Ref {
inner: Owned(
Ident(
"Bar",
),
),
mutable: true,
},
loc: Loc {
file: "parser/functions.mcl",
line: 4,
col: 42,
},
},
),
],
ret_type: Some(
LocBox {
inner: Ref {
inner: Owned(
Ident(
"Nya",
),
),
mutable: false,
},
loc: Loc {
file: "parser/functions.mcl",
line: 4,
col: 54,
},
},
),
qual_const: false,
qual_extern: None,
body: None,
}, },
), ),
loc: Loc { qual_const: false,
file: "parser/functions.mcl", qual_extern: None,
line: 4, body: None,
col: 3,
},
}, },
), ),
Statement( Statement(
LocBox { Fn {
inner: Fn( struct_name: Some(
Function { Ident(
struct_name: Some( "Baz",
),
),
name: Ident(
"main",
),
params: [
(
Ident(
"a",
),
Ref {
inner: Owned(
Ident(
"Foo",
),
),
mutable: false,
},
),
(
Ident(
"b",
),
Ref {
inner: Owned(
Ident(
"Bar",
),
),
mutable: true,
},
),
],
ret_type: Some(
Ref {
inner: Owned(
Ident( Ident(
"Baz", "Nya",
), ),
), ),
name: Ident( mutable: false,
"main",
),
params: [
(
Ident(
"a",
),
LocBox {
inner: Ref {
inner: Owned(
Ident(
"Foo",
),
),
mutable: false,
},
loc: Loc {
file: "parser/functions.mcl",
line: 5,
col: 17,
},
},
),
(
Ident(
"b",
),
LocBox {
inner: Ref {
inner: Owned(
Ident(
"Bar",
),
),
mutable: true,
},
loc: Loc {
file: "parser/functions.mcl",
line: 5,
col: 26,
},
},
),
],
ret_type: Some(
LocBox {
inner: Ref {
inner: Owned(
Ident(
"Nya",
),
),
mutable: false,
},
loc: Loc {
file: "parser/functions.mcl",
line: 5,
col: 38,
},
},
),
qual_const: false,
qual_extern: None,
body: None,
}, },
), ),
loc: Loc { qual_const: false,
file: "parser/functions.mcl", qual_extern: None,
line: 5, body: None,
col: 3,
},
}, },
), ),
], ],

78
tests/parser/if-statements.exp
View File

@ -2,63 +2,35 @@ Program {
ast: Block( ast: Block(
[ [
Expr( Expr(
LocBox { If(
inner: If( IfExpr {
IfExpr { test: BinOp {
test: LocBox { typ: Gt,
inner: BinOp { left: Path(
typ: Gt, Path(
left: LocBox { [
inner: Path( Ident(
Path( "i",
[
Ident(
"i",
),
],
),
), ),
loc: Loc { ],
file: "parser/if-statements.mcl", ),
line: 2, ),
col: 5, right: Literal(
}, Number(
}, Number {
right: LocBox { val: 3,
inner: Literal( base: 10,
Number( signed: false,
Number { },
val: 3, ),
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/if-statements.mcl",
line: 2,
col: 9,
},
},
},
loc: Loc {
file: "parser/if-statements.mcl",
line: 2,
col: 7,
},
},
body: Block(
[],
), ),
else_if: None,
}, },
), body: Block(
loc: Loc { [],
file: "parser/if-statements.mcl", ),
line: 2, else_if: None,
col: 3,
}, },
}, ),
), ),
], ],
), ),

264
tests/parser/loops.exp
View File

@ -2,204 +2,106 @@ Program {
ast: Block( ast: Block(
[ [
Expr( Expr(
LocBox { ForLoop {
inner: ForLoop { init: Statement(
init: Statement( Let {
LocBox { name: Ident(
inner: Let { "i",
name: Ident( ),
"i", typ: None,
), val: Some(
typ: None, Literal(
val: Some( Number(
LocBox { Number {
inner: Literal( val: 0,
Number( base: 10,
Number { signed: false,
val: 0,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/loops.mcl",
line: 1,
col: 14,
},
}, },
), ),
}, ),
loc: Loc { ),
file: "parser/loops.mcl", },
line: 1, ),
col: 8, test: BinOp {
}, typ: Lt,
}, left: Path(
Path(
[
Ident(
"i",
),
],
),
), ),
test: LocBox { right: Literal(
inner: BinOp { Number(
typ: Lt, Number {
left: LocBox { val: 10,
inner: Path( base: 10,
Path( signed: false,
[
Ident(
"i",
),
],
),
),
loc: Loc {
file: "parser/loops.mcl",
line: 1,
col: 17,
},
}, },
right: LocBox { ),
inner: Literal(
Number(
Number {
val: 10,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/loops.mcl",
line: 1,
col: 22,
},
},
},
loc: Loc {
file: "parser/loops.mcl",
line: 1,
col: 19,
},
},
on_loop: LocBox {
inner: BinOp {
typ: AddEq,
left: LocBox {
inner: Path(
Path(
[
Ident(
"i",
),
],
),
),
loc: Loc {
file: "parser/loops.mcl",
line: 1,
col: 25,
},
},
right: LocBox {
inner: Literal(
Number(
Number {
val: 1,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/loops.mcl",
line: 1,
col: 29,
},
},
},
loc: Loc {
file: "parser/loops.mcl",
line: 1,
col: 27,
},
},
body: Block(
[],
), ),
}, },
loc: Loc { on_loop: BinOp {
file: "parser/loops.mcl", typ: AddEq,
line: 1, left: Path(
col: 4, Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 1,
base: 10,
signed: false,
},
),
),
}, },
body: Block(
[],
),
}, },
), ),
Expr( Expr(
LocBox { WhileLoop {
inner: WhileLoop { test: BinOp {
test: LocBox { typ: Gt,
inner: BinOp { left: Path(
typ: Gt, Path(
left: LocBox { [
inner: Path( Ident(
Path( "i",
[
Ident(
"i",
),
],
),
), ),
loc: Loc { ],
file: "parser/loops.mcl", ),
line: 2, ),
col: 8, right: Literal(
}, Number(
Number {
val: 3,
base: 10,
signed: false,
}, },
right: LocBox { ),
inner: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
loc: Loc {
file: "parser/loops.mcl",
line: 2,
col: 12,
},
},
},
loc: Loc {
file: "parser/loops.mcl",
line: 2,
col: 10,
},
},
body: Block(
[],
), ),
}, },
loc: Loc { body: Block(
file: "parser/loops.mcl", [],
line: 2, ),
col: 6,
},
}, },
), ),
Expr( Expr(
LocBox { InfLoop {
inner: InfLoop { body: Block(
body: Block( [],
[], ),
),
},
loc: Loc {
file: "parser/loops.mcl",
line: 3,
col: 5,
},
}, },
), ),
], ],

69
tests/parser/structs.exp
View File

@ -2,58 +2,33 @@ Program {
ast: Block( ast: Block(
[ [
Statement( Statement(
LocBox { Struct {
inner: Struct( name: Ident(
Struct { "foo_t",
name: Ident(
"foo_t",
),
fields: [],
},
), ),
loc: Loc { fields: [],
file: "parser/structs.mcl",
line: 2,
col: 7,
},
}, },
), ),
Statement( Statement(
LocBox { Struct {
inner: Struct( name: Ident(
Struct { "bar_t",
name: Ident(
"bar_t",
),
fields: [
(
Ident(
"a",
),
LocBox {
inner: Ref {
inner: Owned(
Ident(
"bar_t",
),
),
mutable: false,
},
loc: Loc {
file: "parser/structs.mcl",
line: 5,
col: 9,
},
},
),
],
},
), ),
loc: Loc { fields: [
file: "parser/structs.mcl", (
line: 4, Ident(
col: 7, "a",
}, ),
Ref {
inner: Owned(
Ident(
"bar_t",
),
),
mutable: false,
},
),
],
}, },
), ),
], ],