Files
@ ed4fe8216eb0
Branch filter:
Location: CSY/reowolf/src/protocol/tests/lexer.rs
ed4fe8216eb0
3.3 KiB
application/rls-services+xml
Fix binding- and assignment-expression related typing issues.
Simpler solutions are better, so the typechecker is back to normal.
Instead we simply make sure that assignment expression is never
nested under another expression, and binding expressions may only
be nested under LogicalAnd-expressions. If only I knew why I thought
type shenanigans were a good idea in the first place...
Simpler solutions are better, so the typechecker is back to normal.
Instead we simply make sure that assignment expression is never
nested under another expression, and binding expressions may only
be nested under LogicalAnd-expressions. If only I knew why I thought
type shenanigans were a good idea in the first place...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | /// lexer.rs
///
/// Simple tests for the lexer. Only tests the lexing of the input source and
/// the resulting AST without relying on the validation/typing pass
use super::*;
#[test]
fn test_disallowed_inference() {
Tester::new_single_source_expect_err(
"argument auto inference",
"func thing(auto arg) -> s32 { return 0; }"
).error(|e| { e
.assert_msg_has(0, "inference is not allowed")
.assert_occurs_at(0, "auto arg");
});
Tester::new_single_source_expect_err(
"return type auto inference",
"func thing(s32 arg) -> auto { return 0; }"
).error(|e| { e
.assert_msg_has(0, "inference is not allowed")
.assert_occurs_at(0, "auto {");
});
Tester::new_single_source_expect_err(
"implicit polymorph argument auto inference",
"func thing(in port) -> s32 { return port; }"
).error(|e| { e
.assert_msg_has(0, "inference is not allowed")
.assert_occurs_at(0, "in port");
});
Tester::new_single_source_expect_err(
"explicit polymorph argument auto inference",
"func thing(in<auto> port) -> s32 { return port; }"
).error(|e| { e
.assert_msg_has(0, "inference is not allowed")
.assert_occurs_at(0, "auto> port");
});
Tester::new_single_source_expect_err(
"implicit polymorph return type auto inference",
"func thing(in<msg> a, in<msg> b) -> in { return a; }"
).error(|e| { e
.assert_msg_has(0, "inference is not allowed")
.assert_occurs_at(0, "in {");
});
Tester::new_single_source_expect_err(
"explicit polymorph return type auto inference",
"func thing(in<msg> a) -> in<auto> { return a; }"
).error(|e| { e
.assert_msg_has(0, "inference is not allowed")
.assert_occurs_at(0, "auto> {");
});
}
#[test]
fn test_simple_struct_definition() {
Tester::new_single_source_expect_ok(
"empty struct",
"struct Foo{}"
).for_struct("Foo", |t| { t.assert_num_fields(0); });
Tester::new_single_source_expect_ok(
"single field, no comma",
"struct Foo{ s32 field }"
).for_struct("Foo", |t| { t
.assert_num_fields(1)
.for_field("field", |f| {
f.assert_parser_type("s32");
});
});
Tester::new_single_source_expect_ok(
"single field, with comma",
"struct Foo{ s32 field, }"
).for_struct("Foo", |t| { t
.assert_num_fields(1)
.for_field("field", |f| { f
.assert_parser_type("s32");
});
});
Tester::new_single_source_expect_ok(
"multiple fields, no comma",
"struct Foo{ u8 a, s16 b, s32 c }"
).for_struct("Foo", |t| { t
.assert_num_fields(3)
.for_field("a", |f| { f.assert_parser_type("u8"); })
.for_field("b", |f| { f.assert_parser_type("s16"); })
.for_field("c", |f| { f.assert_parser_type("s32"); });
});
Tester::new_single_source_expect_ok(
"multiple fields, with comma",
"struct Foo{
u8 a,
s16 b,
s32 c,
}"
).for_struct("Foo", |t| { t
.assert_num_fields(3)
.for_field("a", |f| { f.assert_parser_type("u8"); })
.for_field("b", |f| { f.assert_parser_type("s16"); })
.for_field("c", |f| { f.assert_parser_type("s32"); });
});
}
|