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

@@ @@ -443,102 +443,108 @@ impl Prompt { @@
                                 Value::String(v) => (ValueKind::String, *v),
                                 Value::Message(v) => (ValueKind::Message, *v),
                                 _ => unreachable!()
                             };
                             if array_inclusive_index_is_invalid(&self.store, array_heap_pos, from_index) {
                                 return Err(construct_array_error(self, modules, heap, expr.from_index, array_heap_pos, from_index));
+                            }
                             if array_exclusive_index_is_invalid(&self.store, array_heap_pos, to_index) {
                                 return Err(construct_array_error(self, modules, heap, expr.to_index, array_heap_pos, to_index));
+                            }
                             // Again: would love to push directly, but rust...
                             let new_heap_pos = self.store.alloc_heap();
                             debug_assert!(self.store.heap_regions[new_heap_pos as usize].values.is_empty());
                             if to_index > from_index {
                                 let from_index = from_index as usize;
                                 let to_index = to_index as usize;
                                 let mut values = Vec::with_capacity(to_index - from_index);
                                 for idx in from_index..to_index {
                                     let value = self.store.heap_regions[array_heap_pos as usize].values[idx].clone();
                                     values.push(self.store.clone_value(value));
+                                }
                                 self.store.heap_regions[new_heap_pos as usize].values = values;
                             } // else: empty range
                             cur_frame.expr_values.push_back(match value_kind {
                                 ValueKind::Array => Value::Array(new_heap_pos),
                                 ValueKind::String => Value::String(new_heap_pos),
                                 ValueKind::Message => Value::Message(new_heap_pos),
                             });
                             // Dropping the original subject, because we don't
                             // want to drop something on the stack
                             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),
                                 Literal::False => Value::Bool(false),
                                 Literal::Character(lit_value) => Value::Char(*lit_value),
                                 Literal::String(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     let value = lit_value.as_str();
                                     debug_assert!(values.is_empty());
                                     values.reserve(value.len());
                                     for character in value.as_bytes() {
                                         debug_assert!(character.is_ascii());
                                         values.push(Value::Char(*character as char));
+                                    }
                                     Value::String(heap_pos)
+                                }
                                 Literal::Integer(lit_value) => {
                                     use ConcreteTypePart as CTP;
                                     let def_types = types.get_procedure_monomorph(cur_frame.monomorph_idx);
                                     let concrete_type = &def_types.expr_data[expr.unique_id_in_definition as usize].expr_type;
                                     debug_assert_eq!(concrete_type.parts.len(), 1);
                                     match concrete_type.parts[0] {
                                         CTP::UInt8  => Value::UInt8(lit_value.unsigned_value as u8),
                                         CTP::UInt16 => Value::UInt16(lit_value.unsigned_value as u16),
                                         CTP::UInt32 => Value::UInt32(lit_value.unsigned_value as u32),
                                         CTP::UInt64 => Value::UInt64(lit_value.unsigned_value as u64),
                                         CTP::SInt8  => Value::SInt8(lit_value.unsigned_value as i8),
                                         CTP::SInt16 => Value::SInt16(lit_value.unsigned_value as i16),
                                         CTP::SInt32 => Value::SInt32(lit_value.unsigned_value as i32),
                                         CTP::SInt64 => Value::SInt64(lit_value.unsigned_value as i64),
                                         _ => unreachable!("got concrete type {:?} for integer literal at expr {:?}", concrete_type, expr_id),
+                                    }
+                                }
                                 Literal::Struct(lit_value) => {
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.fields.len()
                                     );

src/protocol/eval/store.rs

➞

Show inline comments

@@ @@ -144,81 +144,82 @@ impl Store { @@
             ValueId::Heap(heap_pos, region_idx) => {
                 let heap_pos = heap_pos as usize;
                 let region_idx = region_idx as usize;
                 self.drop_value(self.heap_regions[heap_pos].values[region_idx].get_heap_pos());
                 self.heap_regions[heap_pos].values[region_idx] = value
+            }
+        }
+    }
     /// This thing takes a cloned Value, because of borrowing issues (which is
     /// either a direct value, or might contain an index to a heap value), but
     /// should be treated by the programmer as a reference (i.e. don't call
     /// `drop_value(thing)` after calling `clone_value(thing.clone())`.
     pub(crate) fn clone_value(&mut self, value: Value) -> Value {
         // Quickly check if the value is not on the heap
         let source_heap_pos = value.get_heap_pos();
         if source_heap_pos.is_none() {
             // We can do a trivial copy, unless we're dealing with a value
             // reference
             return match value {
                 Value::Ref(ValueId::Stack(stack_pos)) => {
                     let abs_stack_pos = self.cur_stack_boundary + stack_pos as usize + 1;
                     self.clone_value(self.stack[abs_stack_pos].clone())
                 },
                 Value::Ref(ValueId::Heap(heap_pos, val_idx)) => {
                     self.clone_value(self.heap_regions[heap_pos as usize].values[val_idx as usize].clone())
                 },
                 _ => value,
             };
+        }
         // Value does live on heap, copy it
         let source_heap_pos = source_heap_pos.unwrap() as usize;
         let target_heap_pos = self.alloc_heap();
         let target_heap_pos_usize = target_heap_pos as usize;
         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();
         for value_idx in 0..num_values {
             if let Some(other_heap_pos) = self.heap_regions[heap_pos as usize].values[value_idx].get_heap_pos() {
                 self.drop_heap_pos(other_heap_pos);
+            }
+        }
         self.heap_regions[heap_pos as usize].values.clear();
         self.free_regions.push_back(heap_pos);
+    }
     pub(crate) fn alloc_heap(&mut self) -> HeapPos {
         if self.free_regions.is_empty() {
             let idx = self.heap_regions.len() as HeapPos;
             self.heap_regions.push(HeapAllocation{ values: Vec::new() });
             return idx;
         } else {
             let idx = self.free_regions.pop_back().unwrap();
             return idx;
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -3256,97 +3256,100 @@ impl PassTyping { @@
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::ExpressionStmt(_) =>
                 // Determined during type inference
                 InferenceType::new(false, false, vec![ITP::Unknown]),
             EP::Expression(parent_id, idx_in_parent) => {
                 // If we are the test expression of a conditional expression,
                 // then we must resolve to a boolean
                 let is_conditional = if let Expression::Conditional(_) = &ctx.heap[*parent_id] {
                     true
                 } else {
                     false
                 };
                 if is_conditional && *idx_in_parent == 0 {
                     InferenceType::new(false, true, vec![ITP::Bool])
                 } else {
                     InferenceType::new(false, false, vec![ITP::Unknown])
+                }
             },
             EP::If(_) | EP::While(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) =>
                 // Must match the return type of the function
                 if let DefinitionType::Function(func_id) = self.definition_type {
                     debug_assert_eq!(ctx.heap[func_id].return_types.len(), 1);
                     let returned = &ctx.heap[func_id].return_types[0];
                     self.determine_inference_type_from_parser_type_elements(&returned.elements, true)
                 } else {
                     // Cannot happen: definition always set upon body traversal
                     // and "return" calls in components are illegal.
                     unreachable!();
                 },
             EP::New(_) =>
                 // 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;
+            }
         } else {
             // We already have an entry
             debug_assert!(false, "does this ever happen?");
             if let SingleInferenceResult::Incompatible = InferenceType::infer_subtree_for_single_type(
                 &mut infer_expr.expr_type, 0, &inference_type.parts, 0, false
             ) {
                 return Err(self.construct_expr_type_error(ctx, expr_id, expr_id));
+            }
             debug_assert!((infer_expr.extra_data_idx != -1) == needs_extra_data);
+        }
         Ok(())
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) {
         // Note: the polymorph variables may be partially specified and may
         // contain references to the wrapping definition's (i.e. the proctype
         // we are currently visiting) polymorphic arguments.
         //
         // The arguments of the call may refer to polymorphic variables in the
         // definition of the function we're calling, not of the wrapping
         // definition. We insert markers in these inferred types to be able to
         // map them back and forth to the polymorphic arguments of the function
         // we are calling.
         let call = &ctx.heap[call_id];
         let extra_data_idx = self.expr_types[call.unique_id_in_definition as usize].extra_data_idx; // TODO: @Temp
         debug_assert!(extra_data_idx != -1, "insert initial call polymorph data, no preallocated ExtraData");
         // Handle the polymorphic arguments (if there are any)
         let num_poly_args = call.parser_type.elements[0].variant.num_embedded();
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in call.parser_type.iter_embedded(0) {
             poly_args.push(self.determine_inference_type_from_parser_type_elements(embedded_elements, true));

src/protocol/tests/eval_operators.rs

➞

Show inline comments

@@ @@ -102,106 +102,140 @@ fn test_binary_integer_operators() { @@
             .for_function("foo", move |f| {
                 f.call_ok(Some(expected_value));
             });
+    }
     perform_test(
         "bitwise_or", "u16",
         "auto a = 3; return a | 4;", Value::UInt16(7)
     );
     perform_test(
         "bitwise_xor", "u16",
         "auto a = 3; return a ^ 7;", Value::UInt16(4)
     );
     perform_test(
         "bitwise and", "u16",
         "auto a = 0b110011; return a & 0b011110;", Value::UInt16(0b010010)
     );
     perform_test(
         "shift left", "u16",
         "auto a = 0x0F; return a << 4;", Value::UInt16(0xF0)
     );
     perform_test(
         "shift right", "u64",
         "auto a = 0xF0; return a >> 4;", Value::UInt64(0x0F)
     );
     perform_test(
         "add", "u32",
         "auto a = 5; return a + 5;", Value::UInt32(10)
     );
     perform_test(
         "subtract", "u32",
         "auto a = 3; return a - 3;", Value::UInt32(0)
     );
     perform_test(
         "multiply", "u8",
         "auto a = 2 * 2; return a * 2 * 2;", Value::UInt8(16)
     );
     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)));
     });
     Tester::new_single_source_expect_ok("tuple inequality", "
     func test_func() -> bool {
         auto a = (8, 16, 32);
         (u8, u16, u32) a_same = (8, 16, 32);
         auto a_diff = (0b111, 0b1111, 0b11111);
         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 {
     auto left = \"Darth Vader\";
     auto right = \"Anakin Skywalker\";
     auto res1 = create_concatenated(left, right);
     auto res2 = perform_concatenate(left, right);
     auto expected = \"Darth Vader, but also Anakin Skywalker\";
     return
         res1 == expected &&
         res2 == \"Darth Vader, but also Anakin Skywalker\" &&
         res1 != \"This kind of thing\" && res2 != \"Another likewise kind of thing\";
+}
     ").for_function("foo", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/parser_inference.rs

➞

Show inline comments

@@ @@ -77,97 +77,135 @@ fn test_binary_expr_inference() { @@
             s16 s0 = 0;
             s16 s1 = 1;
             s32 i0 = 0;
             s32 i1 = 1;
             s64 l0 = 0;
             s64 l1 = 1;
             auto b = b0 + b1;
             auto s = s0 + s1;
             auto i = i0 + i1;
             auto l = l0 + l1;
             return i;
         }"
     ).for_function("call", |f| { f
         .for_expression_by_source(
             "b0 + b1", "+",
             |e| { e.assert_concrete_type("s8"); }
+        )
         .for_expression_by_source(
             "s0 + s1", "+",
             |e| { e.assert_concrete_type("s16"); }
+        )
         .for_expression_by_source(
             "i0 + i1", "+",
             |e| { e.assert_concrete_type("s32"); }
+        )
         .for_expression_by_source(
             "l0 + l1", "+",
             |e| { e.assert_concrete_type("s64"); }
         );
     });
     Tester::new_single_source_expect_err(
         "incompatible types",
         "func call() -> s32 {
             s8 b = 0;
             s64 l = 1;
             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; }
         func test() -> s32 {
             auto first = 0;
             auto second = 1;
             auto pair = construct(first, second);
             fix_t1(pair);
             fix_t2(pair);
             return 0;
+        }
+        "
     ).for_function("test", |f| { f
         .for_variable("first", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("s8");
         })
         .for_variable("second", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("s32");
         })
         .for_variable("pair", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("Pair<s8,s32>");
         });
     });
     Tester::new_single_source_expect_ok(
         "by field access",
+        "
         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 test() -> s32 {
             auto first = 0;
             auto second = 1;
             auto pair = construct(first, second);
             s8 assign_first = 0;

src/protocol/tests/parser_validation.rs

➞

Show inline comments

@@ @@ -431,69 +431,101 @@ fn test_correct_tuple_polymorph_args() { @@
             auto b = Option<(u32, u64)>::None;
             auto c = Option<(Option<(u8, s8)>, Option<(s8, u8)>)>::None;
             return 0;
+        }
+        "
     ).for_union("Option", |u| { u
         .assert_has_monomorph("Option<()>")
         .assert_has_monomorph("Option<(u32,u64)>")
         .assert_has_monomorph("Option<(Option<(u8,s8)>,Option<(s8,u8)>)>")
         .assert_size_alignment("Option<()>", 1, 1, 0, 0)
         .assert_size_alignment("Option<(u32,u64)>", 24, 8, 0, 0) // (u32, u64) becomes size 16, alignment 8. Hence union tag is aligned to 8
         .assert_size_alignment("Option<(Option<(u8,s8)>,Option<(s8,u8)>)>", 7, 1, 0, 0); // inner unions are size 3, alignment 1. Two of those with a tag is size 7
     });
+}
 #[test]
 fn test_incorrect_tuple_polymorph_args() {
     // Do some mismatching brackets. I don't know what else to test
     Tester::new_single_source_expect_err(
         "mismatch angle bracket",
+        "
         union Option<T>{ Some(T), None }
         func f() -> u32 {
             auto a = Option<(u32>)::None;
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_msg_has(0, "closing '>'").assert_occurs_at(0, ">)::None")
         .assert_msg_has(1, "match this '('").assert_occurs_at(1, "(u32>");
     });
     Tester::new_single_source_expect_err(
         "wrongly placed angle",
+        "
         union O<T>{ S(T), N }
         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>[]"); });
     });
     Tester::new_single_source_expect_ok(
         "array of port in struct",
+        "
         struct Bar { in<u32>[] inputs }
+        "
     ).for_struct("Bar", |s| { s
         .for_field("inputs", |f| { f.assert_parser_type("in<u32>[]"); });
     });
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)