CSY/reowolf Changeset - 8ae142310cc7 · Centrum Wiskunde & Informatica (CWI)

Changeset - 8ae142310cc7

Parent rev.

Child rev.

[Not reviewed]

2 4 2

MH - 4 years ago 2021-12-21 11:58:35
contact@maxhenger.nl

Add some tests before refactoring variable resolving

7 files changed with 216 insertions and 111 deletions:

src/protocol/parser/pass_validation_linking.rs

src/protocol/tests/mod.rs

src/protocol/tests/parser_after_tokenizing.rs

109

src/protocol/tests/parser_inference.rs

src/protocol/tests/parser_type_declaration.rs

src/protocol/tests/parser_type_layout.rs

rename

src/protocol/tests/parser_validation.rs

108

0 comments (0 inline, 0 general)

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -256,12 +256,15 @@ impl Visitor for PassValidationLinking { @@
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         self.visit_block_stmt_with_hint(ctx, id, None)
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         // Note that we're not adding the variable to its scope for lookups.
         // This is done in the `visit_statement_for_locals_labels_and_in_sync`
         // method.
         let stmt = &ctx.heap[id];
         let expr_id = stmt.initial_expr;
         assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::Memory(id);

src/protocol/tests/mod.rs

➞

Show inline comments

@@ @@ -9,19 +9,19 @@ @@
+ *
  * If any of these tests fail, and you think they're not needed anymore, feel
  * free to cast them out into oblivion, where dead code goes to die.
  */
 mod utils;
 mod parser_after_tokenizing;
 mod parser_binding;
 mod parser_imports;
 mod parser_inference;
 mod parser_literals;
 mod parser_monomorphs;
 mod parser_types;
 mod parser_type_declaration;
 mod parser_type_layout;
 mod parser_validation;
 mod eval_binding;
 mod eval_calls;
 mod eval_casting;
 mod eval_operators;
 mod eval_silly;

src/protocol/tests/parser_after_tokenizing.rs

➞

Show inline comments

deleted file

src/protocol/tests/parser_inference.rs

➞

Show inline comments

@@ @@ -465,12 +465,62 @@ fn test_failed_polymorph_inference() { @@
             return 0;
+        }
         ",
     );
+}
 #[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_explicit_polymorph_argument() {
     // Failed because array was put at same type depth as u32. So interpreted
     // as a function with two polymorphic arguments
     Tester::new_single_source_expect_ok("explicit with array", "

src/protocol/tests/parser_type_declaration.rs

➞

Show inline comments

@@ new file 100644 @@
 use super::*;
 #[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"); });
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/parser_type_layout.rs

➞

Show inline comments

file renamed from src/protocol/tests/parser_types.rs to src/protocol/tests/parser_type_layout.rs

src/protocol/tests/parser_validation.rs

➞

Show inline comments

 /// parser_validation.rs
 ///
 /// Simple tests for the validation phase
 use super::*;
 #[test]
 fn test_correct_struct_instance() {
     Tester::new_single_source_expect_ok(
         "single field",
+        "
         struct Foo { s32 a }
@@ @@ -632,6 +634,112 @@ fn test_incorrect_select_statement() { @@
             channel<u32> tx -> rx;
             u32 a = 0; // this one will be shadowed
             sync select { auto a = get(rx) -> {} }
         }"
     );
+}
 #[test]
 fn test_incorrect_goto_statement() {
     Tester::new_single_source_expect_err(
         "goto missing var in same scope",
         "func f() -> u32 {
             goto exit;
             auto v = 5;
             exit: return 0;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "exit;").assert_msg_has(0, "skips over a variable")
         .assert_occurs_at(1, "exit:").assert_msg_has(1, "jumps to this label")
         .assert_occurs_at(2, "v = 5").assert_msg_has(2, "skips over this variable");
     });
     Tester::new_single_source_expect_err(
         "goto missing var in outer scope",
         "func f() -> u32 {
             if (true) {
                 goto exit;
+            }
             auto v = 0;
             exit: return 1;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "exit;").assert_msg_has(0, "skips over a variable")
         .assert_occurs_at(1, "exit:").assert_msg_has(1, "jumps to this label")
         .assert_occurs_at(2, "v = 0").assert_msg_has(2, "skips over this variable");
     });
     Tester::new_single_source_expect_err(
         "goto jumping into scope",
         "func f() -> u32 {
             goto nested;
+            {
                 nested: return 0;
+            }
             return 1;
         }"
     ).error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "nested;")
         .assert_msg_has(0, "could not find this label");
     });
     Tester::new_single_source_expect_err(
         "goto jumping outside sync",
         "primitive f() {
             sync { goto exit; }
             exit: u32 v = 0;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "goto exit;").assert_msg_has(0, "not escape the surrounding sync")
         .assert_occurs_at(1, "exit: u32 v").assert_msg_has(1, "target of the goto")
         .assert_occurs_at(2, "sync {").assert_msg_has(2, "jump past this");
     })
+}
 #[test]
 fn test_incorrect_while_statement() {
     // Just testing the error cases caught at compile-time. Other ones need
     // evaluation testing
     Tester::new_single_source_expect_err(
         "break wrong earlier loop",
         "func f() -> u32 {
             target: while (true) {}
             while (true) { break target; }
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "target; }").assert_msg_has(0, "not nested under the target")
         .assert_occurs_at(1, "target: while").assert_msg_has(1, "is found here");
     });
     Tester::new_single_source_expect_err(
         "break wrong later loop",
         "func f() -> u32 {
             while (true) { break target; }
             target: while (true) {}
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "target; }").assert_msg_has(0, "not nested under the target")
         .assert_occurs_at(1, "target: while").assert_msg_has(1, "is found here");
     });
     Tester::new_single_source_expect_err(
         "break outside of sync",
         "primitive f() {
             outer: while (true) { //mark
                 sync while(true) { break outer; }
+            }
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "break outer;").assert_msg_has(0, "may not escape the surrounding")
         .assert_occurs_at(1, "while (true) { //mark").assert_msg_has(1, "escapes out of this loop")
         .assert_occurs_at(2, "sync while").assert_msg_has(2, "escape this synchronous block");
     });
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)