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

Fix bugs, add propper tests

Browse Source
This commit is contained in:
Gvidas Juknevičius
2026-02-03 13:20:23 +02:00
parent 081ff9a27a
commit 4b61adea5d
58 changed files with 1103 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
old_tests/parser/enumerations.exp Normal file
View File

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

7
old_tests/parser/enumerations.mcl Normal file
View File

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

908
old_tests/parser/expressions.exp Normal file
View File

@@ -0,0 +1,908 @@
Program {
ast: Block(
[
Statement(
LocBox {
inner: Let {
name: Ident(
"a",
),
typ: None,
val: Some(
LocBox {
inner: BinOp {
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 {
file: "parser/expressions.mcl",
line: 1,
col: 4,
},
},
),
Statement(
LocBox {
inner: Let {
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: LocBox {
inner: Path(
Path(
[
Ident(
"a",
),
],
),
),
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 17,
},
},
},
loc: Loc {
file: "parser/expressions.mcl",
line: 2,
col: 16,
},
},
},
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,
},
},
),
],
),
structs: {},
enums: {},
types: {},
functions: {},
member_functions: {},
}

8
old_tests/parser/expressions.mcl Normal file
View File

@@ -0,0 +1,8 @@
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;

306
old_tests/parser/functions.exp Normal file
View File

@@ -0,0 +1,306 @@
Program {
ast: Block(
[
Statement(
LocBox {
inner: Fn(
Function {
struct_name: None,
name: Ident(
"main",
),
params: [
(
Ident(
"argc",
),
LocBox {
inner: Owned(
Ident(
"i32",
),
),
loc: Loc {
file: "parser/functions.mcl",
line: 1,
col: 18,
},
},
),
(
Ident(
"argv",
),
LocBox {
inner: Ref {
inner: Array {
inner: Owned(
Ident(
"Str",
),
),
},
mutable: false,
},
loc: Loc {
file: "parser/functions.mcl",
line: 1,
col: 27,
},
},
),
],
ret_type: Some(
LocBox {
inner: Owned(
Ident(
"i32",
),
),
loc: Loc {
file: "parser/functions.mcl",
line: 1,
col: 39,
},
},
),
qual_const: false,
qual_extern: None,
body: Some(
Block(
[
Expr(
LocBox {
inner: Return(
Some(
LocBox {
inner: Literal(
Number(
Number {
val: 0,
base: 10,
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(
LocBox {
inner: Fn(
Function {
struct_name: Some(
Ident(
"Baz",
),
),
name: Ident(
"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 {
file: "parser/functions.mcl",
line: 4,
col: 3,
},
},
),
Statement(
LocBox {
inner: Fn(
Function {
struct_name: Some(
Ident(
"Baz",
),
),
name: Ident(
"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 {
file: "parser/functions.mcl",
line: 5,
col: 3,
},
},
),
],
),
structs: {},
enums: {},
types: {},
functions: {},
member_functions: {},
}

5
old_tests/parser/functions.mcl Normal file
View File

@@ -0,0 +1,5 @@
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;

70
old_tests/parser/if-statements.exp Normal file
View File

@@ -0,0 +1,70 @@
Program {
ast: Block(
[
Expr(
LocBox {
inner: If(
IfExpr {
test: LocBox {
inner: BinOp {
typ: Gt,
left: LocBox {
inner: Path(
Path(
[
Ident(
"i",
),
],
),
),
loc: Loc {
file: "parser/if-statements.mcl",
line: 2,
col: 5,
},
},
right: LocBox {
inner: Literal(
Number(
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,
},
),
loc: Loc {
file: "parser/if-statements.mcl",
line: 2,
col: 3,
},
},
),
],
),
structs: {},
enums: {},
types: {},
functions: {},
member_functions: {},
}

18
old_tests/parser/if-statements.mcl Normal file
View File

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

212
old_tests/parser/loops.exp Normal file
View File

@@ -0,0 +1,212 @@
Program {
ast: Block(
[
Expr(
LocBox {
inner: ForLoop {
init: Statement(
LocBox {
inner: Let {
name: Ident(
"i",
),
typ: None,
val: Some(
LocBox {
inner: Literal(
Number(
Number {
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: LocBox {
inner: BinOp {
typ: Lt,
left: LocBox {
inner: Path(
Path(
[
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 {
file: "parser/loops.mcl",
line: 1,
col: 4,
},
},
),
Expr(
LocBox {
inner: WhileLoop {
test: LocBox {
inner: BinOp {
typ: Gt,
left: LocBox {
inner: Path(
Path(
[
Ident(
"i",
),
],
),
),
loc: Loc {
file: "parser/loops.mcl",
line: 2,
col: 8,
},
},
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 {
file: "parser/loops.mcl",
line: 2,
col: 6,
},
},
),
Expr(
LocBox {
inner: InfLoop {
body: Block(
[],
),
},
loc: Loc {
file: "parser/loops.mcl",
line: 3,
col: 5,
},
},
),
],
),
structs: {},
enums: {},
types: {},
functions: {},
member_functions: {},
}

3
old_tests/parser/loops.mcl Normal file
View File

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

66
old_tests/parser/structs.exp Normal file
View File

@@ -0,0 +1,66 @@
Program {
ast: Block(
[
Statement(
LocBox {
inner: Struct(
Struct {
name: Ident(
"foo_t",
),
fields: [],
},
),
loc: Loc {
file: "parser/structs.mcl",
line: 2,
col: 7,
},
},
),
Statement(
LocBox {
inner: Struct(
Struct {
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 {
file: "parser/structs.mcl",
line: 4,
col: 7,
},
},
),
],
),
structs: {},
enums: {},
types: {},
functions: {},
member_functions: {},
}

6
old_tests/parser/structs.mcl Normal file
View File

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

1
old_tests/tokeniser/comments.exp Normal file
View File

@@ -0,0 +1 @@
[]

7
old_tests/tokeniser/comments.mcl Normal file
View File

@@ -0,0 +1,7 @@
// Hello, this is a single line comment
/*
And this is a multiline comment, which is
useful for longer documentation
*/

62
old_tests/tokeniser/delimiters.exp Normal file
View File

@@ -0,0 +1,62 @@
[
Token {
loc: Loc {
file: "tokeniser/delimiters.mcl",
line: 3,
col: 4,
},
tt: Delim(
ParenR,
),
},
Token {
loc: Loc {
file: "tokeniser/delimiters.mcl",
line: 3,
col: 2,
},
tt: Delim(
ParenL,
),
},
Token {
loc: Loc {
file: "tokeniser/delimiters.mcl",
line: 2,
col: 4,
},
tt: Delim(
CurlyR,
),
},
Token {
loc: Loc {
file: "tokeniser/delimiters.mcl",
line: 2,
col: 2,
},
tt: Delim(
CurlyL,
),
},
Token {
loc: Loc {
file: "tokeniser/delimiters.mcl",
line: 1,
col: 4,
},
tt: Delim(
SquareR,
),
},
Token {
loc: Loc {
file: "tokeniser/delimiters.mcl",
line: 1,
col: 2,
},
tt: Delim(
SquareL,
),
},
]

3
old_tests/tokeniser/delimiters.mcl Normal file
View File

@@ -0,0 +1,3 @@
[ ]
{ }
( )

212
old_tests/tokeniser/keywords.exp Normal file
View File

@@ -0,0 +1,212 @@
[
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 21,
col: 5,
},
tt: Keyword(
Loop,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 20,
col: 3,
},
tt: Keyword(
As,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 19,
col: 7,
},
tt: Keyword(
Return,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 18,
col: 7,
},
tt: Keyword(
Extern,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 17,
col: 8,
},
tt: Keyword(
Include,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 16,
col: 6,
},
tt: Keyword(
False,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 15,
col: 5,
},
tt: Keyword(
True,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 14,
col: 7,
},
tt: Keyword(
Static,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 13,
col: 4,
},
tt: Keyword(
Mut,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 12,
col: 6,
},
tt: Keyword(
Const,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 11,
col: 4,
},
tt: Keyword(
Let,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 10,
col: 9,
},
tt: Keyword(
Continue,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 9,
col: 6,
},
tt: Keyword(
Break,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 8,
col: 4,
},
tt: Keyword(
For,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 7,
col: 6,
},
tt: Keyword(
While,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 6,
col: 5,
},
tt: Keyword(
Type,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 5,
col: 5,
},
tt: Keyword(
Enum,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 4,
col: 7,
},
tt: Keyword(
Struct,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 3,
col: 5,
},
tt: Keyword(
Else,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 2,
col: 3,
},
tt: Keyword(
If,
),
},
Token {
loc: Loc {
file: "tokeniser/keywords.mcl",
line: 1,
col: 3,
},
tt: Keyword(
Fn,
),
},
]

21
old_tests/tokeniser/keywords.mcl Normal file
View File

@@ -0,0 +1,21 @@
fn
if
else
struct
enum
type
while
for
break
continue
let
const
mut
static
true
false
include
extern
return
as
loop

96
old_tests/tokeniser/literals.exp Normal file
View File

@@ -0,0 +1,96 @@
[
Token {
loc: Loc {
file: "tokeniser/literals.mcl",
line: 7,
col: 11,
},
tt: Number(
Number {
val: 173,
base: 2,
signed: false,
},
),
},
Token {
loc: Loc {
file: "tokeniser/literals.mcl",
line: 6,
col: 8,
},
tt: Number(
Number {
val: 13633,
base: 8,
signed: false,
},
),
},
Token {
loc: Loc {
file: "tokeniser/literals.mcl",
line: 5,
col: 9,
},
tt: Number(
Number {
val: 16759299,
base: 16,
signed: false,
},
),
},
Token {
loc: Loc {
file: "tokeniser/literals.mcl",
line: 4,
col: 3,
},
tt: Number(
Number {
val: 21,
base: 10,
signed: false,
},
),
},
Token {
loc: Loc {
file: "tokeniser/literals.mcl",
line: 3,
col: 22,
},
tt: String(
TString {
val: "this is a c string!",
cstr: true,
},
),
},
Token {
loc: Loc {
file: "tokeniser/literals.mcl",
line: 2,
col: 27,
},
tt: String(
TString {
val: "this is a normal string!",
cstr: false,
},
),
},
Token {
loc: Loc {
file: "tokeniser/literals.mcl",
line: 1,
col: 4,
},
tt: Char(
Char(
'c',
),
),
},
]

8
old_tests/tokeniser/literals.mcl Normal file
View File

@@ -0,0 +1,8 @@
'c'
"this is a normal string!"
c"this is a c string!"
21
0xFfbA03
0o32501
0b10101101

382
old_tests/tokeniser/punctuation.exp Normal file
View File

@@ -0,0 +1,382 @@
[
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 38,
col: 2,
},
tt: Punct(
Pathaccess,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 37,
col: 2,
},
tt: Punct(
Fieldaccess,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 36,
col: 2,
},
tt: Punct(
Neq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 35,
col: 2,
},
tt: Punct(
EqEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 34,
col: 2,
},
tt: Punct(
Eq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 33,
col: 2,
},
tt: Punct(
XorEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 32,
col: 2,
},
tt: Punct(
OrEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 31,
col: 2,
},
tt: Punct(
AndEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 30,
col: 2,
},
tt: Punct(
ShrEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 29,
col: 2,
},
tt: Punct(
ShlEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 28,
col: 2,
},
tt: Punct(
ModEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 27,
col: 2,
},
tt: Punct(
MulEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 26,
col: 2,
},
tt: Punct(
DivEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 25,
col: 2,
},
tt: Punct(
SubEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 24,
col: 2,
},
tt: Punct(
AddEq,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 23,
col: 2,
},
tt: Punct(
Xor,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 22,
col: 2,
},
tt: Punct(
Le,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 21,
col: 2,
},
tt: Punct(
Ge,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 20,
col: 2,
},
tt: Punct(
Lt,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 19,
col: 2,
},
tt: Punct(
Gt,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 18,
col: 2,
},
tt: Punct(
Or,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 17,
col: 2,
},
tt: Punct(
OrOr,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 16,
col: 2,
},
tt: Punct(
AndAnd,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 15,
col: 2,
},
tt: Punct(
Shr,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 14,
col: 2,
},
tt: Punct(
Shl,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 13,
col: 2,
},
tt: Punct(
Mod,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 12,
col: 2,
},
tt: Punct(
Div,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 11,
col: 2,
},
tt: Punct(
Not,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 10,
col: 2,
},
tt: Punct(
Star,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 9,
col: 2,
},
tt: Punct(
Ampersand,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 8,
col: 2,
},
tt: Punct(
Comma,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 7,
col: 2,
},
tt: Punct(
Minus,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 6,
col: 2,
},
tt: Punct(
Plus,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 5,
col: 2,
},
tt: Punct(
FatArrow,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 4,
col: 2,
},
tt: Punct(
Arrow,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 3,
col: 2,
},
tt: Punct(
Pathaccess,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 2,
col: 2,
},
tt: Punct(
Colon,
),
},
Token {
loc: Loc {
file: "tokeniser/punctuation.mcl",
line: 1,
col: 2,
},
tt: Punct(
Semi,
),
},
]

39
old_tests/tokeniser/punctuation.mcl Normal file
View File

@@ -0,0 +1,39 @@
;
:
::
->
=>
+
-
,
&
*
!
/
%
<<
>>
&&
||
|
>
<
>=
<=
^
+=
-=
/=
*=
%=
<<=
>>=
&=
|=
^=
=
==
!=
.
::