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

Changeset - c79f28079eb9

Parent rev.

Child rev.

[Not reviewed]

feat-bytecode

0 3 0

MH - 4 years ago 2021-07-27 13:37:59
contact@maxhenger.nl

make all tests work again

3 files changed with 13 insertions and 10 deletions:

src/protocol/parser/pass_typing.rs

src/protocol/parser/type_table.rs

src/protocol/tests/eval_silly.rs

0 comments (0 inline, 0 general)

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -3513,49 +3513,52 @@ impl PassTyping { @@
                         has_markers = true;
                         has_inferred = true;
                         infer_type.push(ITP::Marker(poly_arg_idx));
                         infer_type.push(ITP::Unknown)
+                    }
                 },
                 PTV::Definition(definition_id, num_embedded) => {
                     infer_type.push(ITP::Instance(*definition_id, *num_embedded));
+                }
+            }
+        }
         InferenceType::new(has_markers, !has_inferred, infer_type)
+    }
     /// Determines the inference type from an already concrete type. Applies the
     /// various type "hacks" inside the type inferencer.
     fn determine_inference_type_from_concrete_type(parser_type: &mut Vec<InferenceTypePart>, concrete_type: &[ConcreteTypePart]) {
         use InferenceTypePart as ITP;
         use ConcreteTypePart as CTP;
         for concrete_part in concrete_type {
             match concrete_part {
                 CTP::Void => parser_type.push(ITP::Void),
                 CTP::Message => parser_type.push(ITP::Message),
                 CTP::Message => {
                     parser_type.push(ITP::Message);
                     parser_type.push(ITP::UInt8)
                 },
                 CTP::Bool => parser_type.push(ITP::Bool),
                 CTP::UInt8 => parser_type.push(ITP::UInt8),
                 CTP::UInt16 => parser_type.push(ITP::UInt16),
                 CTP::UInt32 => parser_type.push(ITP::UInt32),
                 CTP::UInt64 => parser_type.push(ITP::UInt64),
                 CTP::SInt8 => parser_type.push(ITP::SInt8),
                 CTP::SInt16 => parser_type.push(ITP::SInt16),
                 CTP::SInt32 => parser_type.push(ITP::SInt32),
                 CTP::SInt64 => parser_type.push(ITP::SInt64),
                 CTP::Character => parser_type.push(ITP::Character),
                 CTP::String => {
                     parser_type.push(ITP::String);
                     parser_type.push(ITP::Character)
                 },
                 CTP::Array => parser_type.push(ITP::Array),
                 CTP::Slice => parser_type.push(ITP::Slice),
                 CTP::Input => parser_type.push(ITP::Input),
                 CTP::Output => parser_type.push(ITP::Output),
                 CTP::Instance(id, num) => parser_type.push(ITP::Instance(*id, *num)),
                 CTP::Function(_, _) => unreachable!("function type during concrete to inference type conversion"),
                 CTP::Component(_, _) => unreachable!("component type during concrete to inference type conversion"),
+            }
+        }
+    }

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -906,49 +906,49 @@ impl TypeTable { @@
+        }
         for argument in &arguments {
             Self::mark_used_polymorphic_variables(&mut poly_vars, &argument.parser_type);
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Function(FunctionType{
                 return_types: definition.return_types.clone(),
                 arguments,
                 monomorphs: Vec::new(),
             }),
             poly_vars,
             is_polymorph
         });
         return Ok(());
+    }
     /// Builds base component type.
     fn build_base_component_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(self.lookup.contains_key(&definition_id), "base component already built");
+        debug_assert!(!self.lookup.contains_key(&definition_id), "base component already built");
         let definition = &ctx.heap[definition_id].as_component();
         let root_id = definition.defined_in;
         // Check the argument types
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for parameter_id in &definition.parameters {
             let parameter = &ctx.heap[*parameter_id];
             Self::check_member_parser_type(
                 modules, ctx, root_id, &parameter.parser_type, false
             )?;
             arguments.push(FunctionArgument{
                 identifier: parameter.identifier.clone(),
                 parser_type: parameter.parser_type.clone(),
             });
+        }
         // Check conflict of identifiers
         Self::check_identifier_collision(
             modules, root_id, &arguments, |arg| &arg.identifier, "connector argument"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;

src/protocol/tests/eval_silly.rs

➞

Show inline comments

@@ @@ -114,56 +114,56 @@ fn test_slicing_magic() { @@
             auto result_u08 = slicing_magic(created_u08, 3, 2, 1, 2);
             auto result_u16 = slicing_magic(created_u16, 3, 2, 1, 2);
             auto result_u32 = slicing_magic(created_u32, 3, 2, 1, 2);
             auto result_u64 = slicing_magic(created_u64, 3, 2, 1, 2);
             auto result_s08 = slicing_magic(create_holder<s8> (0, 5, 2, 8), 3, 2, 1, 2);
             auto result_s16 = slicing_magic(create_holder<s16>(0, 5, 2, 8), 3, 2, 1, 2);
             auto result_s32 = slicing_magic(create_holder<s32>(0, 5, 2, 8), 3, 2, 1, 2);
             auto result_s64 = slicing_magic(create_holder<s64>(0, 5, 2, 8), 3, 2, 1, 2);
             return
                 result_u08[0] + result_u08[1] == 6 &&
                 result_u16[0] + result_u16[1] == 6 &&
                 result_u32[0] + result_u32[1] == 6 &&
                 result_u64[0] + result_u64[1] == 6 &&
                 result_s08[0] + result_s08[1] == 6 &&
                 result_s16[0] + result_s16[1] == 6 &&
                 result_s32[0] + result_s32[1] == 6 &&
                 result_s64[0] + result_s64[1] == 6;
+        }
     ").for_function("foo", |f| {
         f.call_ok(Some(Value::Bool(true)));
     }).for_struct("Holder", |s| { s
         .assert_num_monomorphs(8)
         .assert_has_monomorph("u8")
         .assert_has_monomorph("u16")
         .assert_has_monomorph("u32")
         .assert_has_monomorph("u64")
         .assert_has_monomorph("s8")
         .assert_has_monomorph("s16")
         .assert_has_monomorph("s32")
         .assert_has_monomorph("s64");
         .assert_has_monomorph("Holder<u8>")
         .assert_has_monomorph("Holder<u16>")
         .assert_has_monomorph("Holder<u32>")
         .assert_has_monomorph("Holder<u64>")
         .assert_has_monomorph("Holder<s8>")
         .assert_has_monomorph("Holder<s16>")
         .assert_has_monomorph("Holder<s32>")
         .assert_has_monomorph("Holder<s64>");
     });
+}
 #[test]
 fn test_struct_fields() {
     Tester::new_single_source_expect_ok("struct field access", "
         struct Nester<T> {
             T v,
+        }
         func make<T>(T inner) -> Nester<T> {
             return Nester{ v: inner };
+        }
         func modify<T>(Nester<T> outer, T inner) -> Nester<T> {
             outer.v = inner;
             return outer;
+        }
         func foo() -> bool {
             // Single depth modification
             auto original1 = make<u32>(5);
             auto modified1 = modify(original1, 2);
             auto success1 = original1.v == 5 && modified1.v == 2;

0 comments (0 inline, 0 general)