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

Changeset - aa1fd869a173

Parent rev.

Child rev.

[Not reviewed]

0 2 0

mh - 3 years ago 2022-02-15 10:16:16
contact@maxhenger.nl

Refactored type table

2 files changed with 81 insertions and 21 deletions:

src/protocol/parser/type_table.rs

src/protocol/tests/parser_monomorphs.rs

0 comments (0 inline, 0 general)

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -398,19 +398,27 @@ impl MonoType { @@
+}
 /// Special structure that acts like the lookup key for `ConcreteType` instances
 /// that have already been added to the type table before.
 #[derive(Clone)]
 struct MonoSearchKey {
     parts: Vec<(bool, ConcreteTypePart)>,
     // Uses bitflags to denote when parts between search keys should match and
     // whether they should be checked. Needs to have a system like this to
     // accommodate tuples.
     parts: Vec<(u8, ConcreteTypePart)>,
     change_bit: u8,
+}
 impl MonoSearchKey {
     const KEY_IN_USE: u8 = 0x01;
     const KEY_CHANGE_BIT: u8 = 0x02;
     fn with_capacity(capacity: usize) -> Self {
         return MonoSearchKey{
             parts: Vec::with_capacity(capacity),
             change_bit: 0,
         };
+    }
     /// Sets the search key based on a single concrete type and its polymorphic
     /// variables.
     fn set(&mut self, concrete_type_parts: &[ConcreteTypePart], poly_var_in_use: &[PolymorphicVariable]) {
@@ @@ -428,72 +436,124 @@ impl MonoSearchKey { @@
     /// Starts setting the search key based on an initial top-level type,
     /// programmer must call `push_subtype` the appropriate number of times
     /// after calling this function
     fn set_top_type(&mut self, type_part: ConcreteTypePart) {
         self.parts.clear();
         self.parts.push((true, type_part));
         self.parts.push((self.change_bit | Self::KEY_IN_USE, type_part));
         self.change_bit ^= Self::KEY_CHANGE_BIT;
+    }
     fn push_subtype(&mut self, concrete_type: &[ConcreteTypePart], in_use: bool) {
         let flag = self.change_bit | (if in_use { Self::KEY_IN_USE } else { 0 });
         for part in concrete_type {
-            self.parts.push((in_use, *part));
+            self.parts.push((flag, *part));
+        }
         self.change_bit ^= Self::KEY_CHANGE_BIT;
+    }
     fn push_subtree(&mut self, concrete_type: &[ConcreteTypePart], poly_var_in_use: &[PolymorphicVariable]) {
         self.parts.push((true, concrete_type[0]));
         self.parts.push((self.change_bit | Self::KEY_IN_USE, concrete_type[0]));
         self.change_bit ^= Self::KEY_CHANGE_BIT;
         let mut poly_var_index = 0;
         for subtype in ConcreteTypeIter::new(concrete_type, 0) {
             let in_use = poly_var_in_use[poly_var_index].is_in_use;
             poly_var_index += 1;
             self.push_subtype(subtype, in_use);
+        }
         debug_assert_eq!(poly_var_index, poly_var_in_use.len());
+    }
     // Utilities for hashing and comparison
     fn find_end_index(&self, start_index: usize) -> usize {
         // Check if we're already at the end
         let mut index = start_index;
         if index >= self.parts.len() {
             return index;
+        }
         // Iterate until bit flips, or until at end
         let expected_bit = self.parts[index].0 & Self::KEY_CHANGE_BIT;
         index += 1;
         while index < self.parts.len() {
             let current_bit = self.parts[index].0 & Self::KEY_CHANGE_BIT;
             if current_bit != expected_bit {
                 return index;
+            }
             index += 1;
+        }
         return self.parts.len();
+    }
+}
 impl Hash for MonoSearchKey {
     fn hash<H: Hasher>(&self, state: &mut H) {
         for index in 0..self.parts.len() {
             let is_in_use = self.parts[index].0;
             if is_in_use {
                 let type_part = &self.parts[index].1;
                 type_part.hash(state);
             let (flags, part) = self.parts[index];
             if flags & Self::KEY_IN_USE != 0 {
                 part.hash(state);
+            }
+        }
+    }
+}
 impl PartialEq for MonoSearchKey {
     fn eq(&self, other: &Self) -> bool {
         let mut self_index = 0;
         let mut other_index = 0;
         while self_index < self.parts.len() && other_index < other.parts.len() {
             let (self_in_use, self_part) = &self.parts[self_index];
             let (other_in_use, other_part) = &other.parts[self_index];
             let self_end_index = ConcreteType::type_parts_subtree_end_idx(&self.parts, )
             // Retrieve part and flags
             let (self_bits, _) = self.parts[self_index];
             let (other_bits, _) = other.parts[other_index];
             let self_in_use = (self_bits & Self::KEY_IN_USE) != 0;
             let other_in_use = (other_bits & Self::KEY_IN_USE) != 0;
             // Determine ending indices
             let self_end_index = self.find_end_index(self_index);
             let other_end_index = other.find_end_index(other_index);
             if self_in_use == other_in_use {
                 if *self_in_use {
                     // Both are in use, so both should be equal
                     if self_part != other_part {
                 if self_in_use {
                     // Both are in use, so both parts should be equal
                     let delta_self = self_end_index - self_index;
                     let delta_other = other_end_index - other_index;
                     if delta_self != delta_other {
                         // Both in use, but not of equal length, so the types
                         // cannot match
                         return false;
+                    }
                     self_index
                 } // else: both not in use, so we don't care
                     for _ in 0..delta_self {
                         let (_, self_part) = self.parts[self_index];
                         let (_, other_part) = self.parts[other_index];
                         if self_part != other_part {
                             return false;
+                        }
                         self_index += 1;
                         other_index += 1;
+                    }
                 } else {
                     // Both not in use, so skip associated parts
                     self_index = self_end_index;
                     other_index = other_end_index;
+                }
             } else {
                 // No agreement on importance of parts. This is practically
                 // impossible
                 unreachable!();
+            }
             self_index = ConcreteType::type_parts_subtree_end_idx();
             other_index += 1;
+        }
         // Everything matched, so if we're at the end of both arrays then we're
         // certain that the two keys are equal.
         return self_index == self.parts.len() && other_index == other.parts.len();
+    }

src/protocol/tests/parser_monomorphs.rs

➞

Show inline comments

@@ @@ -68,14 +68,14 @@ fn test_enum_monomorphs() { @@
             auto c = Answer<s32>::Yes;
             auto d = Answer<Answer<Answer<s64>>>::No;
             return 0;
+        }
+        "
     ).for_enum("Answer", |e| { e
         .assert_has_monomorph("2Answer<s8>")
         .assert_num_monomorphs(1);
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Answer<s8>");
     });
+}
 #[test]
 fn test_union_monomorphs() {
     Tester::new_single_source_expect_ok(

0 comments (0 inline, 0 general)