CSY/reowolf Changeset - 7f9b23076d66 · Centrum Wiskunde & Informatica (CWI)

Changeset - 7f9b23076d66

Parent rev.

Child rev.

[Not reviewed]

0 6 0

mh - 4 years ago 2021-12-15 16:56:29
contact@maxhenger.nl

Add some tests for tuple member access

6 files changed with 118 insertions and 4 deletions:

src/protocol/eval/executor.rs

src/protocol/eval/store.rs

src/protocol/parser/pass_typing.rs

src/protocol/tests/eval_operators.rs

src/protocol/tests/parser_inference.rs

src/protocol/tests/parser_validation.rs

0 comments (0 inline, 0 general)

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -479,30 +479,36 @@ impl Prompt { @@
                             self.store.drop_value(subject.get_heap_pos());
                         },
                         Expression::Select(expr) => {
                             let subject= cur_frame.expr_values.pop_back().unwrap();
                             let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_idx);
                             let field_idx = mono_data.expr_data[expr.unique_id_in_definition as usize].field_or_monomorph_idx as u32;
                             // Note: same as above: clone if value lives on expr stack, simply
                             // refer to it if it already lives on the stack/heap.
                             let (deallocate_heap_pos, value_to_push) = match subject {
                                 Value::Ref(value_ref) => {
                                     let subject = self.store.read_ref(value_ref);
                                     let subject_heap_pos = subject.as_struct();
                                     let subject_heap_pos = match expr.kind {
                                         SelectKind::StructField(_) => subject.as_struct(),
                                         SelectKind::TupleMember(_) => subject.as_tuple(),
                                     };
                                     (None, Value::Ref(ValueId::Heap(subject_heap_pos, field_idx)))
                                 },
                                 _ => {
                                     let subject_heap_pos = subject.as_struct();
                                     let subject_heap_pos = match expr.kind {
                                         SelectKind::StructField(_) => subject.as_struct(),
                                         SelectKind::TupleMember(_) => subject.as_tuple(),
                                     };
                                     let subject_indexed = Value::Ref(ValueId::Heap(subject_heap_pos, field_idx));
                                     (Some(subject_heap_pos), self.store.clone_value(subject_indexed))
                                 },
                             };
                             cur_frame.expr_values.push_back(value_to_push);
                             self.store.drop_value(deallocate_heap_pos);
                         },
                         Expression::Literal(expr) => {
                             let value = match &expr.value {
                                 Literal::Null => Value::Null,
                                 Literal::True => Value::Bool(true),

src/protocol/eval/store.rs

➞

Show inline comments

@@ @@ -180,24 +180,25 @@ impl Store { @@
         let num_values = self.heap_regions[source_heap_pos].values.len();
         for value_idx in 0..num_values {
             let cloned = self.clone_value(self.heap_regions[source_heap_pos].values[value_idx].clone());
             self.heap_regions[target_heap_pos_usize].values.push(cloned);
+        }
         match value {
             Value::Message(_) => Value::Message(target_heap_pos),
             Value::String(_) => Value::String(target_heap_pos),
             Value::Array(_) => Value::Array(target_heap_pos),
             Value::Union(tag, _) => Value::Union(tag, target_heap_pos),
             Value::Struct(_) => Value::Struct(target_heap_pos),
             Value::Tuple(_) => Value::Tuple(target_heap_pos),
             _ => unreachable!("performed clone_value on heap, but {:?} is not a heap value", value),
+        }
+    }
     pub(crate) fn drop_value(&mut self, value: Option<HeapPos>) {
         if let Some(heap_pos) = value {
             self.drop_heap_pos(heap_pos);
+        }
+    }
     pub(crate) fn drop_heap_pos(&mut self, heap_pos: HeapPos) {
         let num_values = self.heap_regions[heap_pos as usize].values.len();

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -3292,25 +3292,28 @@ impl PassTyping { @@
                 // Must be a component call, which we assign a "Void" return
                 // type
                 InferenceType::new(false, true, vec![ITP::Void]),
         };
         let infer_expr = &mut self.expr_types[expr.get_unique_id_in_definition() as usize];
         let needs_extra_data = match expr {
             Expression::Call(_) => true,
             Expression::Literal(expr) => match expr.value {
                 Literal::Enum(_) | Literal::Union(_) | Literal::Struct(_) => true,
                 _ => false,
             },
             Expression::Select(_) => true,
             Expression::Select(expr) => match expr.kind {
                 SelectKind::StructField(_) => true,
                 SelectKind::TupleMember(_) => false,
             },
             _ => false,
         };
         if infer_expr.expr_id.is_invalid() {
             // Nothing is set yet
             infer_expr.expr_type = inference_type;
             infer_expr.expr_id = expr_id;
             if needs_extra_data {
                 let extra_idx = self.extra_data.len() as i32;
                 self.extra_data.push(ExtraData::default());
                 infer_expr.extra_data_idx = extra_idx;
+            }

src/protocol/tests/eval_operators.rs

➞

Show inline comments

@@ @@ -138,25 +138,25 @@ fn test_binary_integer_operators() { @@
     );
     perform_test(
         "divide", "u8",
         "auto a = 32 / 2; return a / 2 / 2;", Value::UInt8(4)
     );
     perform_test(
         "remainder", "u16",
         "auto a = 29; return a % 3;", Value::UInt16(2)
     );
+}
 #[test]
-fn test_tuple_operators() {
+fn test_tuple_comparison_operators() {
     Tester::new_single_source_expect_ok("tuple equality", "
     func test_func() -> bool {
         auto a1 = (8, 16, 32);
         (u8, u16, u32) a2 = (8, 16, 32);
         auto b1 = ();
         () b2 = ();
         return a1 == a2 && a2 == (8, 16, 32) && b1 == b2 && b2 == ();
+    }
     ").for_function("test_func", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
@@ @@ -169,24 +169,58 @@ fn test_tuple_operators() { @@
         auto b = ();
         return
             !(a != a_same) &&
             a != a_diff &&
             a != (8, 16, 320) &&
             !(b != ());
+    }
     ").for_function("test_func", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
+}
 #[test]
 fn test_tuple_select_operator() {
     Tester::new_single_source_expect_ok("tuple member assignment", "
     func test() -> bool {
         auto tuple = (0, 1, 0, 1);
         tuple.0 = cast<u8>(1);
         tuple.1 = cast<u16>(2);
         tuple.2 = cast<u32>(3);
         tuple.3 = cast<u64>(4);
         return cast(tuple.0) + cast(tuple.1) + tuple.2 + cast(tuple.3) == 10;
+    }
     ").for_function("test", |f| { f
         .for_variable("tuple", |v| { v.assert_concrete_type("(u8,u16,u32,u64)"); })
         .call_ok(Some(Value::Bool(true)));
     });
     Tester::new_single_source_expect_ok("tuple polymorph member access", "
     func sum_variant_a<A,B,C,D>((A,B,C,D) v) -> C {
         return cast(v.0) + cast(v.1) + v.2 + cast(v.3);
+    }
     func sum_variant_b<A,B,C,D>((A,B,C,D) i) -> B {
         (A,B,C,D) c = (0,0,0,0);
         c.0 = i.0; c.1 = i.1; c.2 = i.2; c.3 = i.3;
         return cast(c.0) + c.1 + cast(c.2) + cast(c.3);
+    }
     func test() -> bool {
         (u8,u16,u32,u64) tuple = (1, 2, 3, 4);
         return sum_variant_a(tuple) == 10 && sum_variant_b(tuple) == 10;
+    }
     ").for_function("test", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
+}
 #[test]
 fn test_string_operators() {
     Tester::new_single_source_expect_ok("string concatenation", "
 func create_concatenated(string left, string right) -> string {
     return left @ \", but also \" @ right;
+}
 func perform_concatenate(string left, string right) -> string {
     left @= \", but also \";
     left @= right;
     return left;
+}
 func foo() -> bool {

src/protocol/tests/parser_inference.rs

➞

Show inline comments

@@ @@ -113,25 +113,63 @@ fn test_binary_expr_inference() { @@
             auto r = b + l;
             return 0;
         }"
     ).error(|e| { e
         .assert_ctx_has(0, "b + l")
         .assert_msg_has(0, "cannot apply")
         .assert_occurs_at(0, "+")
         .assert_msg_has(1, "has type 's8'")
         .assert_msg_has(2, "has type 's64'");
     });
+}
 #[test]
 fn test_tuple_inference() {
     Tester::new_single_source_expect_ok(
         "from tuple to variable",
+        "
         func test() -> u32 {
             (u8,u16,u32,u64) tuple = (1, 2, 3, 4);
             auto a = tuple.0;
             auto b = tuple.1;
             auto c = tuple.2;
             auto d = tuple.3;
             return cast(a) + cast(b) + c + cast(d);
+        }
+        "
     ).for_function("test", |f| { f
         .for_variable("a", |v| { v.assert_concrete_type("u8"); })
         .for_variable("b", |v| { v.assert_concrete_type("u16"); })
         .for_variable("c", |v| { v.assert_concrete_type("u32"); })
         .for_variable("d", |v| { v.assert_concrete_type("u64"); })
         .call_ok(Some(Value::UInt32(10)));
     });
     Tester::new_single_source_expect_ok(
         "from variable to tuple",
+        "
         func test() -> u32 {
             auto tuple = (1, 2, 3, 4);
             u8  a = tuple.0;
             u16 b = tuple.1;
             u32 c = tuple.2;
             u64 d = tuple.3;
             return cast(a) + cast(b) + c + cast(d);
+        }
+        "
     ).for_function("test", |f| { f
         .for_variable("tuple", |v| { v.assert_concrete_type("(u8,u16,u32,u64)"); })
         .call_ok(Some(Value::UInt32(10)));
     });
+}
 #[test]
 fn test_struct_inference() {
     Tester::new_single_source_expect_ok(
         "by function calls",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         func construct<T1, T2>(T1 first, T2 second) -> Pair<T1, T2> {
             return Pair{ first: first, second: second };
+        }
         func fix_t1<T2>(Pair<s8, T2> arg) -> s32 { return 0; }
         func fix_t2<T1>(Pair<T1, s32> arg) -> s32 { return 0; }

src/protocol/tests/parser_validation.rs

➞

Show inline comments

@@ @@ -467,24 +467,56 @@ fn test_incorrect_tuple_polymorph_args() { @@
         func f() -> u32 {
             auto a = O<(<u32>)>::None;
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "expected typename")
         .assert_occurs_at(0, "<u32");
     });
+}
 #[test]
 fn test_incorrect_tuple_member_access() {
     Tester::new_single_source_expect_err(
         "zero-tuple",
         "func foo() -> () { () a = (); auto b = a.0; return a; }"
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "out of bounds")
         .assert_occurs_at(0, "a.0");
     });
     // Make the type checker do some shenanigans before we can decide the tuple
     // type.
     Tester::new_single_source_expect_err(
         "sized tuple",
+        "
         func determinator<A,B>((A,B,A) v) -> B { return v.1; }
         func tester() -> u64 {
             auto v = (0,1,2);
             u32 a_u32 = 5;
             v.2 = a_u32;
             v.8 = 5;
             return determinator(v);
+        }
+        "
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "out of bounds")
         .assert_occurs_at(0, "v.8");
     });
+}
 #[test]
 fn test_polymorph_array_types() {
     Tester::new_single_source_expect_ok(
         "array of polymorph in struct",
+        "
         struct Foo<T> { T[] hello }
         struct Bar { Foo<u32>[] world }
+        "
     ).for_struct("Bar", |s| { s
         .for_field("world", |f| { f.assert_parser_type("Foo<u32>[]"); });
     });

0 comments (0 inline, 0 general)