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

Compare commits

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

No commits in common. "323d3342a3d37ef37710664ecb885036c39544ce" and "debcf6ad6cc5cdb362ad1655008ab0dd89d4d14a" have entirely different histories.
323d3342a3 ... debcf6ad6c

19 changed files with 57 additions and 659 deletions
Show Stats Expand all files Collapse all files

2
Cargo.toml
View File

@ -2,7 +2,7 @@
name = "mclangc" name = "mclangc"
version = "0.1.0" version = "0.1.0"
edition = "2021" edition = "2021"
default-run = "mclangc"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]

1
src/bin/test/main.rs
View File

@ -1,4 +1,5 @@
use std::{collections::HashMap, ffi::OsStr, io::Write, os::unix::ffi::OsStrExt, path::{Path, PathBuf}, process::ExitCode}; use std::{collections::HashMap, ffi::OsStr, io::Write, os::unix::ffi::OsStrExt, path::{Path, PathBuf}, process::ExitCode};
use anyhow::bail;
use camino::Utf8PathBuf; use camino::Utf8PathBuf;
use clap::Parser; use clap::Parser;
use mclangc; use mclangc;

36
src/cli.rs
View File

@ -1,39 +1,3 @@
use clap::{error::ErrorKind, CommandFactory};
use crate::logger::Level;
#[derive(Debug, clap::Parser)]
pub struct CliArgs {
/// Output more info, will get overwritten if -q|--quiet is specified
#[arg(long, short)]
verbose: bool,
/// Output nothing, except errors, will overwrite -v|--verbose
#[arg(long, short)]
quiet: bool,
/// Output file
#[arg(long, short, default_value="a.out")]
pub output: String,
/// All input files
#[clap(num_args = 1..)]
pub input: Vec<String>
}
impl CliArgs {
pub fn set_log_level(&self) {
if self.quiet {
unsafe {
crate::logger::LEVEL = Level::Error;
}
} else if self.verbose {
unsafe {
crate::logger::LEVEL = Level::Debug;
}
}
}
pub fn validate(&self) {
if self.input.len() < 1 {
CliArgs::command().error(ErrorKind::TooFewValues, "at least one value is required for '<INPUT>' but none was supplied").exit();
}
}
}

112
src/logger.rs
View File

@ -1,8 +1,8 @@
pub static mut LEVEL: Level = Level::Info; use crate::common::Loc;
#[allow(dead_code)]
#[repr(u8)] #[repr(u8)]
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] #[derive(Debug, Default)]
pub enum Level { pub enum Level {
Off = 0, Off = 0,
Error, Error,
@ -20,38 +20,26 @@ const C_INFO: &'static str = "\x1B[1;32m";
const C_DEBUG: &'static str = "\x1B[1;35m"; const C_DEBUG: &'static str = "\x1B[1;35m";
const C_HELP: &'static str = "\x1B[1;36m"; const C_HELP: &'static str = "\x1B[1;36m";
pub fn _log(dbg_loc: Option<(&'static str, u32, u32)>, level: Level, str: &str) { pub fn _log(level: Level, str: &str) {
if level > unsafe { LEVEL }{ match level {
return; Level::Off => return,
} Level::Error => println!("{C_ERROR}error{C_RESET}: {str}"),
let dbg = if let Some((file, line, col)) = dbg_loc { Level::Warn => println!("{C_WARN}warn{C_RESET}: {str}"),
format!("{file}:{line}:{col}: ") Level::Info => println!("{C_INFO}info{C_RESET}: {str}"),
} else {String::new()}; Level::Help => println!("{C_HELP}help{C_RESET}: {str}"),
match level { Level::Debug => println!("{C_DEBUG}debug{C_RESET}: {str}"),
Level::Off => return, }
Level::Error => println!("{dbg}{C_ERROR}error{C_RESET}: {str}"),
Level::Warn => println!("{dbg}{C_WARN}warn{C_RESET}: {str}"),
Level::Info => println!("{dbg}{C_INFO}info{C_RESET}: {str}"),
Level::Help => println!("{dbg}{C_HELP}help{C_RESET}: {str}"),
Level::Debug => println!("{dbg}{C_DEBUG}debug{C_RESET}: {str}"),
}
} }
pub fn _log_with_loc(dbg_loc: Option<(&'static str, u32, u32)>, loc: String, level: Level, str: &str) { pub fn _log_with_loc(loc: &Loc, level: Level, str: &str) {
if level > unsafe { LEVEL }{ match level {
return;
}
let dbg = if let Some((file, line, col)) = dbg_loc {
format!("{file}:{line}:{col}: ")
} else {String::new()};
match level {
Level::Off => return, Level::Off => return,
Level::Error => println!("{dbg}{loc}: {C_ERROR}error{C_RESET}: {str}"), Level::Error => println!("{loc}: {C_ERROR}error{C_RESET}: {str}"),
Level::Warn => println!("{dbg}{loc}: {C_WARN}warn{C_RESET}: {str}"), Level::Warn => println!("{loc}: {C_WARN}warn{C_RESET}: {str}"),
Level::Info => println!("{dbg}{loc}: {C_INFO}info{C_RESET}: {str}"), Level::Info => println!("{loc}: {C_INFO}info{C_RESET}: {str}"),
Level::Help => println!("{dbg}{loc}: {C_HELP}help{C_RESET}: {str}"), Level::Help => println!("{loc}: {C_HELP}help{C_RESET}: {str}"),
Level::Debug => println!("{dbg}{loc}: {C_DEBUG}debug{C_RESET}: {str}"), Level::Debug => println!("{loc}: {C_DEBUG}debug{C_RESET}: {str}"),
} }
} }
#[macro_use] #[macro_use]
@ -59,51 +47,31 @@ pub mod log {
#[macro_export] #[macro_export]
macro_rules! error { macro_rules! error {
($($arg:tt)*) => { ($($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log(crate::logger::Level::Error, &format!($($arg)*))
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Error, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Error, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! warn { macro_rules! warn {
($($arg:tt)*) => { ($($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log(crate::logger::Level::Warn, &format!($($arg)*))
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Warn, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Warn, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! info { macro_rules! info {
($($arg:tt)*) => { ($($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log(crate::logger::Level::Info, &format!($($arg)*))
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Info, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Info, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! help { macro_rules! help {
($($arg:tt)*) => { ($($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log(crate::logger::Level::Help, &format!($($arg)*))
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Help, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Help, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! debug { macro_rules! debug {
($($arg:tt)*) => { ($($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log(crate::logger::Level::Debug, &format!($($arg)*))
crate::logger::_log(Some((file!(), line!(), column!())), crate::logger::Level::Debug, &format!($($arg)*))
} else {
crate::logger::_log(None, crate::logger::Level::Debug, &format!($($arg)*))
}
}; };
} }
@ -111,51 +79,31 @@ pub mod log {
#[macro_export] #[macro_export]
macro_rules! lerror { macro_rules! lerror {
($loc:expr, $($arg:tt)*) => { ($loc:expr, $($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log_with_loc($loc, crate::logger::Level::Error, &format!($($arg)*))
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Error, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Error, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! lwarn { macro_rules! lwarn {
($loc:expr, $($arg:tt)*) => { ($loc:expr, $($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log_with_loc($loc, crate::logger::Level::Warn, &format!($($arg)*))
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Warn, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Warn, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! linfo { macro_rules! linfo {
($loc:expr, $($arg:tt)*) => { ($loc:expr, $($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log_with_loc($loc, crate::logger::Level::Info, &format!($($arg)*))
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Info, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Info, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! lhelp { macro_rules! lhelp {
($loc:expr, $($arg:tt)*) => { ($loc:expr, $($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log_with_loc($loc, crate::logger::Level::Help, &format!($($arg)*))
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Help, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Help, &format!($($arg)*))
}
}; };
} }
#[macro_export] #[macro_export]
macro_rules! ldebug { macro_rules! ldebug {
($loc:expr, $($arg:tt)*) => { ($loc:expr, $($arg:tt)*) => {
if cfg!(debug_assertions) { crate::logger::_log_with_loc($loc, crate::logger::Level::Debug, &format!($($arg)*))
crate::logger::_log_with_loc(Some((file!(), line!(), column!())), format!("{}", $loc), crate::logger::Level::Debug, &format!($($arg)*))
} else {
crate::logger::_log_with_loc(None, format!("{}", $loc), crate::logger::Level::Debug, &format!($($arg)*))
}
}; };
} }
} }

40
src/main.rs
View File

@ -1,39 +1,11 @@
use std::{path::PathBuf, process::ExitCode};
use clap::Parser;
// Importing logger here too cause the logger macros dont work outside the mclanc lib
mod logger;
fn main() -> anyhow::Result<()> {
let data = std::fs::read_to_string("test.mcl").unwrap();
fn main() -> ExitCode { let tokens = mclangc::tokeniser::tokenise(&data, "test.mcl")?;
let cli = mclangc::cli::CliArgs::parse(); let prog = mclangc::parser::parse_program(tokens)?;
cli.set_log_level(); mclangc::validator::validate_code(&prog);
cli.validate(); Ok(())
for file in &cli.input {
let fp = PathBuf::from(file);
if !fp.exists() {
error!("File {fp:?} doesnt exits, exiting");
return ExitCode::FAILURE;
}
let data = std::fs::read_to_string(fp).unwrap();
info!("Tokenising {file}");
let Ok(tokens) = mclangc::tokeniser::tokenise(&data, &file) else {
error!("Failed to tokenise file, exiting");
return ExitCode::FAILURE;
};
info!("Parsing {file}");
let Ok(prog) = mclangc::parser::parse_program(tokens) else {
error!("Failed to parse file, exiting");
return ExitCode::FAILURE;
};
info!("Validating {file}");
let Ok(validated) = mclangc::validator::validate_code(&prog) else {
error!("Failed to validate file, exiting");
return ExitCode::FAILURE;
};
}
ExitCode::SUCCESS
} }

31
src/parser/expr.rs
View File

@ -2,7 +2,7 @@ use std::collections::HashMap;
use anyhow::{bail, Result}; use anyhow::{bail, Result};
use crate::{debug, error, lerror, parser::{typ::parse_type, Punctuation}, tokeniser::Token}; use crate::{debug, 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};
@ -108,11 +108,12 @@ pub fn parse_expr(tokens: &mut Vec<Token>, precedence: usize, consume_semi: bool
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)?));
} else { } else {
if consume_semi {
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "Expected ; at the end of the expression")?;
}
return Ok(Some(res)); return Ok(Some(res));
} }
}
if consume_semi {
_ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "Expected ; at the end of the expression")?;
} }
Ok(res) Ok(res)
} }
@ -137,17 +138,7 @@ fn parse_if(tokens: &mut Vec<Token>) -> Result<IfExpr> {
lerror!(loc.loc(), "Expected test for if statement, got nothing"); lerror!(loc.loc(), "Expected test for if statement, got nothing");
bail!("") bail!("")
}; };
let block = if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyL)) { let block = parse_block(tokens)?;
if let Some(_) = utils::check_2_last(tokens, TokenType::Delim(Delimiter::CurlyR)) {
_ = utils::check_consume(tokens, TokenType::Delim(Delimiter::CurlyR));
Block(Vec::new())
} else {
parse_block(tokens)?
}
} else {
lerror!(loc.loc(), "Expected '{{'");
bail!("")
};
if let Some(_) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Else)) { if let Some(_) = utils::check_consume(tokens, TokenType::Keyword(Keyword::Else)) {
if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::If)) { if let Some(_) = utils::check(tokens, TokenType::Keyword(Keyword::If)) {
let branch = IfBranchExpr::ElseIf(Box::new(parse_if(tokens)?)); let branch = IfBranchExpr::ElseIf(Box::new(parse_if(tokens)?));
@ -190,7 +181,7 @@ fn parse_for_loop(tokens: &mut Vec<Token>) -> Result<Expr> {
lerror!(loc.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 _ = utils::check_consume_or_err(tokens, TokenType::Punct(Punctuation::Semi), "");
let Some(test) = parse_expr(tokens, 0, false)? else { let Some(test) = parse_expr(tokens, 0, false)? else {
lerror!(loc.loc(), "Expected test comparrison for a for loop, got nothing"); lerror!(loc.loc(), "Expected test comparrison for a for loop, got nothing");
bail!("") bail!("")
@ -449,14 +440,14 @@ pub fn parse_block(tokens: &mut Vec<Token>) -> Result<Block> {
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyL), "")?; utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyL), "")?;
let mut items = Vec::new(); let mut items = Vec::new();
while !tokens.is_empty() { while !tokens.is_empty() {
if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyR)) {
break;
}
if let Some(item) = parse_item(tokens)? { if let Some(item) = parse_item(tokens)? {
items.push(item); items.push(item);
} else { } else {
break; break;
} }
if let Some(_) = utils::check(tokens, TokenType::Delim(Delimiter::CurlyR)) {
break;
}
} }
utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyR), "")?; utils::check_consume_or_err(tokens, TokenType::Delim(Delimiter::CurlyR), "")?;
Ok(Block(items)) Ok(Block(items))

5
src/parser/typ.rs
View File

@ -1,6 +1,6 @@
use anyhow::Result; use anyhow::Result;
use crate::{parser::Delimiter, tokeniser::Token}; use crate::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};
@ -15,7 +15,7 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<Type> {
} }
let mut typ; let mut typ;
if let Some(_) = utils::check_consume(tokens, TokenType::Delim(super::Delimiter::SquareL)) { if let Some(_) = utils::check(tokens, TokenType::Delim(super::Delimiter::SquareL)) {
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();
@ -28,7 +28,6 @@ pub fn parse_type(tokens: &mut Vec<Token>) -> Result<Type> {
inner: Box::new(itm_typ), inner: Box::new(itm_typ),
} }
} }
_ = 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());

29
tests/parser/enumerations.exp
View File

@ -1,33 +1,6 @@
Program { Program {
ast: Block( ast: Block(
[ [],
Statement(
Enum {
name: Ident(
"Foo",
),
fields: [],
},
),
Statement(
Enum {
name: Ident(
"Bar",
),
fields: [
Ident(
"A",
),
Ident(
"B",
),
Ident(
"C",
),
],
},
),
],
), ),
structs: {}, structs: {},
enums: {}, enums: {},

7
tests/parser/enumerations.mcl
View File

@ -1,7 +0,0 @@
enum Foo {}
enum Bar {
A,
B,
C,
}

53
tests/parser/expressions.exp
View File

@ -1,57 +1,6 @@
Program { Program {
ast: Block( ast: Block(
[ [],
Expr(
BinOp {
typ: Eq,
left: UnOp {
typ: Star,
right: Path(
Path(
[
Ident(
"a",
),
],
),
),
},
right: BinOp {
typ: EqEq,
left: BinOp {
typ: Star,
left: Literal(
Number(
Number {
val: 1,
base: 10,
signed: false,
},
),
),
right: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
},
right: Literal(
Number(
Number {
val: 4,
base: 10,
signed: false,
},
),
),
},
},
),
],
), ),
structs: {}, structs: {},
enums: {}, enums: {},

8
tests/parser/expressions.mcl
View File

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

187
tests/parser/functions.exp
View File

@ -1,191 +1,6 @@
Program { Program {
ast: Block( ast: Block(
[ [],
Statement(
Fn {
struct_name: None,
name: Ident(
"main",
),
params: [
(
Ident(
"argc",
),
Owned(
Ident(
"i32",
),
),
),
(
Ident(
"argv",
),
Ref {
inner: Array {
inner: Owned(
Ident(
"Str",
),
),
},
mutable: false,
},
),
],
ret_type: Some(
Owned(
Ident(
"i32",
),
),
),
qual_const: false,
qual_extern: None,
body: Some(
Block(
[
Expr(
Return(
Some(
Literal(
Number(
Number {
val: 0,
base: 10,
signed: false,
},
),
),
),
),
),
],
),
),
},
),
Statement(
Fn {
struct_name: Some(
Ident(
"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(
"Nya",
),
),
mutable: false,
},
),
qual_const: false,
qual_extern: None,
body: None,
},
),
Statement(
Fn {
struct_name: Some(
Ident(
"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(
"Nya",
),
),
mutable: false,
},
),
qual_const: false,
qual_extern: None,
body: None,
},
),
],
), ),
structs: {}, structs: {},
enums: {}, enums: {},

5
tests/parser/functions.mcl
View File

@ -1,5 +0,0 @@
fn main(argc: i32, argv: &[Str]) -> i32 {
return 0;
}
fn Baz.main(self: &mut Baz, a: &Foo, b: &mut Bar) -> &Nya;
fn Baz.main(a: &Foo, b: &mut Bar) -> &Nya;

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

@ -1,38 +1,6 @@
Program { Program {
ast: Block( ast: Block(
[ [],
Expr(
If(
IfExpr {
test: BinOp {
typ: Gt,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
},
body: Block(
[],
),
else_if: None,
},
),
),
],
), ),
structs: {}, structs: {},
enums: {}, enums: {},

18
tests/parser/if-statements.mcl
View File

@ -1,18 +0,0 @@
if i > 3 {
}
if 1 {
} else {
}
if 1 {
} else if a > 3 {
} else {
}

106
tests/parser/loops.exp
View File

@ -1,110 +1,6 @@
Program { Program {
ast: Block( ast: Block(
[ [],
Expr(
ForLoop {
init: Statement(
Let {
name: Ident(
"i",
),
typ: None,
val: Some(
Literal(
Number(
Number {
val: 0,
base: 10,
signed: false,
},
),
),
),
},
),
test: BinOp {
typ: Lt,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 10,
base: 10,
signed: false,
},
),
),
},
on_loop: BinOp {
typ: AddEq,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 1,
base: 10,
signed: false,
},
),
),
},
body: Block(
[],
),
},
),
Expr(
WhileLoop {
test: BinOp {
typ: Gt,
left: Path(
Path(
[
Ident(
"i",
),
],
),
),
right: Literal(
Number(
Number {
val: 3,
base: 10,
signed: false,
},
),
),
},
body: Block(
[],
),
},
),
Expr(
InfLoop {
body: Block(
[],
),
},
),
],
), ),
structs: {}, structs: {},
enums: {}, enums: {},

3
tests/parser/loops.mcl
View File

@ -1,3 +0,0 @@
for let i = 0; i < 10; i += 1 {}
while i > 3 {}
loop {}

33
tests/parser/structs.exp
View File

@ -1,37 +1,6 @@
Program { Program {
ast: Block( ast: Block(
[ [],
Statement(
Struct {
name: Ident(
"foo_t",
),
fields: [],
},
),
Statement(
Struct {
name: Ident(
"bar_t",
),
fields: [
(
Ident(
"a",
),
Ref {
inner: Owned(
Ident(
"bar_t",
),
),
mutable: false,
},
),
],
},
),
],
), ),
structs: {}, structs: {},
enums: {}, enums: {},

6
tests/parser/structs.mcl
View File

@ -1,6 +0,0 @@
struct foo_t {}
struct bar_t {
a: &bar_t
}