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 80 insertions and 20 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

@@ @@ -20,858 +20,918 @@ @@
  * because their stack-size is now based on pointers. Hence breaking the type
  * loop required for computing the byte size of types.
+ *
  * The reason for these type shenanigans is because PDL is a value-based
  * language, but we would still like to be able to express recursively defined
  * types like trees or linked lists. Hence we need to insert pointers somewhere
  * to break these cycles.
+ *
  * We will insert these pointers into the variants of unions. However note that
  * we can only compute the stack size of a union until we've looked at *all*
  * variants. Hence we perform an initial pass where we detect type loops, a
  * second pass where we compute the stack sizes of everything, and a third pass
  * where we actually compute the size of the heap allocations for unions.
+ *
  * As a final bit of global documentation: non-polymorphic types will always
  * have one "monomorph" entry. This contains the non-polymorphic type's memory
  * layout.
  */
 use std::fmt::{Formatter, Result as FmtResult};
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use crate::protocol::ast::*;
 use crate::protocol::parser::symbol_table::SymbolScope;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::*;
 //------------------------------------------------------------------------------
 // Defined Types
 //------------------------------------------------------------------------------
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum TypeClass {
     Enum,
     Union,
     Struct,
     Function,
     Component
+}
 impl TypeClass {
     pub(crate) fn display_name(&self) -> &'static str {
         match self {
             TypeClass::Enum => "enum",
             TypeClass::Union => "union",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
     pub(crate) fn is_data_type(&self) -> bool {
         match self {
             TypeClass::Enum | TypeClass::Union | TypeClass::Struct => true,
             TypeClass::Function | TypeClass::Component => false,
+        }
+    }
+}
 impl std::fmt::Display for TypeClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         write!(f, "{}", self.display_name())
+    }
+}
 /// Struct wrapping around a potentially polymorphic type. If the type does not
 /// have any polymorphic arguments then it will not have any monomorphs and
 /// `is_polymorph` will be set to `false`. A type with polymorphic arguments
 /// only has `is_polymorph` set to `true` if the polymorphic arguments actually
 /// appear in the types associated types (function return argument, struct
 /// field, enum variant, etc.). Otherwise the polymorphic argument is just a
 /// marker and does not influence the bytesize of the type.
 pub struct DefinedType {
     pub(crate) ast_root: RootId,
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
     pub(crate) poly_vars: Vec<PolymorphicVariable>,
     pub(crate) is_polymorph: bool,
+}
 pub enum DefinedTypeVariant {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
+}
 impl DefinedTypeVariant {
     pub(crate) fn type_class(&self) -> TypeClass {
         match self {
             DefinedTypeVariant::Enum(_) => TypeClass::Enum,
             DefinedTypeVariant::Union(_) => TypeClass::Union,
             DefinedTypeVariant::Struct(_) => TypeClass::Struct,
             DefinedTypeVariant::Function(_) => TypeClass::Function,
             DefinedTypeVariant::Component(_) => TypeClass::Component
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructType {
         match self {
             DefinedTypeVariant::Struct(v) => v,
             _ => unreachable!("Cannot convert {} to struct variant", self.type_class())
+        }
+    }
     pub(crate) fn as_enum(&self) -> &EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
             _ => unreachable!("Cannot convert {} to enum variant", self.type_class())
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionType {
         match self {
             DefinedTypeVariant::Union(v) => v,
             _ => unreachable!("Cannot convert {} to union variant", self.type_class())
+        }
+    }
+}
 pub struct PolymorphicVariable {
     identifier: Identifier,
     is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
 /// compiler-defined, or a mix of the two. If a user assigns the same enum
 /// value multiple times, we assume the user is an expert and we consider both
 /// variants to be equal to one another.
 pub struct EnumType {
     pub variants: Vec<EnumVariant>,
     pub minimum_tag_value: i64,
     pub maximum_tag_value: i64,
     pub tag_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     pub identifier: Identifier,
     pub value: i64,
+}
 /// `UnionType` is the algebraic datatype (or sum type, or discriminated union).
 /// A value is an element of the union, identified by its tag, and may contain
 /// a single subtype.
 /// For potentially infinite types (i.e. a tree, or a linked list) only unions
 /// can break the infinite cycle. So when we lay out these unions in memory we
 /// will reserve enough space on the stack for all union variants that do not
 /// cause "type loops" (i.e. a union `A` with a variant containing a struct
 /// `B`). And we will reserve enough space on the heap (and store a pointer in
 /// the union) for all variants which do cause type loops (i.e. a union `A`
 /// with a variant to a struct `B` that contains the union `A` again).
 pub struct UnionType {
     pub variants: Vec<UnionVariant>,
     pub tag_type: ConcreteType,
     pub tag_size: usize,
+}
 pub struct UnionVariant {
     pub identifier: Identifier,
     pub embedded: Vec<ParserType>, // zero-length does not have embedded values
     pub tag_value: i64,
+}
 /// `StructType` is a generic C-like struct type (or record type, or product
 /// type) type.
 pub struct StructType {
     pub fields: Vec<StructField>,
+}
 pub struct StructField {
     pub identifier: Identifier,
     pub parser_type: ParserType,
+}
 /// `FunctionType` is what you expect it to be: a particular function's
 /// signature.
 pub struct FunctionType {
     pub return_type: ParserType,
     pub arguments: Vec<FunctionArgument>,
+}
 pub struct ComponentType {
     pub variant: ComponentVariant,
     pub arguments: Vec<FunctionArgument>,
+}
 pub struct FunctionArgument {
     identifier: Identifier,
     parser_type: ParserType,
+}
 /// Represents the data associated with a single expression after type inference
 /// for a monomorph (or just the normal expression types, if dealing with a
 /// non-polymorphic function/component).
 pub struct MonomorphExpression {
     // The output type of the expression. Note that for a function it is not the
     // function's signature but its return type
     pub(crate) expr_type: ConcreteType,
     // Has multiple meanings: the field index for select expressions, the
     // monomorph index for polymorphic function calls or literals. Negative
     // values are never used, but used to catch programming errors.
     pub(crate) field_or_monomorph_idx: i32,
     pub(crate) type_id: TypeId,
+}
 //------------------------------------------------------------------------------
 // Type monomorph storage
 //------------------------------------------------------------------------------
 pub(crate) enum MonoTypeVariant {
     Enum, // no extra data
     Struct(StructMonomorph),
     Union(UnionMonomorph),
     Procedure(ProcedureMonomorph), // functions, components
     Tuple(TupleMonomorph),
+}
 impl MonoTypeVariant {
     fn as_struct_mut(&mut self) -> &mut StructMonomorph {
         match self {
             MonoTypeVariant::Struct(v) => v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionMonomorph {
         match self {
             MonoTypeVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_union_mut(&mut self) -> &mut UnionMonomorph {
         match self {
             MonoTypeVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {
         match self {
             MonoTypeVariant::Tuple(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_procedure(&self) -> &ProcedureMonomorph {
         match self {
             MonoTypeVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_procedure_mut(&mut self) -> &mut ProcedureMonomorph {
         match self {
             MonoTypeVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
+}
 /// Struct monomorph
 pub struct StructMonomorph {
     pub fields: Vec<StructMonomorphField>,
+}
 pub struct StructMonomorphField {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Union monomorph
 pub struct UnionMonomorph {
     pub variants: Vec<UnionMonomorphVariant>,
     pub tag_size: usize, // copied from `UnionType` upon monomorph construction.
     // note that the stack size is in the `TypeMonomorph` struct. This size and
     // alignment will include the size of the union tag.
     //
     // heap_size contains the allocated size of the union in the case it
     // is used to break a type loop. If it is 0, then it doesn't require
     // allocation and lives entirely on the stack.
     pub heap_size: usize,
     pub heap_alignment: usize,
+}
 pub struct UnionMonomorphVariant {
     pub lives_on_heap: bool,
     pub embedded: Vec<UnionMonomorphEmbedded>,
+}
 pub struct UnionMonomorphEmbedded {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     // Note that the meaning of the offset (and alignment) depend on whether or
     // not the variant lives on the stack/heap. If it lives on the stack then
     // they refer to the offset from the start of the union value (so the first
     // embedded type lives at a non-zero offset, because the union tag sits in
     // the front). If it lives on the heap then it refers to the offset from the
     // allocated memory region (so the first embedded type lives at a 0 offset).
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Procedure (functions and components of all possible types) monomorph. Also
 /// stores the expression type data from the typechecking/inferencing pass.
 pub struct ProcedureMonomorph {
     // Expression data for one particular monomorph
     pub arg_types: Vec<ConcreteType>,
     pub expr_data: Vec<MonomorphExpression>,
+}
 /// Tuple monomorph. Again a kind of exception because one cannot define a named
 /// tuple type containing explicit polymorphic variables. But again: we need to
 /// store size/offset/alignment information, so we do it here.
 pub struct TupleMonomorph {
     pub members: Vec<TupleMonomorphMember>
+}
 pub struct TupleMonomorphMember {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Generic unique type ID. Every monomorphed type and every non-polymorphic
 /// type will have one of these associated with it.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct TypeId(i64);
 impl TypeId {
     pub(crate) fn new_invalid() -> Self {
         return Self(-1);
+    }
+}
 /// A monomorphed type (or non-polymorphic type's) memory layout and information
 /// regarding associated types (like a struct's field type).
 pub struct MonoType {
     pub type_id: TypeId,
     pub concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub(crate) variant: MonoTypeVariant
+}
 impl MonoType {
     #[inline]
     fn new_empty(type_id: TypeId, concrete_type: ConcreteType, variant: MonoTypeVariant) -> Self {
         return Self {
             type_id, concrete_type,
             size: 0,
             alignment: 0,
             variant,
+        }
+    }
     /// Little internal helper function as a reminder: if alignment is 0, then
     /// the size/alignment are not actually computed yet!
     #[inline]
     fn get_size_alignment(&self) -> Option<(usize, usize)> {
         if self.alignment == 0 {
             return None
         } else {
             return Some((self.size, self.alignment));
+        }
+    }
+}
 /// 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]) {
         self.set_top_type(concrete_type_parts[0]);
         let mut poly_var_index = 0;
         for subtype in ConcreteTypeIter::new(concrete_type_parts, 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());
+    }
     /// 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_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;
+                    }
                     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
                 } // else: both not in use, so we don't care
                         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();
+    }
+}
 impl Eq for MonoSearchKey{}
 //------------------------------------------------------------------------------
 // Type table
 //------------------------------------------------------------------------------
 // Programmer note: keep this struct free of dynamically allocated memory
 #[derive(Clone)]
 struct TypeLoopBreadcrumb {
     type_id: TypeId,
     next_member: u32,
     next_embedded: u32, // for unions, the index into the variant's embedded types
+}
 // Programmer note: keep this struct free of dynamically allocated memory
 #[derive(Clone)]
 struct MemoryBreadcrumb {
     type_id: TypeId,
     next_member: u32,
     next_embedded: u32,
     first_size_alignment_idx: u32,
+}
 #[derive(Debug, PartialEq, Eq)]
 enum TypeLoopResult {
     TypeExists,
     PushBreadcrumb(DefinitionId, ConcreteType),
     TypeLoop(usize), // index into vec of breadcrumbs at which the type matched
+}
 enum MemoryLayoutResult {
     TypeExists(usize, usize), // (size, alignment)
     PushBreadcrumb(MemoryBreadcrumb),
+}
 // TODO: @Optimize, initial memory-unoptimized implementation
 struct TypeLoopEntry {
     type_id: TypeId,
     is_union: bool,
+}
 struct TypeLoop {
     members: Vec<TypeLoopEntry>,
+}
 type DefinitionMap = HashMap<DefinitionId, DefinedType>;
 type MonoTypeMap = HashMap<MonoSearchKey, TypeId>;
 type MonoTypeArray = Vec<MonoType>;
 pub struct TypeTable {
     // Lookup from AST DefinitionId to a defined type. Also lookups for
     // concrete type to monomorphs
     pub(crate) definition_lookup: DefinitionMap,
     mono_type_lookup: MonoTypeMap,
     pub(crate) mono_types: MonoTypeArray,
     mono_search_key: MonoSearchKey,
     // Breadcrumbs left behind while trying to find type loops. Also used to
     // determine sizes of types when all type loops are detected.
     type_loop_breadcrumbs: Vec<TypeLoopBreadcrumb>,
     type_loops: Vec<TypeLoop>,
     // Stores all encountered types during type loop detection. Used afterwards
     // to iterate over all types in order to compute size/alignment.
     encountered_types: Vec<TypeLoopEntry>,
     // Breadcrumbs and temporary storage during memory layout computation.
     memory_layout_breadcrumbs: Vec<MemoryBreadcrumb>,
     size_alignment_stack: Vec<(usize, usize)>,
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types.
     pub(crate) fn new() -> Self {
         Self{
             definition_lookup: HashMap::with_capacity(128),
             mono_type_lookup: HashMap::with_capacity(128),
             mono_types: Vec::with_capacity(128),
             mono_search_key: MonoSearchKey::with_capacity(32),
             type_loop_breadcrumbs: Vec::with_capacity(32),
             type_loops: Vec::with_capacity(8),
             encountered_types: Vec::with_capacity(32),
             memory_layout_breadcrumbs: Vec::with_capacity(32),
             size_alignment_stack: Vec::with_capacity(64),
+        }
+    }
     /// Iterates over all defined types (polymorphic and non-polymorphic) and
     /// add their types in two passes. In the first pass we will just add the
     /// base types (we will not consider monomorphs, and we will not compute
     /// byte sizes). In the second pass we will compute byte sizes of
     /// non-polymorphic types, and potentially the monomorphs that are embedded
     /// in those types.
     pub(crate) fn build_base_types(&mut self, modules: &mut [Module], ctx: &mut PassCtx) -> Result<(), ParseError> {
         // Make sure we're allowed to cast root_id to index into ctx.modules
         debug_assert!(modules.iter().all(|m| m.phase >= ModuleCompilationPhase::DefinitionsParsed));
         debug_assert!(self.definition_lookup.is_empty());
         dbg_code!({
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(index, module.root_id.index as usize);
+            }
         });
         // Use context to guess hashmap size of the base types
         let reserve_size = ctx.heap.definitions.len();
         self.definition_lookup.reserve(reserve_size);
         // Resolve all base types
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let definition = &ctx.heap[definition_id];
             match definition {
                 Definition::Enum(_) => self.build_base_enum_definition(modules, ctx, definition_id)?,
                 Definition::Union(_) => self.build_base_union_definition(modules, ctx, definition_id)?,
                 Definition::Struct(_) => self.build_base_struct_definition(modules, ctx, definition_id)?,
                 Definition::Function(_) => self.build_base_function_definition(modules, ctx, definition_id)?,
                 Definition::Component(_) => self.build_base_component_definition(modules, ctx, definition_id)?,
+            }
+        }
         debug_assert_eq!(self.definition_lookup.len(), reserve_size, "mismatch in reserved size of type table");
         for module in modules.iter_mut() {
             module.phase = ModuleCompilationPhase::TypesAddedToTable;
+        }
         // Go through all types again, lay out all types that are not
         // polymorphic. This might cause us to lay out monomorphized polymorphs
         // if these were member types of non-polymorphic types.
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let poly_type = self.definition_lookup.get(&definition_id).unwrap();
             if !poly_type.definition.type_class().is_data_type() || !poly_type.poly_vars.is_empty() {
                 continue;
+            }
             // If here then the type is a data type without polymorphic
             // variables, but we might have instantiated it already, so:
             let concrete_parts = [ConcreteTypePart::Instance(definition_id, 0)];
             self.mono_search_key.set(&concrete_parts, &[]);
             let type_id = self.mono_type_lookup.get(&self.mono_search_key);
             if type_id.is_none() {
                 self.detect_and_resolve_type_loops_for(
                     modules, ctx.heap,
                     ConcreteType{
                         parts: vec![ConcreteTypePart::Instance(definition_id, 0)]
                     },
                 )?;
                 self.lay_out_memory_for_encountered_types(ctx.arch);
+            }
+        }
         Ok(())
+    }
     /// Retrieves base definition from type table. We must be able to retrieve
     /// it as we resolve all base types upon type table construction (for now).
     /// However, in the future we might do on-demand type resolving, so return
     /// an option anyway
     #[inline]
     pub(crate) fn get_base_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {
         self.definition_lookup.get(&definition_id)
+    }
     /// Returns the index into the monomorph type array if the procedure type
     /// already has a (reserved) monomorph.
     #[inline]
     pub(crate) fn get_procedure_monomorph_type_id(&self, definition_id: &DefinitionId, type_parts: &[ConcreteTypePart]) -> Option<TypeId> {
         // Cannot use internal search key due to mutability issues. But this
         // method should end up being deprecated at some point anyway.
         let base_type = self.definition_lookup.get(definition_id).unwrap();
         let mut search_key = MonoSearchKey::with_capacity(type_parts.len());
         search_key.set(type_parts, &base_type.poly_vars);
         return self.mono_type_lookup.get(&search_key).copied();
+    }
     #[inline]
     pub(crate) fn get_monomorph(&self, type_id: TypeId) -> &MonoType {
         return &self.mono_types[type_id.0 as usize];
+    }
     /// Returns a mutable reference to a procedure's monomorph expression data.
     /// Used by typechecker to fill in previously reserved type information
     #[inline]
     pub(crate) fn get_procedure_monomorph_mut(&mut self, type_id: TypeId) -> &mut ProcedureMonomorph {
         let mono_type = &mut self.mono_types[type_id.0 as usize];
         return mono_type.variant.as_procedure_mut();
+    }
     #[inline]
     pub(crate) fn get_procedure_monomorph(&self, type_id: TypeId) -> &ProcedureMonomorph {
         let mono_type = &self.mono_types[type_id.0 as usize];
         return mono_type.variant.as_procedure();
+    }
     /// Reserves space for a monomorph of a polymorphic procedure. The index
     /// will point into a (reserved) slot of the array of expression types. The
     /// monomorph may NOT exist yet (because the reservation implies that we're
     /// going to be performing typechecking on it, and we don't want to
     /// check the same monomorph twice)
     pub(crate) fn reserve_procedure_monomorph_type_id(&mut self, definition_id: &DefinitionId, concrete_type: ConcreteType) -> TypeId {
         let type_id = TypeId(self.mono_types.len() as i64);
         let base_type = self.definition_lookup.get_mut(definition_id).unwrap();
         self.mono_search_key.set(&concrete_type.parts, &base_type.poly_vars);
         debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));
         self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);
         self.mono_types.push(MonoType::new_empty(type_id, concrete_type, MonoTypeVariant::Procedure(ProcedureMonomorph{
             arg_types: Vec::new(),
             expr_data: Vec::new(),
         })));
         return type_id;
+    }
     /// Adds a monomorphed type to the type table. If it already exists then the
     /// previous entry will be used.
     pub(crate) fn add_monomorphed_type(
         &mut self, modules: &[Module], heap: &Heap, arch: &TargetArch,
         definition_id: DefinitionId, concrete_type: ConcreteType
     ) -> Result<TypeId, ParseError> {
         debug_assert_eq!(definition_id, get_concrete_type_definition(&concrete_type.parts).unwrap());
         // Check if the concrete type was already added
         let definition = self.definition_lookup.get(&definition_id).unwrap();
         let poly_var_in_use = &definition.poly_vars;
         self.mono_search_key.set(&concrete_type.parts, poly_var_in_use.as_slice());
         if let Some(type_id) = self.mono_type_lookup.get(&self.mono_search_key) {
             return Ok(*type_id);
+        }
         // Concrete type needs to be added
         self.detect_and_resolve_type_loops_for(modules, heap, concrete_type)?;
         let type_id = self.encountered_types[0].type_id;
         self.lay_out_memory_for_encountered_types(arch);
         return Ok(type_id);
+    }
     //--------------------------------------------------------------------------
     // Building base types
     //--------------------------------------------------------------------------
     /// Builds the base type for an enum. Will not compute byte sizes
     fn build_base_enum_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.definition_lookup.contains_key(&definition_id), "base enum already built");
         let definition = ctx.heap[definition_id].as_enum();
         let root_id = definition.defined_in;
         // Determine enum variants
         let mut enum_value = -1;
         let mut variants = Vec::with_capacity(definition.variants.len());
         for variant in &definition.variants {
             if enum_value == i64::MAX {
                 let source = &modules[definition.defined_in.index as usize].source;
                 return Err(ParseError::new_error_str_at_span(
                     source, variant.identifier.span,
                     "this enum variant has an integer value that is too large"
                 ));
+            }
             enum_value += 1;
             if let EnumVariantValue::Integer(explicit_value) = variant.value {
                 enum_value = explicit_value;
+            }
             variants.push(EnumVariant{
                 identifier: variant.identifier.clone(),
                 value: enum_value,
             });
+        }
         // Determine tag size
         let mut min_enum_value = 0;
         let mut max_enum_value = 0;
         if !variants.is_empty() {
             min_enum_value = variants[0].value;
             max_enum_value = variants[0].value;
             for variant in variants.iter().skip(1) {
                 min_enum_value = min_enum_value.min(variant.value);
                 max_enum_value = max_enum_value.max(variant.value);
+            }
+        }
         let (tag_type, size_and_alignment) = Self::variant_tag_type_from_values(min_enum_value, max_enum_value);
         // Enum names and polymorphic args do not conflict
         Self::check_identifier_collision(
             modules, root_id, &variants, |variant| &variant.identifier, "enum variant"
         )?;
         // Polymorphic arguments cannot appear as embedded types, because
         // they can only consist of integer variants.
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         let poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         self.definition_lookup.insert(definition_id, DefinedType {
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Enum(EnumType{
                 variants,
                 minimum_tag_value: min_enum_value,
                 maximum_tag_value: max_enum_value,
                 tag_type,
                 size: size_and_alignment,
                 alignment: size_and_alignment
             }),
             poly_vars,
             is_polymorph: false,
         });
         return Ok(());
+    }
     /// Builds the base type for a union. Will compute byte sizes.
     fn build_base_union_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.definition_lookup.contains_key(&definition_id), "base union already built");
         let definition = ctx.heap[definition_id].as_union();
         let root_id = definition.defined_in;
         // Check all variants and their embedded types
         let mut variants = Vec::with_capacity(definition.variants.len());
         let mut tag_counter = 0;
         for variant in &definition.variants {
             for embedded in &variant.value {
                 Self::check_member_parser_type(
                     modules, ctx, root_id, embedded, false
                 )?;
+            }
             variants.push(UnionVariant{
                 identifier: variant.identifier.clone(),
                 embedded: variant.value.clone(),
                 tag_value: tag_counter,
             });
             tag_counter += 1;
+        }
         let mut max_tag_value = 0;
         if tag_counter != 0 {
             max_tag_value = tag_counter - 1
+        }
         let (tag_type, tag_size) = Self::variant_tag_type_from_values(0, max_tag_value);
         // Make sure there are no conflicts in identifiers
         Self::check_identifier_collision(
             modules, root_id, &variants, |variant| &variant.identifier, "union variant"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct internal representation of union
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         for variant in &definition.variants {
             for embedded in &variant.value {
                 Self::mark_used_polymorphic_variables(&mut poly_vars, embedded);
+            }
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.definition_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Union(UnionType{ variants, tag_type, tag_size }),
             poly_vars,
             is_polymorph
         });
         return Ok(());
+    }
     /// Builds base struct type. Will not compute byte sizes.
     fn build_base_struct_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.definition_lookup.contains_key(&definition_id), "base struct already built");

src/protocol/tests/parser_monomorphs.rs

➞

Show inline comments

 /// parser_monomorphs.rs
 ///
 /// Simple tests to make sure that all of the appropriate monomorphs are
 /// instantiated
 use super::*;
 #[test]
 fn test_struct_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
         "struct Integer{ s32 field }"
     ).for_struct("Integer", |s| { s
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Integer");
     });
     Tester::new_single_source_expect_ok(
         "single polymorph",
+        "
         struct Number<T>{ T number }
         func instantiator() -> s32 {
             auto a = Number<s8>{ number: 0 };
             auto b = Number<s8>{ number: 1 };
             auto c = Number<s32>{ number: 2 };
             auto d = Number<s64>{ number: 3 };
             auto e = Number<Number<s16>>{ number: Number{ number: 4 }};
             return 0;
+        }
+        "
     ).for_struct("Number", |s| { s
         .assert_has_monomorph("Number<s8>")
         .assert_has_monomorph("Number<s16>")
         .assert_has_monomorph("Number<s32>")
         .assert_has_monomorph("Number<s64>")
         .assert_has_monomorph("Number<Number<s16>>")
         .assert_num_monomorphs(5);
     }).for_function("instantiator", |f| { f
         .for_variable("a", |v| {v.assert_concrete_type("Number<s8>");} )
         .for_variable("e", |v| {v.assert_concrete_type("Number<Number<s16>>");} );
     });
+}
 #[test]
 fn test_enum_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
+        "
         enum Answer{ Yes, No }
         func do_it() -> s32 { auto a = Answer::Yes; return 0; }
+        "
     ).for_enum("Answer", |e| { e
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Answer")
         .assert_size_alignment("Answer", 1, 1);
     });
     // Note for reader: because the enum doesn't actually use the polymorphic
     // variable, we expect to have 1 monomorph: the type only has to be laid
     // out once.
     Tester::new_single_source_expect_ok(
         "single polymorph",
+        "
         enum Answer<T> { Yes, No }
         func instantiator() -> s32 {
             auto a = Answer<s8>::Yes;
             auto b = Answer<s8>::No;
             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(
         "no polymorph",
+        "
         union Trinary { Undefined, Value(bool) }
         func do_it() -> s32 { auto a = Trinary::Value(true); return 0; }
+        "
     ).for_union("Trinary", |e| { e
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Trinary");
     });
     Tester::new_single_source_expect_ok(
         "polymorphs",
+        "
         union Result<T, E>{ Ok(T), Err(E) }
         func instantiator() -> s32 {
             s16 a_s16 = 5;
             auto a = Result<s8, bool>::Ok(0);
             auto b = Result<bool, s8>::Ok(true);
             auto c = Result<Result<s8, s32>, Result<s16, s64>>::Err(Result::Ok(5));
             auto d = Result<Result<s8, s32>, auto>::Err(Result<auto, s64>::Ok(a_s16));
             return 0;
+        }
+        "
     ).for_union("Result", |e| { e
         .assert_num_monomorphs(5)
         .assert_has_monomorph("Result<s8,bool>")
         .assert_has_monomorph("Result<bool,s8>")
         .assert_has_monomorph("Result<Result<s8,s32>,Result<s16,s64>>")
         .assert_has_monomorph("Result<s8,s32>")
         .assert_has_monomorph("Result<s16,s64>");
     }).for_function("instantiator", |f| { f
         .for_variable("d", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("Result<Result<s8,s32>,Result<s16,s64>>");
         });
     });
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)