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

Changeset - a67d4fde9cb5

Parent rev.

Child rev.

[Not reviewed]

0 3 0

mh - 3 years ago 2022-02-23 14:08:11
contact@maxhenger.nl

Finish refactoring type table

3 files changed with 157 insertions and 102 deletions:

src/collections/scoped_buffer.rs

src/protocol/parser/pass_typing.rs

154

src/protocol/tests/parser_validation.rs

0 comments (0 inline, 0 general)

src/collections/scoped_buffer.rs

➞

Show inline comments

@@ @@ -95,98 +95,98 @@ impl<T: Sized> ScopedSection<T> { @@
         self.check_length();
         let vec = unsafe{&mut *self.inner};
         hide!(self.cur_size = self.start_size);
         vec.truncate(self.start_size as usize);
+    }
     #[inline]
     #[allow(unused_mut)] // used in debug mode
     pub(crate) fn into_vec(mut self) -> Vec<T> {
         self.check_length();
         let vec = unsafe{&mut *self.inner};
         hide!(self.cur_size = self.start_size);
         let section = Vec::from_iter(vec.drain(self.start_size as usize..));
         section
+    }
     #[inline]
     pub(crate) fn check_length(&self) {
         hide!({
             let vec = unsafe{&*self.inner};
             debug_assert_eq!(
                 vec.len(), self.cur_size as usize,
                 "incorrect use of ScopedSection: underlying storage vector has changed size"
+            )
         })
+    }
+}
 impl<T: Sized + PartialEq> ScopedSection<T> {
     #[inline]
     pub(crate) fn push_unique(&mut self, value: T) {
         self.check_length();
         let vec = unsafe{&mut *self.inner};
         for item in &vec[self.start_size as usize..] {
             if *item == value {
                 // item already exists
                 return;
+            }
+        }
         vec.push(value);
         hide!(self.cur_size += 1);
+    }
     #[inline]
     pub(crate) fn contains(&self, value: &T) -> bool {
         self.check_length();
         let vec = unsafe{&*self.inner};
         for index in self.start_size..vec.len() {
             if vec[index] == value {
         for index in self.start_size as usize..vec.len() {
             if &vec[index] == value {
                 return true;
+            }
+        }
         return false;
+    }
+}
 impl<T: Copy> ScopedSection<T> {
     pub(crate) fn iter_copied(&self) -> ScopedIter<T> {
         return ScopedIter{
             inner: self.inner,
             cur_index: self.start_size,
             last_index: unsafe{ (*self.inner).len() as u32 },
+        }
+    }
+}
 impl<T> std::ops::Index<usize> for ScopedSection<T> {
     type Output = T;
     fn index(&self, index: usize) -> &Self::Output {
         let vec = unsafe{&*self.inner};
         return &vec[self.start_size as usize + index]
+    }
+}
 impl<T> std::ops::IndexMut<usize> for ScopedSection<T> {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
         let vec = unsafe{&mut *self.inner};
         return &mut vec[self.start_size as usize + index]
+    }
+}
 #[cfg(debug_assertions)]
 impl<T: Sized> Drop for ScopedSection<T> {
     fn drop(&mut self) {
         let vec = unsafe{&mut *self.inner};
         hide!(debug_assert_eq!(vec.len(), self.cur_size as usize));
         vec.truncate(self.start_size as usize);
+    }
+}
 /// Small utility for iterating over a section of the buffer. Same conditions as
 /// the buffer apply: each time we retrieve an element the buffer must have the
 /// same size as the moment of creation.
 pub(crate) struct ScopedIter<T: Copy> {
     inner: *mut Vec<T>,

src/protocol/parser/pass_typing.rs

➞

Show inline comments

 /// pass_typing
 ///
 /// Performs type inference and type checking. Type inference is implemented by
 /// applying constraints on (sub)trees of types. During this process the
 /// resolver takes the `ParserType` structs (the representation of the types
 /// written by the programmer), converts them to `InferenceType` structs (the
 /// temporary data structure used during type inference) and attempts to arrive
 /// at `ConcreteType` structs (the representation of a fully checked and
 /// validated type).
 ///
 /// The resolver will visit every statement and expression relevant to the
 /// procedure and insert and determine its initial type based on context (e.g. a
 /// return statement's expression must match the function's return type, an
 /// if statement's test expression must evaluate to a boolean). When all are
 /// visited we attempt to make progress in evaluating the types. Whenever a type
 /// is progressed we queue the related expressions for further type progression.
 /// Once no more expressions are in the queue the algorithm is finished. At this
 /// point either all types are inferred (or can be trivially implicitly
 /// determined), or we have incomplete types. In the latter case we return an
 /// error.
 ///
 /// TODO: Needs a thorough rewrite:
 ///  0. polymorph_progress is intentionally broken at the moment. Make it work
 ///     again and use a normal VecSomething.
 ///  1. The foundation for doing all of the work with predetermined indices
 ///     instead of with HashMaps is there, but it is not really used because of
 ///     time constraints. When time is available, rewrite the system such that
 ///     AST IDs are not needed, and only indices into arrays are used.
 ///  2. Remove the `msg` type?
 ///  3. Disallow certain types in certain operations (e.g. `Void`).
 macro_rules! debug_log_enabled {
     () => { false };
+}
 macro_rules! debug_log {
     ($format:literal) => {
         enabled_debug_print!(false, "types", $format);
     };
     ($format:literal, $($args:expr),*) => {
         enabled_debug_print!(false, "types", $format, $($args),*);
     };
+}
 use std::collections::{HashMap, HashSet};
 use crate::collections::{ScopedBuffer, ScopedSection, DequeSet};
 use crate::protocol::ast::*;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::ModuleCompilationPhase;
 use crate::protocol::parser::type_table::*;
 use crate::protocol::parser::token_parsing::*;
 use super::visitor::{
     BUFFER_INIT_CAP_LARGE,
     BUFFER_INIT_CAP_SMALL,
     Ctx,
 };
 // -----------------------------------------------------------------------------
 // Inference type
 // -----------------------------------------------------------------------------
 const VOID_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Void ];
 const MESSAGE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Message, InferenceTypePart::UInt8 ];
 const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];
 const CHARACTER_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Character ];
 const STRING_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::String, InferenceTypePart::Character ];
 const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];
 const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];
 const ARRAY_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Array, InferenceTypePart::Unknown ];
 const SLICE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Slice, InferenceTypePart::Unknown ];
 const ARRAYLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::ArrayLike, InferenceTypePart::Unknown ];
 /// TODO: @performance Turn into PartialOrd+Ord to simplify checks
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub(crate) enum InferenceTypePart {
     // When we infer types of AST elements that support polymorphic arguments,
     // then we might have the case that multiple embedded types depend on the
     // polymorphic type (e.g. func bla(T a, T[] b) -> T[][]). If we can infer
     // the type in one place (e.g. argument a), then we may propagate this
     // information to other types (e.g. argument b and the return type). For
     // this reason we place markers in the `InferenceType` instances such that
     // we know which part of the type was originally a polymorphic argument.
     Marker(u32),
     // Completely unknown type, needs to be inferred
     Unknown,
     // Partially known type, may be inferred to to be the appropriate related
     // type.
     // IndexLike,      // index into array/slice
     NumberLike,     // any kind of integer/float
     IntegerLike,    // any kind of integer
     ArrayLike,      // array or slice. Note that this must have a subtype
     PortLike,       // input or output port
     // Special types that cannot be instantiated by the user
@@ @@ -764,178 +762,180 @@ impl<'a> Iterator for InferenceTypeMarkerIter<'a> { @@
                 // Modify internal index, then return items
                 self.idx = end_idx;
                 return Some((marker, &self.parts[start_idx..end_idx]));
+            }
             self.idx += 1;
+        }
         None
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum DualInferenceResult {
     Neither,        // neither argument is clarified
     First,          // first argument is clarified using the second one
     Second,         // second argument is clarified using the first one
     Both,           // both arguments are clarified
     Incompatible,   // types are incompatible: programmer error
+}
 impl DualInferenceResult {
     fn modified_lhs(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_rhs(&self) -> bool {
         match self {
             DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum SingleInferenceResult {
     Unmodified,
     Modified,
     Incompatible
+}
 // -----------------------------------------------------------------------------
 // PassTyping - Public Interface
 // -----------------------------------------------------------------------------
 type InferNodeIndex = usize;
-type PolyDataIndex = usize;
+type PolyDataIndex = isize;
 type VarDataIndex = usize;
 enum DefinitionType{
     Component(ComponentDefinitionId),
     Function(FunctionDefinitionId),
+}
 impl DefinitionType {
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Component(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 pub(crate) struct ResolveQueueElement {
     // Note that using the `definition_id` and the `monomorph_idx` one may
     // query the type table for the full procedure type, thereby retrieving
     // the polymorphic arguments to the procedure.
     pub(crate) root_id: RootId,
     pub(crate) definition_id: DefinitionId,
     pub(crate) reserved_type_id: TypeId,
+}
 pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;
 #[derive(Clone)]
 struct InferenceNode {
     expr_type: InferenceType,       // result type from expression
     expr_id: ExpressionId,          // expression that is evaluated
     inference_rule: InferenceRule,
     parent_index: Option<InferNodeIndex>,
     field_or_monomorph_index: i32,    // index of field
     poly_data_index: PolyDataIndex,            // index of extra data needed for inference
     type_id: TypeId,                // when applicable indexes into type table
+}
 /// Inferencing rule to apply. Some of these are reasonably generic. Other ones
 /// require so much custom logic that we'll not try to come up with an
 /// abstraction.
 enum InferenceRule {
     Noop,
     MonoTemplate(InferenceRuleTemplate),
     BiEqual(InferenceRuleBiEqual),
     TriEqualArgs(InferenceRuleTriEqualArgs),
     TriEqualAll(InferenceRuleTriEqualAll),
     Concatenate(InferenceRuleTwoArgs),
     IndexingExpr(InferenceRuleIndexingExpr),
     SlicingExpr(InferenceRuleSlicingExpr),
     SelectStructField(InferenceRuleSelectStructField),
     SelectTupleMember(InferenceRuleSelectTupleMember),
     LiteralStruct(InferenceRuleLiteralStruct),
     LiteralEnum,
     LiteralUnion(InferenceRuleLiteralUnion),
     LiteralArray(InferenceRuleLiteralArray),
     LiteralTuple(InferenceRuleLiteralTuple),
     CastExpr(InferenceRuleCastExpr),
     CallExpr(InferenceRuleCallExpr),
     VariableExpr(InferenceRuleVariableExpr),
+}
 impl InferenceRule {
     union_cast_method_impl!(as_mono_template, InferenceRuleTemplate, InferenceRule::MonoTemplate);
     union_cast_method_impl!(as_bi_equal, InferenceRuleBiEqual, InferenceRule::BiEqual);
     union_cast_method_impl!(as_tri_equal_args, InferenceRuleTriEqualArgs, InferenceRule::TriEqualArgs);
     union_cast_method_impl!(as_tri_equal_all, InferenceRuleTriEqualAll, InferenceRule::TriEqualAll);
     union_cast_method_impl!(as_concatenate, InferenceRuleTwoArgs, InferenceRule::Concatenate);
     union_cast_method_impl!(as_indexing_expr, InferenceRuleIndexingExpr, InferenceRule::IndexingExpr);
     union_cast_method_impl!(as_slicing_expr, InferenceRuleSlicingExpr, InferenceRule::SlicingExpr);
     union_cast_method_impl!(as_select_struct_field, InferenceRuleSelectStructField, InferenceRule::SelectStructField);
     union_cast_method_impl!(as_select_tuple_member, InferenceRuleSelectTupleMember, InferenceRule::SelectTupleMember);
     union_cast_method_impl!(as_literal_struct, InferenceRuleLiteralStruct, InferenceRule::LiteralStruct);
     union_cast_method_impl!(as_literal_union, InferenceRuleLiteralUnion, InferenceRule::LiteralUnion);
     union_cast_method_impl!(as_literal_array, InferenceRuleLiteralArray, InferenceRule::LiteralArray);
     union_cast_method_impl!(as_literal_tuple, InferenceRuleLiteralTuple, InferenceRule::LiteralTuple);
     union_cast_method_impl!(as_cast_expr, InferenceRuleCastExpr, InferenceRule::CastExpr);
     union_cast_method_impl!(as_call_expr, InferenceRuleCallExpr, InferenceRule::CallExpr);
     union_cast_method_impl!(as_variable_expr, InferenceRuleVariableExpr, InferenceRule::VariableExpr);
+}
 // Note: InferenceRuleTemplate is `Copy`, so don't add dynamically allocated
 // members in the future (or review places where this struct is copied)
 #[derive(Clone, Copy)]
 struct InferenceRuleTemplate {
     template: &'static [InferenceTypePart],
     application: InferenceRuleTemplateApplication,
+}
 impl InferenceRuleTemplate {
     fn new_none() -> Self {
         return Self{
             template: &[],
             application: InferenceRuleTemplateApplication::None,
         };
+    }
     fn new_forced(template: &'static [InferenceTypePart]) -> Self {
         return Self{
             template,
             application: InferenceRuleTemplateApplication::Forced,
         };
+    }
     fn new_template(template: &'static [InferenceTypePart]) -> Self {
         return Self{
             template,
             application: InferenceRuleTemplateApplication::Template,
+        }
+    }
+}
 #[derive(Clone, Copy)]
 enum InferenceRuleTemplateApplication {
     None, // do not apply template, silly, but saves some bytes
     Forced,
     Template,
+}
 /// Type equality applied to 'self' and the argument. An optional template will
 /// be applied to 'self' first. Example: "bitwise not"
 struct InferenceRuleBiEqual {
     template: InferenceRuleTemplate,
     argument_index: InferNodeIndex,
+}
 /// Type equality applied to two arguments. Template can be applied to 'self'
 /// (generally forced, since this rule does not apply a type equality constraint
 /// to 'self') and the two arguments. Example: "equality operator"
 struct InferenceRuleTriEqualArgs {
     argument_template: InferenceRuleTemplate,
     result_template: InferenceRuleTemplate,
@@ @@ -998,113 +998,119 @@ struct InferenceRuleLiteralTuple { @@
 struct InferenceRuleCastExpr {
     subject_index: InferNodeIndex,
+}
 struct InferenceRuleCallExpr {
     argument_indices: Vec<InferNodeIndex>
+}
 /// Data associated with a variable expression: an expression that reads the
 /// value from a variable.
 struct InferenceRuleVariableExpr {
     var_data_index: VarDataIndex, // shared variable information
+}
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types.
 pub(crate) struct PassTyping {
     // Current definition we're typechecking.
     reserved_type_id: TypeId,
     definition_type: DefinitionType,
     poly_vars: Vec<ConcreteType>,
     // Temporary variables during construction of inference rulesr
     parent_index: Option<InferNodeIndex>,
     // Buffers for iteration over various types
     var_buffer: ScopedBuffer<VariableId>,
     expr_buffer: ScopedBuffer<ExpressionId>,
     stmt_buffer: ScopedBuffer<StatementId>,
     bool_buffer: ScopedBuffer<bool>,
     index_buffer: ScopedBuffer<usize>,
     poly_progress_buffer: ScopedBuffer<u32>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // specify these types until we're stuck or we've fully determined the type.
     infer_nodes: Vec<InferenceNode>,                     // will be transferred to type table at end
     poly_data: Vec<PolyData>,       // data for polymorph inference
     var_data: Vec<VarData>,
     // Keeping track of which expressions need to be reinferred because the
     // expressions they're linked to made progression on an associated type
     node_queued: DequeSet<InferNodeIndex>,
+}
 /// Generic struct that is used to store inferred types associated with
 /// polymorphic types.
 struct PolyData {
     first_rule_application: bool,
     definition_id: DefinitionId, // the definition, only used for user feedback
     /// Inferred types of the polymorphic variables as they are written down
     /// at the type's definition.
     poly_vars: Vec<InferenceType>,
     expr_types: PolyDataTypes,
+}
 // silly structure, just so we can use `PolyDataTypeIndex` ergonomically while
 // making sure we're still capable of borrowing from `poly_vars`.
 struct PolyDataTypes {
     /// Inferred types of associated types (e.g. struct fields, tuple members,
     /// function arguments). These types may depend on the polymorphic variables
     /// defined above.
     associated: Vec<InferenceType>,
     /// Inferred "returned" type (e.g. if a struct field is selected, then this
     /// contains the type of the selected field, for a function call it contains
     /// the return type). May depend on the polymorphic variables defined above.
     returned: InferenceType,
+}
 #[derive(Clone, Copy)]
 enum PolyDataTypeIndex {
     Associated(usize), // indexes into `PolyData.associated`
     Returned,
+}
-impl PolyData {
+impl PolyDataTypes {
     fn get_type(&self, index: PolyDataTypeIndex) -> &InferenceType {
         match index {
             PolyDataTypeIndex::Associated(index) => return &self.associated[index],
             PolyDataTypeIndex::Returned => return &self.returned,
+        }
+    }
     fn get_type_mut(&mut self, index: PolyDataTypeIndex) -> &mut InferenceType {
         match index {
             PolyDataTypeIndex::Associated(index) => return &mut self.associated[index],
             PolyDataTypeIndex::Returned => return &mut self.returned,
+        }
+    }
+}
 struct VarData {
     var_id: VariableId,
     var_type: InferenceType,
     used_at: Vec<InferNodeIndex>, // of variable expressions
     linked_var: Option<VarDataIndex>,
+}
 impl PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
             reserved_type_id: TypeId::new_invalid(),
             definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             poly_vars: Vec::new(),
             parent_index: None,
             var_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             expr_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             stmt_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             bool_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             index_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             poly_progress_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             infer_nodes: Vec::with_capacity(BUFFER_INIT_CAP_LARGE),
             poly_data: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),
             var_data: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),
             node_queued: DequeSet::new(),
+        }
+    }
     pub(crate) fn queue_module_definitions(ctx: &mut Ctx, queue: &mut ResolveQueue) {
         debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::ValidatedAndLinked);
         let root_id = ctx.module().root_id;
         let root = &ctx.heap.protocol_descriptions[root_id];
         for definition_id in &root.definitions {
             let definition = &ctx.heap[*definition_id];
@@ @@ -1160,146 +1166,138 @@ impl PassTyping { @@
         // Visit the definition, setting up the type resolving process, then
         // (attempt to) resolve all types
         self.visit_definition(ctx, element.definition_id)?;
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
         self.reserved_type_id = TypeId::new_invalid();
         self.definition_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.poly_vars.clear();
         self.parent_index = None;
         self.infer_nodes.clear();
         self.poly_data.clear();
         self.var_data.clear();
         self.node_queued.clear();
+    }
+}
 // -----------------------------------------------------------------------------
 // PassTyping - Visitor-like implementation
 // -----------------------------------------------------------------------------
 type VisitorResult = Result<(), ParseError>;
 type VisitExprResult = Result<InferNodeIndex, ParseError>;
 impl PassTyping {
     // Definitions
     fn visit_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> VisitorResult {
         return visitor_recursive_definition_impl!(self, &ctx.heap[id], ctx);
+    }
     fn visit_enum_definition(&mut self, _: &mut Ctx, _: EnumDefinitionId) -> VisitorResult { return Ok(()) }
     fn visit_struct_definition(&mut self, _: &mut Ctx, _: StructDefinitionId) -> VisitorResult { return Ok(()) }
     fn visit_union_definition(&mut self, _: &mut Ctx, _: UnionDefinitionId) -> VisitorResult { return Ok(()) }
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
         debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting component '{}': {}", comp_def.identifier.value.as_str(), id.0.index);
         debug_log!("{}", "-".repeat(50));
         // Reserve data for expression types
         debug_assert!(self.infer_nodes.is_empty());
         self.infer_nodes.resize(comp_def.num_expressions_in_body as usize, Default::default());
         // Visit parameters
         let section = self.var_buffer.start_section_initialized(comp_def.parameters.as_slice());
         for param_id in section.iter_copied() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_data.push(VarData{
                 var_id: param_id,
                 var_type,
                 used_at: Vec::new(),
                 linked_var: None
             });
+        }
         section.forget();
         // Visit the body and all of its expressions
         let body_stmt_id = ctx.heap[id].body;
         self.parent_index = None;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Function(id);
         let func_def = &ctx.heap[id];
         debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting function '{}': {}", func_def.identifier.value.as_str(), id.0.index);
         if debug_log_enabled!() {
             debug_log!("Polymorphic variables:");
             for (_idx, poly_var) in self.poly_vars.iter().enumerate() {
                 let mut infer_type_parts = Vec::new();
                 Self::determine_inference_type_from_concrete_type(
                     &mut infer_type_parts, &poly_var.parts
                 );
                 let _infer_type = InferenceType::new(false, true, infer_type_parts);
                 debug_log!(" - [{:03}] {:?}", _idx, _infer_type.display_name(&ctx.heap));
+            }
+        }
         debug_log!("{}", "-".repeat(50));
         // Reserve data for expression types
         debug_assert!(self.infer_nodes.is_empty());
         self.infer_nodes.resize(func_def.num_expressions_in_body as usize, Default::default());
         // Visit parameters
         let section = self.var_buffer.start_section_initialized(func_def.parameters.as_slice());
         for param_id in section.iter_copied() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_data.push(VarData{
                 var_id: param_id,
                 var_type,
                 used_at: Vec::new(),
                 linked_var: None
             })
+        }
         section.forget();
         // Visit all of the expressions within the body
         let body_stmt_id = ctx.heap[id].body;
         self.parent_index = None;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
     // Statements
     fn visit_stmt(&mut self, ctx: &mut Ctx, id: StatementId) -> VisitorResult {
         return visitor_recursive_statement_impl!(self, &ctx.heap[id], ctx, Ok(()));
+    }
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         let section = self.stmt_buffer.start_section_initialized(block.statements.as_slice());
         for stmt_id in section.iter_copied() {
             self.visit_stmt(ctx, stmt_id)?;
+        }
         section.forget();
         Ok(())
+    }
     fn visit_local_stmt(&mut self, ctx: &mut Ctx, id: LocalStatementId) -> VisitorResult {
         return visitor_recursive_local_impl!(self, &ctx.heap[id], ctx);
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let initial_expr_id = memory_stmt.initial_expr;
@@ @@ -1724,178 +1722,194 @@ impl PassTyping { @@
         self.progress_inference_rule(ctx, self_index)?;
         return Ok(self_index);
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitExprResult {
         let upcast_id = id.upcast();
         let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;
         let old_parent = self.parent_index.replace(self_index);
         let literal_expr = &ctx.heap[id];
         match &literal_expr.value {
             Literal::Null => {
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::MonoTemplate(InferenceRuleTemplate::new_template(&MESSAGE_TEMPLATE));
             },
             Literal::Integer(_) => {
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::MonoTemplate(InferenceRuleTemplate::new_template(&INTEGERLIKE_TEMPLATE));
             },
             Literal::True | Literal::False => {
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::MonoTemplate(InferenceRuleTemplate::new_forced(&BOOL_TEMPLATE));
             },
             Literal::Character(_) => {
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::MonoTemplate(InferenceRuleTemplate::new_forced(&CHARACTER_TEMPLATE));
             },
             Literal::String(_) => {
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::MonoTemplate(InferenceRuleTemplate::new_forced(&STRING_TEMPLATE));
             },
             Literal::Struct(literal) => {
                 // Visit field expressions
                 let mut expr_ids = self.expr_buffer.start_section();
                 for field in &literal.fields {
                     expr_ids.push(field.value);
+                }
                 let mut expr_indices = self.index_buffer.start_section();
                 for expr_id in expr_ids.iter_copied() {
                     let expr_index = self.visit_expr(ctx, expr_id)?;
                     expr_indices.push(expr_index);
+                }
                 expr_ids.forget();
                 let element_indices = expr_indices.into_vec();
                 // Assign rule and extra data index to inference node
-                let extra_index = self.insert_initial_struct_polymorph_data(ctx, id);
+                let poly_data_index = self.insert_initial_struct_polymorph_data(ctx, id);
                 let node = &mut self.infer_nodes[self_index];
-                node.poly_data_index = extra_index;
+                node.poly_data_index = poly_data_index;
                 node.inference_rule = InferenceRule::LiteralStruct(InferenceRuleLiteralStruct{
                     element_indices,
                 });
             },
             Literal::Enum(_) => {
                 // Enumerations do not carry any subexpressions, but may still
                 // have a user-defined polymorphic marker variable. For this
                 // reason we may still have to apply inference to this
                 // polymorphic variable
-                let extra_index = self.insert_initial_enum_polymorph_data(ctx, id);
+                let poly_data_index = self.insert_initial_enum_polymorph_data(ctx, id);
                 let node = &mut self.infer_nodes[self_index];
-                node.poly_data_index = extra_index;
+                node.poly_data_index = poly_data_index;
                 node.inference_rule = InferenceRule::LiteralEnum;
             },
             Literal::Union(literal) => {
                 // May carry subexpressions and polymorphic arguments
                 let expr_ids = self.expr_buffer.start_section_initialized(literal.values.as_slice());
-                let extra_index = self.insert_initial_union_polymorph_data(ctx, id);
+                let poly_data_index = self.insert_initial_union_polymorph_data(ctx, id);
                 let mut expr_indices = self.index_buffer.start_section();
                 for expr_id in expr_ids.iter_copied() {
                     let expr_index = self.visit_expr(ctx, expr_id)?;
                     expr_indices.push(expr_index);
+                }
                 expr_ids.forget();
                 let element_indices = expr_indices.into_vec();
                 let node = &mut self.infer_nodes[self_index];
-                node.poly_data_index = extra_index;
+                node.poly_data_index = poly_data_index;
                 node.inference_rule = InferenceRule::LiteralUnion(InferenceRuleLiteralUnion{
                     element_indices,
                 });
             },
-            Literal::Array(expressions) | Literal::Tuple(expressions) => {
             Literal::Array(expressions) => {
                 let expr_ids = self.expr_buffer.start_section_initialized(expressions.as_slice());
                 let mut expr_indices = self.index_buffer.start_section();
                 let mut expr_indices = self.index_buffer.start_section();
                 for expr_id in expr_ids.iter_copied() {
                     let expr_index = self.visit_expr(ctx, expr_id)?;
                     expr_indices.push(expr_index);
+                }
                 expr_ids.forget();
                 let element_indices = expr_indices.into_vec();
                 let node = &mut self.infer_nodes[self_index];
                 node.poly_data_index = extra_index;
                 node.inference_rule = InferenceRule::LiteralArray(InferenceRuleLiteralArray{
                     element_indices,
                 });
             },
             Literal::Tuple(expressions) => {
                 let expr_ids = self.expr_buffer.start_section_initialized(expressions.as_slice());
                 let mut expr_indices = self.index_buffer.start_section();
                 for expr_id in expr_ids.iter_copied() {
                     let expr_index = self.visit_expr(ctx, expr_id)?;
                     expr_indices.push(expr_index);
+                }
                 expr_ids.forget();
                 let element_indices = expr_indices.into_vec();
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::LiteralTuple(InferenceRuleLiteralTuple{
                     element_indices,
                 })
+            }
+        }
         self.parent_index = old_parent;
         self.progress_inference_rule(ctx, self_index)?;
         return Ok(self_index);
+    }
     fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitExprResult {
         let upcast_id = id.upcast();
         let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;
         let cast_expr = &ctx.heap[id];
         let subject_expr_id = cast_expr.subject;
         let old_parent = self.parent_index.replace(self_index);
         let subject_index = self.visit_expr(ctx, subject_expr_id)?;
         let node = &mut self.infer_nodes[self_index];
         node.inference_rule = InferenceRule::CastExpr(InferenceRuleCastExpr{
             subject_index,
         });
         self.parent_index = old_parent;
         // The cast expression is a bit special at this point: the progression
         // function simply makes sure input/output types are compatible. But if
         // the programmer explicitly specified the output type, then we can
         // already perform that inference rule here.
+        {
             let cast_expr = &ctx.heap[id];
             let specified_type = self.determine_inference_type_from_parser_type_elements(&cast_expr.to_type.elements, true);
             let _progress = self.apply_template_constraint(ctx, self_index, &specified_type.parts)?;
+        }
         self.progress_inference_rule_cast_expr(ctx, self_index)?;
         return Ok(self_index);
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitExprResult {
         let upcast_id = id.upcast();
         let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;
         let extra_index = self.insert_initial_call_polymorph_data(ctx, id);
         // By default we set the polymorph idx for calls to 0. If the call
         // refers to a non-polymorphic function, then it will be "monomorphed"
         // once, hence we end up pointing to the correct instance.
         self.infer_nodes[self_index].field_or_monomorph_index = 0;
         // Visit all arguments
         let old_parent = self.parent_index.replace(self_index);
         let call_expr = &ctx.heap[id];
         let expr_ids = self.expr_buffer.start_section_initialized(call_expr.arguments.as_slice());
         let mut expr_indices = self.index_buffer.start_section();
         for arg_expr_id in expr_ids.iter_copied() {
             let expr_index = self.visit_expr(ctx, arg_expr_id)?;
             expr_indices.push(expr_index);
+        }
         expr_ids.forget();
         let argument_indices = expr_indices.into_vec();
         let node = &mut self.infer_nodes[self_index];
         node.poly_data_index = extra_index;
         node.inference_rule = InferenceRule::CallExpr(InferenceRuleCallExpr{
             argument_indices,
         });
         self.parent_index = old_parent;
         self.progress_inference_rule_call_expr(ctx, self_index)?;
         return Ok(self_index);
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitExprResult {
         let upcast_id = id.upcast();
         let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;
         let var_expr = &ctx.heap[id];
@@ @@ -1915,1373 +1929,1404 @@ impl PassTyping { @@
             let var_data = &mut self.var_data[var_data_index];
             var_data.used_at.push(self_index);
             var_data_index
         } else {
             // If we're in a binding expression then it might the first time we
             // encounter the variable, so add a `VarData` entry.
             debug_assert_eq!(declaration.kind, VariableKind::Binding);
             let var_type = self.determine_inference_type_from_parser_type_elements(
                 &declaration.parser_type.elements, true
             );
             let var_data_index = self.var_data.len();
             self.var_data.push(VarData{
                 var_id: declaration.this,
                 var_type,
                 used_at: vec![self_index],
                 linked_var: None,
             });
             var_data_index
         };
         let node = &mut self.infer_nodes[self_index];
         node.inference_rule = InferenceRule::VariableExpr(InferenceRuleVariableExpr{
             var_data_index,
         });
         self.parent_index = old_parent;
         self.progress_inference_rule_variable_expr(ctx, self_index)?;
         return Ok(self_index);
+    }
+}
 // -----------------------------------------------------------------------------
 // PassTyping - Type-inference progression
 // -----------------------------------------------------------------------------
 impl PassTyping {
     #[allow(dead_code)] // used when debug flag at the top of this file is true.
     fn debug_get_display_name(&self, ctx: &Ctx, expr_id: ExpressionId) -> String {
         let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition();
         let expr_type = &self.infer_nodes[expr_idx as usize].expr_type;
         expr_type.display_name(&ctx.heap)
+    }
     fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {
         // Keep inferring until we can no longer make any progress
         while !self.node_queued.is_empty() {
             // Make as much progress as possible without forced integer
             // inference.
             while !self.node_queued.is_empty() {
                 let next_expr_idx = self.node_queued.pop_front().unwrap();
                 self.progress_expr(ctx, next_expr_idx)?;
                 let node_index = self.node_queued.pop_front().unwrap();
                 self.progress_inference_rule(ctx, node_index)?;
+            }
             // Nothing is queued anymore. However we might have integer literals
             // whose type cannot be inferred. For convenience's sake we'll
             // infer these to be s32.
             for (infer_node_index, infer_node) in self.infer_nodes.iter_mut().enumerate() {
                 let expr_type = &mut infer_node.expr_type;
                 if !expr_type.is_done && expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     // Force integer type to s32
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                     expr_type.is_done = true;
                     // Requeue expression (and its parent, if it exists)
                     self.node_queued.push_back(infer_node_index);
                     if let Some(parent_node_index) = infer_node.parent_index {
                         self.expr_queued(parent_node_index);
                     if let Some(node_parent_index) = infer_node.parent_index {
                         self.node_queued.push_back(node_parent_index);
+                    }
+                }
+            }
+        }
         // Helper for transferring polymorphic variables to concrete types and
         // checking if they're completely specified
         fn inference_type_to_concrete_type(
             ctx: &Ctx, expr_id: ExpressionId, inference: &Vec<InferenceType>,
             first_concrete_part: ConcreteTypePart,
         ) -> Result<ConcreteType, ParseError> {
             // Prepare storage vector
             let mut num_inference_parts = 0;
             for inference_type in inference {
                 num_inference_parts += inference_type.parts.len();
+            }
             let mut concrete_type = ConcreteType{
                 parts: Vec::with_capacity(1 + num_inference_parts),
             };
             concrete_type.parts.push(first_concrete_part);
             // Go through all polymorphic arguments and add them to the concrete
             // types.
             for (poly_idx, poly_type) in inference.iter().enumerate() {
                 if !poly_type.is_done {
                     let expr = &ctx.heap[expr_id];
                     let definition = match expr {
                         Expression::Call(expr) => expr.definition,
                         Expression::Literal(expr) => match &expr.value {
                             Literal::Enum(lit) => lit.definition,
                             Literal::Union(lit) => lit.definition,
                             Literal::Struct(lit) => lit.definition,
                             _ => unreachable!()
                         },
                         _ => unreachable!(),
                     };
                     let poly_vars = ctx.heap[definition].poly_vars();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, expr.operation_span(), format!(
                             "could not fully infer the type of polymorphic variable '{}' of this expression (got '{}')",
                             poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
                 poly_type.write_concrete_type(&mut concrete_type);
+            }
             Ok(concrete_type)
+        }
         // Inference is now done. But we may still have uninferred types. So we
         // check for these.
         for infer_expr in self.infer_nodes.iter_mut() {
             if !infer_expr.expr_type.is_done {
                 let expr = &ctx.heap[infer_expr.expr_id];
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, expr.full_span(), format!(
                         "could not fully infer the type of this expression (got '{}')",
                         infer_expr.expr_type.display_name(&ctx.heap)
+                    )
                 ));
+            }
             // Expression is fine, check if any extra data is attached
-            if infer_expr.extra_data_idx < 0 { continue; }
+            if infer_expr.poly_data_index < 0 { continue; }
             // Extra data is attached, perform typechecking and transfer
             // resolved information to the expression
-            let extra_data = &self.poly_data[infer_expr.extra_data_idx as usize];
+            let poly_data = &self.poly_data[infer_expr.poly_data_index as usize];
             // Note that only call and literal expressions need full inference.
             // Select expressions also use `extra_data`, but only for temporary
             // storage of the struct type whose field it is selecting.
-            match &ctx.heap[extra_data.expr_id] {
+            match &ctx.heap[infer_expr.expr_id] {
                 Expression::Call(expr) => {
                     // Check if it is not a builtin function. If not, then
                     // construct the first part of the concrete type.
                     let first_concrete_part = if expr.method == Method::UserFunction {
-                        ConcreteTypePart::Function(expr.definition, extra_data.poly_vars.len() as u32)
+                        ConcreteTypePart::Function(expr.definition, poly_data.poly_vars.len() as u32)
                     } else if expr.method == Method::UserComponent {
-                        ConcreteTypePart::Component(expr.definition, extra_data.poly_vars.len() as u32)
+                        ConcreteTypePart::Component(expr.definition, poly_data.poly_vars.len() as u32)
                     } else {
                         // Builtin function
                         continue;
                     };
                     let definition_id = expr.definition;
                     let concrete_type = inference_type_to_concrete_type(
-                        ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part
+                        ctx, infer_expr.expr_id, &poly_data.poly_vars, first_concrete_part
                     )?;
                     match ctx.types.get_procedure_monomorph_type_id(&definition_id, &concrete_type.parts) {
                         Some(type_id) => {
                             // Already typechecked, or already put into the resolve queue
                             infer_expr.type_id = type_id;
                         },
                         None => {
                             // Not typechecked yet, so add an entry in the queue
                             let reserved_type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, concrete_type);
                             infer_expr.type_id = reserved_type_id;
                             queue.push(ResolveQueueElement {
                                 root_id: ctx.heap[definition_id].defined_in(),
                                 definition_id,
                                 reserved_type_id,
                             });
+                        }
+                    }
                 },
                 Expression::Literal(expr) => {
                     let definition_id = match &expr.value {
                         Literal::Enum(lit) => lit.definition,
                         Literal::Union(lit) => lit.definition,
                         Literal::Struct(lit) => lit.definition,
                         _ => unreachable!(),
                     };
-                    let first_concrete_part = ConcreteTypePart::Instance(definition_id, extra_data.poly_vars.len() as u32);
+                    let first_concrete_part = ConcreteTypePart::Instance(definition_id, poly_data.poly_vars.len() as u32);
                     let concrete_type = inference_type_to_concrete_type(
-                        ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part
+                        ctx, infer_expr.expr_id, &poly_data.poly_vars, first_concrete_part
                     )?;
                     let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, definition_id, concrete_type)?;
                     infer_expr.type_id = type_id;
                 },
                 Expression::Select(_) => {
                     debug_assert!(infer_expr.field_or_monomorph_index >= 0);
                 },
                 _ => {
-                    unreachable!("handling extra data for expression {:?}", &ctx.heap[extra_data.expr_id]);
+                    unreachable!("handling extra data for expression {:?}", &ctx.heap[infer_expr.expr_id]);
+                }
+            }
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the type table.
         let procedure_arguments = match &self.definition_type {
             DefinitionType::Component(id) => {
                 let definition = &ctx.heap[*id];
                 &definition.parameters
             },
             DefinitionType::Function(id) => {
                 let definition = &ctx.heap[*id];
                 &definition.parameters
             },
         };
         let target = ctx.types.get_procedure_monomorph_mut(self.reserved_type_id);
         debug_assert!(target.arg_types.is_empty()); // makes sure we never queue a procedure's type inferencing twice
         debug_assert!(target.expr_data.is_empty());
         // - Write the arguments to the procedure
         target.arg_types.reserve(procedure_arguments.len());
         for argument_id in procedure_arguments {
             let mut concrete = ConcreteType::default();
             let var_data = self.var_data.iter().find(|v| v.var_id == *argument_id).unwrap();
             var_data.var_type.write_concrete_type(&mut concrete);
             target.arg_types.push(concrete);
+        }
         // - Write the expression data
         target.expr_data.reserve(self.infer_nodes.len());
         for infer_expr in self.infer_nodes.iter() {
             let mut concrete = ConcreteType::default();
             infer_expr.expr_type.write_concrete_type(&mut concrete);
             target.expr_data.push(MonomorphExpression{
                 expr_type: concrete,
                 field_or_monomorph_idx: infer_expr.field_or_monomorph_index,
                 type_id: infer_expr.type_id,
             });
+        }
         Ok(())
+    }
     fn progress_inference_rule(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         use InferenceRule as IR;
         let node = &self.infer_nodes[node_index];
         match &node.inference_rule {
             IR::Noop =>
                 unreachable!(),
             IR::MonoTemplate(_) =>
                 self.progress_inference_rule_mono_template(ctx, node_index),
             IR::BiEqual(_) =>
                 self.progress_inference_rule_bi_equal(ctx, node_index),
             IR::TriEqualArgs(_) =>
                 self.progress_inference_rule_tri_equal_args(ctx, node_index),
             IR::TriEqualAll(_) =>
                 self.progress_inference_rule_tri_equal_all(ctx, node_index),
             IR::Concatenate(_) =>
                 self.progress_inference_rule_concatenate(ctx, node_index),
             IR::IndexingExpr(_) =>
                 self.progress_inference_rule_indexing_expr(ctx, node_index),
             IR::SlicingExpr(_) =>
                 self.progress_inference_rule_slicing_expr(ctx, node_index),
             IR::SelectStructField(_) =>
                 self.progress_inference_rule_select_struct_field(ctx, node_index),
             IR::SelectTupleMember(_) =>
                 self.progress_inference_rule_select_tuple_member(ctx, node_index),
             IR::LiteralStruct(_) =>
                 self.progress_inference_rule_literal_struct(ctx, node_index),
             IR::LiteralEnum =>
                 self.progress_inference_rule_literal_enum(ctx, node_index),
             IR::LiteralUnion(_) =>
                 self.progress_inference_rule_literal_union(ctx, node_index),
             IR::LiteralArray(_) =>
                 self.progress_inference_rule_literal_array(ctx, node_index),
             IR::LiteralTuple(_) =>
                 self.progress_inference_rule_literal_tuple(ctx, node_index),
             IR::CastExpr(_) =>
                 self.progress_inference_rule_cast_expr(ctx, node_index),
             IR::CallExpr(_) =>
                 self.progress_inference_rule_call_expr(ctx, node_index),
             IR::VariableExpr(_) =>
                 self.progress_inference_rule_variable_expr(ctx, node_index),
+        }
+    }
     fn progress_inference_rule_mono_template(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_mono_template();
+        let rule = *node.inference_rule.as_mono_template();
         let progress = self.progress_template(ctx, node_index, rule.application, rule.template)?;
         if progress { self.queue_node_parent(node_index); }
         return Ok(());
+    }
     fn progress_inference_rule_bi_equal(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_bi_equal();
         let template = rule.template;
         let arg_index = rule.argument_index;
-        let base_progress = self.progress_template(ctx, node_index, rule.template.application, rule.template.template)?;
         let base_progress = self.progress_template(ctx, node_index, template.application, template.template)?;
         let (node_progress, arg_progress) = self.apply_equal2_constraint(ctx, node_index, node_index, 0, arg_index, 0)?;
         if base_progress || node_progress { self.queue_node_parent(node_index); }
         if arg_progress { self.queue_node(arg_index); }
         return Ok(())
+    }
     fn progress_inference_rule_tri_equal_args(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_tri_equal_args();
         let result_template = rule.result_template;
         let argument_template = rule.argument_template;
         let arg1_index = rule.argument1_index;
         let arg2_index = rule.argument2_index;
         let self_template_progress = self.progress_template(ctx, node_index, rule.result_template.application, rule.result_template.template)?;
         let arg1_template_progress = self.progress_template(ctx, arg1_index, rule.argument_template.application, rule.argument_template.template)?;
         let self_template_progress = self.progress_template(ctx, node_index, result_template.application, result_template.template)?;
         let arg1_template_progress = self.progress_template(ctx, arg1_index, argument_template.application, argument_template.template)?;
         let (arg1_progress, arg2_progress) = self.apply_equal2_constraint(ctx, node_index, arg1_index, 0, arg2_index, 0)?;
         if self_template_progress { self.queue_node_parent(node_index); }
         if arg1_template_progress || arg1_progress { self.queue_node(arg1_index); }
-        if arg2_template_progress || arg2_progress { self.queue_node(arg2_index); }
         if arg2_progress { self.queue_node(arg2_index); }
         return Ok(());
+    }
     fn progress_inference_rule_tri_equal_all(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_tri_equal_all();
         let template = rule.template;
         let arg1_index = rule.argument1_index;
         let arg2_index = rule.argument2_index;
-        let template_progress = self.progress_template(ctx, node_index, rule.template.application, rule.template.template)?;
         let template_progress = self.progress_template(ctx, node_index, template.application, template.template)?;
         let (node_progress, arg1_progress, arg2_progress) =
             self.apply_equal3_constraint(ctx, node_index, arg1_index, arg2_index, 0)?;
         if template_progress || node_progress { self.queue_node_parent(node_index); }
         if arg1_progress { self.queue_node(arg1_index); }
         if arg2_progress { self.queue_node(arg2_index); }
         return Ok(());
+    }
     fn progress_inference_rule_concatenate(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_concatenate();
         let arg1_index = rule.argument1_index;
         let arg2_index = rule.argument2_index;
         // Two cases: one of the arguments is a string (then all must be), or
         // one of the arguments is an array (and all must be arrays).
         let (expr_is_str, expr_is_not_str) = self.type_is_certainly_or_certainly_not_string(node_index);
         let (arg1_is_str, arg1_is_not_str) = self.type_is_certainly_or_certainly_not_string(arg1_index);
         let (arg2_is_str, arg2_is_not_str) = self.type_is_certainly_or_certainly_not_string(arg2_index);
         let someone_is_str = expr_is_str || arg1_is_str || arg2_is_str;
         let someone_is_not_str = expr_is_not_str || arg1_is_not_str || arg2_is_not_str;
+        println!("DEBUG: Running concat, is_str = {}, is_not_str = {}", someone_is_str, someone_is_not_str);
         // Note: this statement is an expression returning the progression bools
         let (node_progress, arg1_progress, arg2_progress) = if someone_is_str {
             // One of the arguments is a string, then all must be strings
             self.apply_equal3_constraint(ctx, node_index, arg1_index, arg2_index, 0)?
         } else {
             let progress_expr = if someone_is_not_str {
                 // Output must be a normal array
                 self.apply_template_constraint(ctx, node_index, &ARRAY_TEMPLATE)?
             } else {
                 // Output may still be anything
                 self.apply_template_constraint(ctx, node_index, &ARRAYLIKE_TEMPLATE)?
             };
             let progress_arg1 = self.apply_template_constraint(ctx, arg1_index, &ARRAYLIKE_TEMPLATE)?;
             let progress_arg2 = self.apply_template_constraint(ctx, arg2_index, &ARRAYLIKE_TEMPLATE)?;
             // If they're all arraylike, then we want the subtype to match
             let (subtype_expr, subtype_arg1, subtype_arg2) =
                 self.apply_equal3_constraint(ctx, node_index, arg1_index, arg2_index, 1)?;
             (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)
         };
         if node_progress { self.queue_node_parent(node_index); }
         if arg1_progress { self.queue_node(arg1_index); }
         if arg2_progress { self.queue_node(arg2_index); }
         return Ok(())
+    }
     fn progress_inference_rule_indexing_expr(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_indexing_expr();
         let subject_index = rule.subject_index;
         let index_index = rule.index_index; // which one?
         // Subject is arraylike, index in integerlike
         let subject_template_progress = self.apply_template_constraint(ctx, subject_index, &ARRAYLIKE_TEMPLATE)?;
         let index_template_progress = self.apply_template_constraint(ctx, index_index, &INTEGERLIKE_TEMPLATE)?;
         // If subject is type `Array<T>`, then expr type is `T`
         let (node_progress, subject_progress) =
             self.apply_equal2_constraint(ctx, node_index, node_index, 0, subject_index, 1)?;
         if node_progress { self.queue_node_parent(node_index); }
         if subject_template_progress || subject_progress { self.queue_node(subject_index); }
         if index_template_progress { self.queue_node(index_index); }
         return Ok(());
+    }
     fn progress_inference_rule_slicing_expr(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_slicing_expr();
         let subject_index = rule.subject_index;
         let from_index_index = rule.from_index;
         let to_index_index = rule.to_index;
         debug_log!("Rule slicing [node: {}, expr: {}]", node_index, node.expr_id.index);
         // Subject is arraylike, indices are integerlike
         let subject_template_progress = self.apply_template_constraint(ctx, subject_index, &ARRAYLIKE_TEMPLATE)?;
         let from_template_progress = self.apply_template_constraint(ctx, from_index_index, &INTEGERLIKE_TEMPLATE)?;
         let to_template_progress = self.apply_template_constraint(ctx, to_index_index, &INTEGERLIKE_TEMPLATE)?;
         let (from_index_progress, to_index_progress) =
             self.apply_equal2_constraint(ctx, node_index, from_index_index, 0, to_index_index, 0)?;
         // Same as array indexing: result depends on whether subject is string
         // or array
         let (is_string, is_not_string) = self.type_is_certainly_or_certainly_not_string(node_index);
         println!("DEBUG: Running slicing, is_str = {}, is_not_str = {}", is_string, is_not_string);
         let (node_progress, subject_progress) = if is_string {
             // Certainly a string
+            (
                 self.apply_forced_constraint(ctx, node_index, &STRING_TEMPLATE)?,
                 false
+            )
         } else if is_not_string {
             // Certainly not a string, apply template constraint. Then make sure
             // that if we have an `Array<T>`, that the slice produces `Slice<T>`
             let node_template_progress = self.apply_template_constraint(ctx, node_index, &SLICE_TEMPLATE)?;
             let (node_progress, subject_progress) =
                 self.apply_equal2_constraint(ctx, node_index, node_index, 1, subject_index, 1)?;
+            (
                 node_template_progress || node_progress,
                 subject_progress
+            )
         } else {
             // Not sure yet
             let node_template_progress = self.apply_template_constraint(ctx, node_index, &ARRAYLIKE_TEMPLATE)?;
             let (node_progress, subject_progress) =
                 self.apply_equal2_constraint(ctx, node_index, node_index, 1, subject_index, 1)?;
+            (
                 node_template_progress || node_progress,
                 subject_progress
+            )
         };
         if node_progress { self.queue_node_parent(node_index); }
         if subject_template_progress || subject_progress { self.queue_node(subject_index); }
         if from_template_progress || from_index_progress { self.queue_node(from_index_index); }
         if to_template_progress || to_index_progress { self.queue_node(to_index_index); }
         return Ok(());
+    }
     fn progress_inference_rule_select_struct_field(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_select_struct_field();
         let subject_index = rule.subject_index;
         let selected_field = rule.selected_field.clone();
         fn get_definition_id_from_inference_type(inference_type: &InferenceType) -> Result<Option<DefinitionId>, ()> {
             for part in inference_type.parts.iter() {
                 if part.is_marker() { continue; }
                 if !part.is_concrete() { break; }
                 if let InferenceTypePart::Instance(definition_id, _) = part {
                     return Ok(Some(*definition_id));
                 } else {
                     return Err(())
+                }
+            }
             // Nothing is known yet
             return Ok(None);
+        }
         if node.field_or_monomorph_index < 0 {
             // Don't know the subject definition, hence the field yet. Try to
             // determine it.
             let subject_node = &self.infer_nodes[subject_index];
             match get_definition_id_from_inference_type(&subject_node.expr_type) {
                 Ok(Some(definition_id)) => {
                     // Determined definition of subject for the first time.
                     let base_definition = ctx.types.get_base_definition(&definition_id).unwrap();
                     let struct_definition = if let DefinedTypeVariant::Struct(struct_definition) = &base_definition.definition {
                         struct_definition
                     } else {
                         return Err(ParseError::new_error_at_span(
-                            &ctx.module().source, rule.selected_field.span, format!(
                             &ctx.module().source, selected_field.span, format!(
                                 "Can only apply field access to structs, got a subject of type '{}'",
-                                subject_type.display_name(&ctx.heap)
+                                subject_node.expr_type.display_name(&ctx.heap)
+                            )
                         ));
                     };
                     // Seek the field that is referenced by the select
                     // expression
                     let mut field_found = false;
                     for (field_index, field) in struct_definition.fields.iter().enumerate() {
-                        if field.identifier.value == rule.selected_field.value {
                         if field.identifier.value == selected_field.value {
                             // Found the field of interest
                             field_found = true;
                             let node = &mut self.infer_nodes[node_index];
                             node.field_or_monomorph_index = field_index as i32;
                             break;
+                        }
+                    }
                     if !field_found {
                         let struct_definition = ctx.heap[definition_id].as_struct();
                         return Err(ParseError::new_error_at_span(
-                            &ctx.module().source, rule.selected_field.span, format!(
                             &ctx.module().source, selected_field.span, format!(
                                 "this field does not exist on the struct '{}'",
-                                ast_struct_def.identifier.value.as_str()
+                                struct_definition.identifier.value.as_str()
+                            )
                         ));
+                    }
                     // Insert the initial data needed to infer polymorphic
                     // fields
                     let extra_index = self.insert_initial_select_polymorph_data(ctx, node_index, definition_id);
                     let node = &mut self.infer_nodes[node_index];
                     node.poly_data_index = extra_index;
                 },
                 Ok(None) => {
                     // We don't know what to do yet, because we don't know the
                     // subject type yet.
                     return Ok(())
                 },
                 Err(()) => {
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, rule.selected_field.span, format!(
                             "Can only apply field access to structs, got a subject of type '{}'",
-                            subject_type.display_name(&ctx.heap)
+                            subject_node.expr_type.display_name(&ctx.heap)
+                        )
                     ));
                 },
+            }
+        }
         // If here then the field index is known, hence we can start inferring
         // the type of the selected field
         let field_expr_id = self.infer_nodes[node_index].expr_id;
         let subject_expr_id = self.infer_nodes[subject_index].expr_id;
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
         let (_, progress_subject_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, subject_expr_id, "selected struct's",
             PolyDataTypeIndex::Associated(0), 0, subject_index, 0, &mut poly_progress_section
         )?;
         let (_, progress_field_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, field_expr_id, "selected field's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         // Maybe make progress on types due to inferred polymorphic variables
         let progress_subject_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Associated(0), subject_index, &poly_progress_section
         );
         let progress_field_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned, node_index, &poly_progress_section
         );
         if progress_subject_1 || progress_subject_2 { self.queue_node(subject_index); }
         if progress_field_1 || progress_field_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(())
+    }
     fn progress_inference_rule_select_tuple_member(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_select_tuple_member();
         let subject_index = rule.subject_index;
         let tuple_member_index = rule.selected_index;
         if node.field_or_monomorph_index < 0 {
             let subject_type = &self.infer_nodes[subject_index].expr_type;
             let tuple_size = get_tuple_size_from_inference_type(subject_type);
             let tuple_size = match tuple_size {
                 Ok(Some(tuple_size)) => {
                     tuple_size
                 },
                 Ok(None) => {
                     // We can't infer anything yet
                     return Ok(())
                 },
                 Err(()) => {
                     let select_expr_span = ctx.heap[node.expr_id].full_span();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, select_expr_span, format!(
                             "tuple element select cannot be applied to a subject of type '{}'",
                             subject_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
             };
             // If here then we at least have the tuple size. Now check if the
             // index doesn't exceed that size.
             if tuple_member_index >= tuple_size as u64 {
                 let select_expr_span = ctx.heap[node.expr_id].full_span();
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, select_expr_span, format!(
                         "element index {} is out of bounds, tuple has {} elements",
                         tuple_member_index, tuple_size
+                    )
                 ));
+            }
             // Within bounds, set index on the type inference node
             let node = &mut self.infer_nodes[node_index];
             node.field_or_monomorph_index = tuple_member_index as i32;
+        }
         // If here then we know we can use `tuple_member_index`. We need to keep
         // computing the offset to the subtype, as its value changes during
         // inference
         let subject_type = &self.infer_nodes[subject_index].expr_type;
         let mut selected_member_start_index = 1; // start just after the InferenceTypeElement::Tuple
         for _ in 0..tuple_member_index {
             selected_member_start_index = InferenceType::find_subtree_end_idx(&subject_type.parts, selected_member_start_index);
+        }
         let (progress_member, progress_subject) = self.apply_equal2_constraint(
-            ctx, node_index, node_index, 0, subject_index, selected_member_start_idx
+            ctx, node_index, node_index, 0, subject_index, selected_member_start_index
         )?;
         if progress_member { self.queue_node_parent(node_index); }
         if progress_subject { self.queue_node(subject_index); }
         return Ok(());
+    }
     fn progress_inference_rule_literal_struct(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let node_expr_id = node.expr_id;
         let rule = node.inference_rule.as_literal_struct();
         // For each of the fields in the literal struct, apply the type equality
         // constraint. If the literal is polymorphic, then we try to progress
         // their types during this process
         let element_indices_section = self.index_buffer.start_section_initialized(&rule.element_indices);
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
-        for (field_index, field_node_index) in rule.element_indices.iter().copied().enumerate() {
+        for (field_index, field_node_index) in element_indices_section.iter_copied().enumerate() {
             let field_expr_id = self.infer_nodes[field_node_index].expr_id;
             let (_, progress_field) = self.apply_polydata_equal2_constraint(
                 ctx, node_index, field_expr_id, "struct field's",
                 PolyDataTypeIndex::Associated(field_index), 0,
                 field_node_index, 0, &mut poly_progress_section
             )?;
             if progress_field { self.queue_node(field_node_index); }
+        }
         // Now we do the same thing for the struct literal expression (the type
         // of the struct itself).
         let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(
-            ctx, node_index, node.expr_id, "struct literal's",
+            ctx, node_index, node_expr_id, "struct literal's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         // And the other way around: if any of our polymorphic variables are
         // more specific then they were before, then we forward that information
         // back to our struct/fields.
-        for (field_index, field_node_index) in rule.element_indices.iter().copied().enumerate() {
+        for (field_index, field_node_index) in element_indices_section.iter_copied().enumerate() {
             let progress_field = self.apply_polydata_polyvar_constraint(
                 ctx, node_index, PolyDataTypeIndex::Associated(field_index),
                 field_node_index, &poly_progress_section
             );
             if progress_field { self.queue_node(field_node_index); }
+        }
         let progress_literal_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned,
             node_index, &poly_progress_section
         );
         if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         element_indices_section.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(())
+    }
     fn progress_inference_rule_literal_enum(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_literal_enum();
         let node_expr_id = node.expr_id;
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
         // An enum literal type is simply, well, the enum's type. However, it
         // might still have polymorphic variables, hence the use of `PolyData`.
         let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(
-            ctx, node_index, node.expr_id, "enum literal's",
+            ctx, node_index, node_expr_id, "enum literal's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         let progress_literal_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned, node_index, &poly_progress_section
         );
         if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(());
+    }
     fn progress_inference_rule_literal_union(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let node_expr_id = node.expr_id;
         let rule = node.inference_rule.as_literal_union();
         // Infer type of any embedded values in the union variant. At the same
         // time progress the polymorphic variables associated with the union.
         let element_indices_section = self.index_buffer.start_section_initialized(&rule.element_indices);
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
-        for (embedded_index, embedded_node_index) in rule.element_indices.iter().copied().enumerate() {
+        for (embedded_index, embedded_node_index) in element_indices_section.iter_copied().enumerate() {
             let embedded_node_expr_id = self.infer_nodes[embedded_node_index].expr_id;
             let (_, progress_embedded) = self.apply_polydata_equal2_constraint(
                 ctx, node_index, embedded_node_expr_id, "embedded value's",
                 PolyDataTypeIndex::Associated(embedded_index), 0,
                 embedded_node_index, 0, &mut poly_progress_section
             )?;
             if progress_embedded { self.queue_node(embedded_node_index); }
+        }
         let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(
-            ctx, node_index, node.expr_id, "union's",
+            ctx, node_index, node_expr_id, "union's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         // Propagate progress in the polymorphic variables to the expressions
         // that constitute the union literal.
-        for (embedded_index, embedded_node_index) in rule.element_indices.iter().copied().enumerate() {
+        for (embedded_index, embedded_node_index) in element_indices_section.iter_copied().enumerate() {
             let progress_embedded = self.apply_polydata_polyvar_constraint(
                 ctx, node_index, PolyDataTypeIndex::Associated(embedded_index),
                 embedded_node_index, &poly_progress_section
             );
             if progress_embedded { self.queue_node(embedded_node_index); }
+        }
         let progress_literal_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned, node_index, &poly_progress_section
         );
         if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(());
+    }
     fn progress_inference_rule_literal_array(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_literal_array();
         // Apply equality rule to all of the elements that form the array
         let argument_node_indices = self.index_buffer.start_section_initialized(&rule.element_indices);
         let mut argument_progress_section = self.bool_buffer.start_section();
         self.apply_equal_n_constraint(ctx, node_index, &argument_node_indices, &mut argument_progress_section)?;
         debug_assert_eq!(argument_node_indices.len(), argument_progress_section.len());
         for argument_index in 0..argument_node_indices.len() {
             let argument_node_index = argument_node_indices[argument_index];
             let progress = argument_progress_section[argument_index];
             if progress { self.queue_node(argument_node_index); }
+        }
         // If elements are of type `T`, then the array is of type `Array<T>`, so:
         let mut progress_literal = self.apply_template_constraint(ctx, node_index, &ARRAY_TEMPLATE)?;
         if argument_node_indices.len() != 0 {
             let argument_node_index = argument_node_indices[0];
             let (progress_literal_inner, progress_argument) = self.apply_equal2_constraint(
                 ctx, node_index, node_index, 1, argument_node_index, 0
             )?;
             progress_literal = progress_literal || progress_literal_inner;
             // It is possible that the `Array<T>` has a more progress `T` then
             // the arguments. So in the case we progress our argument type we
             // simply queue this rule again
-            if progress_argument { self.queue_expr(node_index); }
+            if progress_argument { self.queue_node(node_index); }
+        }
         argument_node_indices.forget();
         argument_progress_section.forget();
         if progress_literal { self.queue_node_parent(node_index); }
         return Ok(());
+    }
     fn progress_inference_rule_literal_tuple(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_literal_tuple();
         let element_indices = self.index_buffer.start_section_initialized(&rule.element_indices);
         // Check if we need to apply the initial tuple template type. Note that
         // this is a hacky check.
         let num_tuple_elements = rule.element_indices.len();
         let mut template_type = Vec::with_capacity(num_tuple_elements + 1); // TODO: @performance
         template_type.push(InferenceTypePart::Tuple(num_tuple_elements as u32));
         for _ in 0..num_tuple_elements {
             template_type.push(InferenceTypePart::Unknown);
+        }
         let mut progress_literal = self.apply_template_constraint(ctx, node_index, &template_type)?;
         // Because of the (early returning error) check above, we're certain
         // that the tuple has the correct number of elements. Now match each
         // element expression type to the tuple subtype.
         let mut element_subtree_start_index = 1; // first element is InferenceTypePart::Tuple
         for element_node_index in element_indices.iter_copied() {
             let (progress_literal_element, progress_element) = self.apply_equal2_constraint(
                 ctx, node_index, node_index, element_subtree_start_index, element_node_index, 0
             )?;
             progress_literal = progress_literal || progress_literal_element;
             if progress_element {
                 self.queue_node(element_node_index);
+            }
             // Prepare for next element
             let node = &self.infer_nodes[node_index];
             let subtree_end_index = InferenceType::find_subtree_end_idx(&node.expr_type.parts, element_subtree_start_index);
             element_subtree_start_index = subtree_end_index;
+        }
-        debug_assert_eq!(element_subtree_end_index, node.expr_type.parts.len());
+        debug_assert_eq!(element_subtree_start_index, self.infer_nodes[node_index].expr_type.parts.len());
         if progress_literal { self.queue_node_parent(node_index); }
         element_indices.forget();
         return Ok(());
+    }
     fn progress_inference_rule_cast_expr(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_cast_expr();
         let subject_index = rule.subject_index;
         let subject = &self.infer_nodes[subject_index];
         // Make sure that both types are completely done. Note: a cast
         // expression cannot really infer anything between the subject and the
         // output type, we can only make sure that, at the end, the cast is
         // correct.
         if !node.expr_type.is_done || !subject.expr_type.is_done {
             return Ok(());
+        }
         // Both types are known, currently the only valid casts are bool,
         // integer and character casts.
         fn is_bool_int_or_char(parts: &[InferenceTypePart]) -> bool {
             let mut index = 0;
             while index < parts.len() {
                 let part = &parts[index];
                 if !part.is_marker() { break; }
                 index += 1;
+            }
             debug_assert!(index != parts.len());
             let part = &parts[index];
             if (
                 *part == InferenceTypePart::Bool ||
                 *part == InferenceTypePart::Character ||
                 part.is_concrete_integer()
             ) {
             if *part == InferenceTypePart::Bool || *part == InferenceTypePart::Character || part.is_concrete_integer() {
                 debug_assert!(index + 1 == parts.len()); // type is done, first part does not have children -> must be at end
                 return true;
             } else {
                 return false;
+            }
+        }
         let is_valid = if is_bool_int_or_char(&node.expr_type.parts) && is_bool_int_or_char(&subject.expr_type.parts) {
             true
         } else if InferenceType::check_subtrees(&node.expr_type.parts, 0, &subject.expr_type.parts, 0) {
             // again: check_subtrees is sufficient since both types are done
             true
         } else {
             false
         };
         if !is_valid {
             let cast_expr = &ctx.heap[node.expr_id];
             let subject_expr = &ctx.heap[subject.expr_id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, cast_expr.full_span(), "invalid casting operation"
             ).with_info_at_span(
                 &ctx.module.source, subject_expr.full_span(), format!(
+                &ctx.module().source, subject_expr.full_span(), format!(
                     "cannot cast the argument type '{}' to the type '{}'",
                     subject.expr_type.display_name(&ctx.heap),
                     node.expr_type.display_name(&ctx.heap)
+                )
             ));
+        }
         return Ok(())
+    }
     fn progress_inference_rule_call_expr(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let node_expr_id = node.expr_id;
         let rule = node.inference_rule.as_call_expr();
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
         let argument_node_indices = self.index_buffer.start_section_initialized(&rule.argument_indices);
         // Perform inference on arguments to function, while trying to figure
         // out the polymorphic variables
         for (argument_index, argument_node_index) in argument_node_indices.iter_copied().enumerate() {
             let argument_expr_id = self.infer_nodes[argument_node_index].expr_id;
             let (_, progress_argument) = self.apply_polydata_equal2_constraint(
                 ctx, node_index, argument_expr_id, "argument's",
                 PolyDataTypeIndex::Associated(argument_index), 0,
                 argument_node_index, 0, &mut poly_progress_section
             )?;
             if progress_argument { self.queue_node(argument_node_index); }
+        }
         // Same for the return type.
         let call_expr_id = node.expr_id;
         let (_, progress_call_1) = self.apply_polydata_equal2_constraint(
-            ctx, node_index, call_expr_id, "return",
+            ctx, node_index, node_expr_id, "return",
             PolyDataTypeIndex::Returned, 0,
             node_index, 0, &mut poly_progress_section
         )?;
         // We will now apply any progression in the polymorphic variable type
         // back to the arguments.
         for (argument_index, argument_node_index) in argument_node_indices.iter_copied().enumerate() {
             let progress_argument = self.apply_polydata_polyvar_constraint(
                 ctx, node_index, PolyDataTypeIndex::Associated(argument_index),
                 argument_node_index, &poly_progress_section
             );
             if progress_argument { self.queue_node(argument_node_index); }
+        }
         // And back to the return type.
         let progress_call_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned,
             node_index, &poly_progress_section
         );
         if progress_call_1 || progress_call_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         argument_node_indices.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(())
+    }
     fn progress_inference_rule_variable_expr(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &mut self.infer_nodes[node_index];
         let rule = node.inference_rule.as_variable_expr();
         let var_data_index = rule.var_data_index;
         let var_data = &mut self.var_data[var_data_index];
         let var_data = &mut self.var_data[var_data_index];
         // Apply inference to the shared variable type and the expression type
         let shared_type: *mut _ = &mut var_data.var_type;
         let expr_type: *mut _ = &mut node.expr_type;
         let inference_result = unsafe {
             // safety: vectors exist in different storage vectors, so cannot alias
             InferenceType::infer_subtrees_for_both_types(shared_type, 0, expr_type, 0)
         };
         if inference_result == DualInferenceResult::Incompatible {
             return Err(self.construct_variable_type_error(ctx, node_index));
+        }
         let progress_var_data = inference_result.modified_lhs();
         let progress_expr = inference_result.modified_rhs();
         if progress_var_data {
             // We progressed the type of the shared variable, so propagate this
             // to all associated variable expressions (and relatived variables).
             for other_node_index in var_data.used_at.iter().copied() {
                 if other_node_index != node_index {
-                    self.queue_node(other_node_index);
+                    self.node_queued.push_back(other_node_index);
+                }
+            }
             if let Some(linked_var_data_index) = var_data.linked_var {
                 // Only perform one-way inference, progressing the linked
                 // variable.
                 // note: because this "linking" is used only for channels, we
                 // will start inference one level below the top-level in the
                 // type tree (i.e. ensure `T` in `in<T>` and `out<T>` is equal).
                 debug_assert!(
                     var_data.var_type.parts[0] == InferenceTypePart::Input ||
                     var_data.var_type.parts[0] == InferenceTypePart::Output
                 );
                 let this_var_type: *const _ = &var_data.var_type;
                 let linked_var_data = &mut self.var_data[linked_var_data_index];
                 debug_assert!(
                     linked_var_data.var_type.parts[0] == InferenceTypePart::Input ||
                     linked_var_data.var_type.parts[0] == InferenceTypePart::Output
                 );
                 // safety: by construction var_data_index and linked_var_data_index cannot be the
                 // same, hence we're not aliasing here.
                 let inference_result = InferenceType::infer_subtree_for_single_type(
                     &mut linked_var_data.var_type, 1,
                     unsafe{ &(*this_var_type).parts }, 1, false
                 );
                 match inference_result {
                     SingleInferenceResult::Modified => {
                         for used_at in linked_var_data.used_at.iter().copied() {
-                            self.queue_node(used_at);
+                            self.node_queued.push_back(used_at);
+                        }
                     },
                     SingleInferenceResult::Unmodified => {},
                     SingleInferenceResult::Incompatible => {
                         let var_data_this = &self.var_data[var_data_index];
                         let var_decl_this = &ctx.heap[var_data_this.var_id];
                         let var_data_linked = &self.var_data[linked_var_data_index];
                         let var_decl_linked = &ctx.heap[var_data_linked.var_id];
                         return Err(ParseError::new_error_at_span(
                             &ctx.module().source, var_decl_this.identifier.span, format!(
                                 "conflicting types for this channel, this port has type '{}'",
                                 var_data_this.var_type.display_name(&ctx.heap)
+                            )
                         ).with_info_at_span(
                             &ctx.module().source, var_decl_linked.identifier.span, format!(
                                 "while this port has type '{}'",
                                 var_data_linked.var_type.display_name(&ctx.heap)
+                            )
                         ));
+                    }
+                }
+            }
+        }
         if progress_expr { self.queue_node_parent(node_index); }
         return Ok(());
+    }
     fn progress_template(&mut self, ctx: &Ctx, node_index: InferNodeIndex, application: InferenceRuleTemplateApplication, template: &[InferenceTypePart]) -> Result<bool, ParseError> {
         use InferenceRuleTemplateApplication as TA;
         match application {
             TA::None => Ok(false),
             TA::Template => self.apply_template_constraint(ctx, node_index, template),
             TA::Forced => self.apply_forced_constraint(ctx, node_index, template),
+        }
+    }
     fn queue_node_parent(&mut self, node_index: InferNodeIndex) {
         let node = &self.infer_nodes[node_index];
         if let Some(parent_node_index) = node.parent_index {
             self.node_queued.push_back(parent_node_index);
+        }
+    }
     #[inline]
     fn queue_node(&mut self, node_index: InferNodeIndex) {
         self.node_queued.push_back(node_index);
+    }
     /// Returns whether the type is certainly a string (true, false), certainly
     /// not a string (false, true), or still unknown (false, false).
     fn type_is_certainly_or_certainly_not_string(&self, node_index: InferNodeIndex) -> (bool, bool) {
         let expr_type = &self.infer_nodes[node_index].expr_type;
         if expr_type.is_done {
             if expr_type.parts[0] == InferenceTypePart::String {
         println!("DEBUG: Running test on {:?}", expr_type.parts);
         let mut part_index = 0;
         while part_index < expr_type.parts.len() {
             let part = &expr_type.parts[part_index];
             if part.is_marker() { continue; }
             if !part.is_concrete() { break; }
             if *part == InferenceTypePart::String {
                 // First part is a string
                 return (true, false);
             } else {
                 return (false, true);
+            }
+        }
         // If here then first non-marker type is not concrete
         if part_index == expr_type.parts.len() {
             // nothing known at all
             return (false, false);
+        }
         // Special case: array-like where its argument is not a character
         if part_index + 1 < expr_type.parts.len() {
             if expr_type.parts[part_index] == InferenceTypePart::ArrayLike && expr_type.parts[part_index + 1] != InferenceTypePart::Character {
                 return (false, true);
+            }
+        }
         (false, false)
+    }
     /// Applies a template type constraint: the type associated with the
     /// supplied expression will be molded into the provided `template`. But
     /// will be considered valid if the template could've been molded into the
     /// expression type as well. Hence the template may be fully specified (e.g.
     /// a bool) or contain "inference" variables (e.g. an array of T)
     fn apply_template_constraint(
         &mut self, ctx: &Ctx, node_index: InferNodeIndex, template: &[InferenceTypePart]
     ) -> Result<bool, ParseError> {
         let expr_type = &mut self.infer_nodes[node_index].expr_type;
         match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0, false) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(
                 self.construct_template_type_error(ctx, node_index, template)
+            )
+        }
+    }
     /// Applies a forced constraint: the supplied expression's type MUST be
     /// inferred from the template, the other way around is considered invalid.
     fn apply_forced_constraint(
         &mut self, ctx: &Ctx, node_index: InferNodeIndex, template: &[InferenceTypePart]
     ) -> Result<bool, ParseError> {
         let expr_type = &mut self.infer_nodes[node_index].expr_type;
         match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0, true) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(
                 self.construct_template_type_error(ctx, node_index, template)
+            )
+        }
+    }
     /// Applies a type constraint that expects the two provided types to be
     /// equal. We attempt to make progress in inferring the types. If the call
     /// is successful then the composition of all types are made equal.
     /// The "parent" `expr_id` is provided to construct errors.
     fn apply_equal2_constraint(
         &mut self, ctx: &Ctx, node_index: InferNodeIndex,
         arg1_index: InferNodeIndex, arg1_start_idx: usize,
         arg2_index: InferNodeIndex, arg2_start_idx: usize
     ) -> Result<(bool, bool), ParseError> {
         let arg1_type: *mut _ = &mut self.infer_nodes[arg1_index].expr_type;
         let arg2_type: *mut _ = &mut self.infer_nodes[arg2_index].expr_type;
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             arg1_type, arg1_start_idx,
             arg2_type, arg2_start_idx
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, node_index, arg1_index, arg2_index));
+        }
         Ok((infer_res.modified_lhs(), infer_res.modified_rhs()))
+    }
     /// Applies an equal2 constraint between a member of the `PolyData` struct,
     /// and another inferred type. If any progress is made in the `PolyData`
     /// struct then the affected polymorphic variables are updated as well.
     ///
     /// Because a lot of types/expressions are involved in polymorphic typFe
     /// inference, some explanation: "outer_node" refers to the main expression
     /// that is the root cause of type inference (e.g. a struct literal
     /// expression, or a tuple member select expression). Associated with that
     /// outer node is `PolyData`, so that is what the "poly_data" variables
     /// are referring to. We are applying equality between a "poly_data" type
     /// and an associated expression (not necessarily the "outer_node", e.g.
     /// the expression that constructs the value of a struct field). Hence the
     /// "associated" variables.
     ///
     /// Finally, when an error occurs we'll first show the outer node's
     /// location. As info, the `error_location_expr_id` span is shown,
     /// indicating that the "`error_type_name` type has been resolved to
     /// `outer_node_type`, but this expression has been resolved to
     /// `associated_node_type`".
     fn apply_polydata_equal2_constraint(
         &mut self, ctx: &Ctx,
         outer_node_index: InferNodeIndex, error_location_expr_id: ExpressionId, error_type_name: &str,
         poly_data_type_index: PolyDataTypeIndex, poly_data_start_index: usize,
         associated_node_index: InferNodeIndex, associated_node_start_index: usize,
         poly_progress_section: &mut ScopedSection<u32>,
     ) -> Result<(bool, bool), ParseError> {
         let poly_data_index = self.infer_nodes[outer_node_index].poly_data_index;
         let poly_data_type = self.poly_data[poly_data_index].get_type_mut(poly_data_type_index);
         let poly_data = &mut self.poly_data[poly_data_index as usize];
         let poly_data_type = poly_data.expr_types.get_type_mut(poly_data_type_index);
         let associated_type: *mut _ = &mut self.infer_nodes[associated_node_index].expr_type;
         let inference_result = unsafe{
             // Safety: pointers originate from different vectors, so cannot
             // alias.
             let poly_data_type: *mut _ = poly_data_type;
             InferenceType::infer_subtrees_for_both_types(
                 poly_data_type, poly_data_start_index,
                 associated_type, associated_node_start_index
+            )
         };
         let modified_poly_data = inference_result.modified_lhs();
         let modified_associated = inference_result.modified_rhs();
         if inference_result == DualInferenceResult::Incompatible {
             let outer_node_expr_id = self.infer_nodes[outer_node_index].expr_id;
             let outer_node_span = ctx.heap[outer_node_expr_id].full_span();
             let detailed_span = ctx.heap[error_location_expr_id].full_span();
             let outer_node_type = poly_data_type.display_name(&ctx.heap);
             let associated_type = self.infer_nodes[associated_node_index].expr_type.display_name(&ctx.heap);
             let source = &ctx.module().source;
             return Err(ParseError::new_error_str_at_span(
                 source, outer_node_span, "failed to resolve the types of this expression"
             ).with_info_str_at_span(
                 source, detailed_span, &format!(
                     "because the {} type has been resolved to '{}', but this expression has been resolved to '{}'",
                     error_type_name, outer_node_type, associated_type
+                )
             ));
+        }
         if modified_poly_data {
             debug_assert!(poly_data_type.has_marker);
             // Go through markers for polymorphic variables and use the
             // (hopefully) more specific types to update their representation
             // in the PolyData struct
             for (poly_var_index, poly_var_section) in poly_data_type.marker_iter() {
-                let poly_var_type = &mut self.poly_data[poly_data_index].poly_vars[poly_var_index as usize];
                 let poly_var_type = &mut poly_data.poly_vars[poly_var_index as usize];
                 match InferenceType::infer_subtree_for_single_type(poly_var_type, 0, poly_var_section, 0, false) {
                     SingleInferenceResult::Modified => {
                         poly_progress_section.push_unique(poly_var_index);
                     },
                     SingleInferenceResult::Unmodified => {
                         // nothing to do
                     },
                     SingleInferenceResult::Incompatible => {
                         return Err(Self::construct_poly_arg_error(
                             ctx, &self.poly_data[poly_data_index],
+                            ctx, &self.poly_data[poly_data_index as usize],
                             self.infer_nodes[outer_node_index].expr_id
                         ));
+                    }
+                }
+            }
+        }
         return Ok((modified_poly_data, modified_associated));
+    }
     /// After calling `apply_polydata_equal2_constraint` on several expressions
     /// that are associated with some kind of polymorphic expression, several of
     /// the polymorphic variables might have been inferred to more specific
     /// types than before.
     ///
     /// At this point one should call this function to apply the progress in
     /// these polymorphic variables back onto the types that are functions of
     /// these polymorphic variables.
     ///
     /// An example: a struct literal with a polymorphic variable `T` may have
     /// two fields `foo` and `bar` each with different types that are a function
     /// of the polymorhic variable `T`. If the expressions constructing the
     /// value for the field `foo` causes the type `T` to progress, then we can
     /// also progress the type of the expression that constructs `bar`.
     ///
     /// And so we have `outer_node_index` + `poly_data_type_index` pointing to
     /// the appropriate type in the `PolyData` struct. Which will be updated
     /// first using the polymorphic variables. If we happen to have updated that
     /// type, then we should also progress the associated expression, hence the
     /// `associated_node_index`.
     fn apply_polydata_polyvar_constraint(
         &mut self, ctx: &Ctx,
         outer_node_index: InferNodeIndex, poly_data_type_index: PolyDataTypeIndex,
         associated_node_index: InferNodeIndex, poly_progress_section: &ScopedSection<u32>
     ) -> bool {
         let poly_data_index = self.infer_nodes[outer_node_index].poly_data_index;
         let poly_data = &mut self.poly_data[poly_data_index];
+        let poly_data = &mut self.poly_data[poly_data_index as usize];
         // Early exit, most common case (literals or functions calls which are
         // actually not polymorphic)
         if !poly_data.first_rule_application && poly_progress_section.len() == 0 {
             return false;
+        }
         // safety: we're borrowing from two distinct fields, so should be fine
         let poly_data_type = poly_data.get_type_mut(poly_data_type_index);
+        let poly_data_type = poly_data.expr_types.get_type_mut(poly_data_type_index);
         let mut last_start_index = 0;
         let mut modified_poly_type = false;
         while let Some((poly_var_index, poly_var_start_index)) = poly_data_type.find_marker(last_start_index) {
             let poly_var_end_index = InferenceType::find_subtree_end_idx(&poly_data_type.parts, poly_var_start_index);
             if poly_data.first_rule_application || poly_progress_section.contains(&poly_var_index) {
                 // We have updated this polymorphic variable, so try updating it
                 // in the PolyData type
                 let modified_in_poly_data = match InferenceType::infer_subtree_for_single_type(
                     poly_data_type, poly_var_start_index, &poly_data.poly_vars[poly_var_index as usize].parts, 0, false
                 ) {
                     SingleInferenceResult::Modified => true,
                     SingleInferenceResult::Unmodified => false,
                     SingleInferenceResult::Incompatible => {
                         // practically impossible: before calling this function we gather all the
                         // data on the polymorphic variables from the associated expressions. So if
                         // the polymorphic variables in those expressions were not mutually
                         // compatible, we must have encountered that error already.
                         unreachable!()
                     },
                 };
                 modified_poly_type = modified_poly_type || modified_in_poly_data;
+            }
             last_start_index = poly_var_end_index;
+        }
         if modified_poly_type {
             let associated_type = &mut self.infer_nodes[associated_node_index].expr_type;
             match InferenceType::infer_subtree_for_single_type(
                 associated_type, 0, &poly_data_type.parts, 0, true
             ) {
                 SingleInferenceResult::Modified => return true,
                 SingleInferenceResult::Unmodified => return false,
                 SingleInferenceResult::Incompatible => unreachable!(), // same as above
+            }
         } else {
             // Did not update associated type
             return false;
+        }
+    }
     /// Should be called after completing one full round of applying polydata
     /// constraints.
     fn finish_polydata_constraint(&mut self, outer_node_index: InferNodeIndex) {
         let poly_data_index = self.infer_nodes[outer_node_index].poly_data_index;
         let poly_data = &mut self.poly_data[poly_data_index];
+        let poly_data = &mut self.poly_data[poly_data_index as usize];
         poly_data.first_rule_application = false;
+    }
     /// Applies a type constraint that expects all three provided types to be
     /// equal. In case we can make progress in inferring the types then we
     /// attempt to do so. If the call is successful then the composition of all
     /// types is made equal.
     fn apply_equal3_constraint(
         &mut self, ctx: &Ctx, node_index: InferNodeIndex,
         arg1_index: InferNodeIndex, arg2_index: InferNodeIndex,
         start_idx: usize
     ) -> Result<(bool, bool, bool), ParseError> {
         // Safety: all indices are unique
         //         containers may not be modified
         let expr_type: *mut _ = &mut self.infer_nodes[node_index].expr_type;
         let arg1_type: *mut _ = &mut self.infer_nodes[arg1_index].expr_type;
         let arg2_type: *mut _ = &mut self.infer_nodes[arg2_index].expr_type;
         let expr_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(expr_type, start_idx, arg1_type, start_idx)
         };
         if expr_res == DualInferenceResult::Incompatible {
             return Err(self.construct_expr_type_error(ctx, node_index, arg1_index));
+        }
         let args_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(arg1_type, start_idx, arg2_type, start_idx) };
         if args_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, node_index, arg1_index, arg2_index));
+        }
         // If all types are compatible, but the second call caused the arg1_type
         // to be expanded, then we must also assign this to expr_type.
         let mut progress_expr = expr_res.modified_lhs();
         let mut progress_arg1 = expr_res.modified_rhs();
         let progress_arg2 = args_res.modified_rhs();
         if args_res.modified_lhs() {
             unsafe {
                 let end_idx = InferenceType::find_subtree_end_idx(&(*arg2_type).parts, start_idx);
                 let subtree = &((*arg2_type).parts[start_idx..end_idx]);
                 (*expr_type).replace_subtree(start_idx, subtree);
+            }
             progress_expr = true;
             progress_arg1 = true;
+        }
         Ok((progress_expr, progress_arg1, progress_arg2))
@@ @@ -3374,376 +3419,386 @@ impl PassTyping { @@
         let inference_type = match expr.parent() {
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::Memory(_) | 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 {
                     let returned = &ctx.heap[func_id].return_type;
                     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_index = self.infer_nodes.len() as InferNodeIndex;
         self.infer_nodes.push(InferenceNode {
             expr_type: inference_type,
             expr_id,
             inference_rule: InferenceRule::Noop,
             parent_index: self.parent_index,
             field_or_monomorph_index: -1,
-            poly_data_index: PolyDataIndex::MAX,
+            poly_data_index: -1,
             type_id: TypeId::new_invalid(),
         });
         return Ok(infer_index);
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) -> PolyDataIndex {
         // 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];
         // 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));
+        }
         // Handle the arguments and return types
         let definition = &ctx.heap[call.definition];
         let (parameters, returned) = match definition {
             Definition::Component(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, None)
             },
             Definition::Function(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, Some(&definition.return_type))
             },
             Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => {
                 unreachable!("insert_initial_call_polymorph data for non-procedure type");
             },
         };
         let mut parameter_types = Vec::with_capacity(parameters.len());
         for parameter_id in parameters.clone().into_iter() { // TODO: @Performance @Now
             let param = &ctx.heap[parameter_id];
             parameter_types.push(self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, false));
+        }
         let return_type = match returned {
             None => {
                 // Component, so returns a "Void"
                 InferenceType::new(false, true, vec![InferenceTypePart::Void])
             },
             Some(returned) => {
                 self.determine_inference_type_from_parser_type_elements(&returned.elements, false)
+            }
         };
         let extra_data_idx = self.poly_data.len() as PolyDataIndex;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: call.definition,
             poly_vars: poly_args,
             associated: parameter_types,
             returned: return_type
             expr_types: PolyDataTypes {
                 associated: parameter_types,
                 returned: return_type
+            }
         });
         return extra_data_idx
+    }
     fn insert_initial_struct_polymorph_data(
         &mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId,
     ) -> PolyDataIndex {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_struct();
         // Handle polymorphic arguments
         let num_embedded = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_embedded);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle parser types on struct definition
         let defined_type = ctx.types.get_base_definition(&literal.definition).unwrap();
         let struct_type = defined_type.definition.as_struct();
         debug_assert_eq!(poly_args.len(), defined_type.poly_vars.len());
         // Note: programmer is capable of specifying fields in a struct literal
         // in a different order than on the definition. We take the literal-
         // specified order to be leading.
         let mut embedded_types = Vec::with_capacity(struct_type.fields.len());
         for lit_field in literal.fields.iter() {
             let def_field = &struct_type.fields[lit_field.field_idx];
             let inference_type = self.determine_inference_type_from_parser_type_elements(&def_field.parser_type.elements, false);
             embedded_types.push(inference_type);
+        }
         // Return type is the struct type itself, with the appropriate
         // polymorphic variables. So:
         // - 1 part for definition
         // - N_poly_arg marker parts for each polymorphic argument
         // - all the parts for the currently known polymorphic arguments
         let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(literal.definition, poly_args.len() as u32));
         let mut return_type_done = true;
         for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { return_type_done = false; }
             parts.push(ITP::Marker(poly_var_idx as u32));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts.len(), parts_reserved);
         let return_type = InferenceType::new(!poly_args.is_empty(), return_type_done, parts);
         let extra_data_index = self.poly_data.len() as PolyDataIndex;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: literal.definition,
             poly_vars: poly_args,
             associated: embedded_types,
             returned: return_type,
             expr_types: PolyDataTypes {
                 associated: embedded_types,
                 returned: return_type,
             },
         });
         return extra_data_index
+    }
     /// Inserts the extra polymorphic data struct for enum expressions. These
     /// can never be determined from the enum itself, but may be inferred from
     /// the use of the enum.
     fn insert_initial_enum_polymorph_data(
         &mut self, ctx: &Ctx, lit_id: LiteralExpressionId
     ) -> PolyDataIndex {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_enum();
         // Handle polymorphic arguments to the enum
         let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle enum type itself
         let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(literal.definition, poly_args.len() as u32));
         let mut enum_type_done = true;
         for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { enum_type_done = false; }
             parts.push(ITP::Marker(poly_var_idx as u32));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts.len(), parts_reserved);
         let enum_type = InferenceType::new(!poly_args.is_empty(), enum_type_done, parts);
         let extra_data_index = self.poly_data.len() as PolyDataIndex;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: literal.definition,
             poly_vars: poly_args,
             associated: Vec::new(),
             returned: enum_type,
             expr_types: PolyDataTypes {
                 associated: Vec::new(),
                 returned: enum_type,
             },
         });
         return extra_data_index;
+    }
     /// Inserts the extra polymorphic data struct for unions. The polymorphic
     /// arguments may be partially determined from embedded values in the union.
     fn insert_initial_union_polymorph_data(
         &mut self, ctx: &Ctx, lit_id: LiteralExpressionId
     ) -> PolyDataIndex {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_union();
         // Construct the polymorphic variables
         let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle any of the embedded values in the variant, if specified
         let definition_id = literal.definition;
         let type_definition = ctx.types.get_base_definition(&definition_id).unwrap();
         let union_definition = type_definition.definition.as_union();
         debug_assert_eq!(poly_args.len(), type_definition.poly_vars.len());
         let variant_definition = &union_definition.variants[literal.variant_idx];
         debug_assert_eq!(variant_definition.embedded.len(), literal.values.len());
         let mut embedded = Vec::with_capacity(variant_definition.embedded.len());
         for embedded_parser_type in &variant_definition.embedded {
             let inference_type = self.determine_inference_type_from_parser_type_elements(&embedded_parser_type.elements, false);
             embedded.push(inference_type);
+        }
         // Handle the type of the union itself
         let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(definition_id, poly_args.len() as u32));
         let mut union_type_done = true;
         for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { union_type_done = false; }
             parts.push(ITP::Marker(poly_var_idx as u32));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts_reserved, parts.len());
         let union_type = InferenceType::new(!poly_args.is_empty(), union_type_done, parts);
         let extra_data_index = self.poly_data.len();
+        let extra_data_index = self.poly_data.len() as isize;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: literal.definition,
             poly_vars: poly_args,
             associated: embedded,
             returned: union_type
             expr_types: PolyDataTypes {
                 associated: embedded,
                 returned: union_type,
             },
         });
         return extra_data_index;
+    }
     /// Inserts the extra polymorphic data struct. Assumes that the select
     /// expression's referenced (definition_id, field_idx) has been resolved.
     fn insert_initial_select_polymorph_data(
         &mut self, ctx: &Ctx, node_index: InferNodeIndex, struct_def_id: DefinitionId
     ) -> PolyDataIndex {
         use InferenceTypePart as ITP;
         let definition = ctx.heap[struct_def_id].as_struct();
         let node = &self.infer_nodes[node_index];
         let field_index = node.field_or_monomorph_index as usize;
         // Generate initial polyvar types and struct type
         // TODO: @Performance: we can immediately set the polyvars of the subject's struct type
         let num_poly_vars = definition.poly_vars.len();
         let mut poly_vars = Vec::with_capacity(num_poly_vars);
         let struct_parts_reserved = 1 + 2 * num_poly_vars;
         let mut struct_parts = Vec::with_capacity(struct_parts_reserved);
         struct_parts.push(ITP::Instance(struct_def_id, num_poly_vars as u32));
         for poly_idx in 0..num_poly_vars {
             poly_vars.push(InferenceType::new(true, false, vec![
                 ITP::Marker(poly_idx as u32), ITP::Unknown,
             ]));
             struct_parts.push(ITP::Marker(poly_idx as u32));
             struct_parts.push(ITP::Unknown);
+        }
         debug_assert_eq!(struct_parts.len(), struct_parts_reserved);
         // Generate initial field type
         let field_type = self.determine_inference_type_from_parser_type_elements(&definition.fields[field_index].parser_type.elements, false);
         let extra_data_index = self.poly_data.len() as PolyDataIndex;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: struct_def_id,
             poly_vars,
             associated: vec![InferenceType::new(num_poly_vars != 0, num_poly_vars == 0, struct_parts)],
             returned: field_type
             expr_types: PolyDataTypes {
                 associated: vec![InferenceType::new(num_poly_vars != 0, num_poly_vars == 0, struct_parts)],
                 returned: field_type,
             },
         });
         return extra_data_index;
+    }
     /// Determines the initial InferenceType from the provided ParserType. This
     /// may be called with two kinds of intentions:
     /// 1. To resolve a ParserType within the body of a function, or on
     ///     polymorphic arguments to calls/instantiations within that body. This
     ///     means that the polymorphic variables are known and can be replaced
     ///     with the monomorph we're instantiating.
     /// 2. To resolve a ParserType on a called function's definition or on
     ///     an instantiated datatype's members. This means that the polymorphic
     ///     arguments inside those ParserTypes refer to the polymorphic
     ///     variables in the called/instantiated type's definition.
     /// In the second case we place InferenceTypePart::Marker instances such
     /// that we can perform type inference on the polymorphic variables.
     fn determine_inference_type_from_parser_type_elements(
         &mut self, elements: &[ParserTypeElement],
         use_definitions_known_poly_args: bool
     ) -> InferenceType {
         use ParserTypeVariant as PTV;
         use InferenceTypePart as ITP;
         let mut infer_type = Vec::with_capacity(elements.len());
         let mut has_inferred = false;
         let mut has_markers = false;
         for element in elements {
             match &element.variant {
                 // Compiler-only types
                 PTV::Void => { infer_type.push(ITP::Void); },
                 PTV::InputOrOutput => { infer_type.push(ITP::PortLike); has_inferred = true },
                 PTV::ArrayLike => { infer_type.push(ITP::ArrayLike); has_inferred = true },
                 PTV::IntegerLike => { infer_type.push(ITP::IntegerLike); has_inferred = true },
                 // Builtins
                 PTV::Message => {
                     // TODO: @types Remove the Message -> Byte hack at some point...
                     infer_type.push(ITP::Message);
                     infer_type.push(ITP::UInt8);
                 },
                 PTV::Bool => { infer_type.push(ITP::Bool); },
                 PTV::UInt8 => { infer_type.push(ITP::UInt8); },
                 PTV::UInt16 => { infer_type.push(ITP::UInt16); },
                 PTV::UInt32 => { infer_type.push(ITP::UInt32); },
                 PTV::UInt64 => { infer_type.push(ITP::UInt64); },
                 PTV::SInt8 => { infer_type.push(ITP::SInt8); },
                 PTV::SInt16 => { infer_type.push(ITP::SInt16); },
@@ @@ -4015,183 +4070,183 @@ impl PassTyping { @@
                     let (poly_var, struct_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);
                     let field_name = match &expr.kind {
                         SelectKind::StructField(v) => v,
                         SelectKind::TupleMember(_) => unreachable!(), // because we're constructing a polymorph error, and tuple access does not deal with polymorphs
                     };
                     return ParseError::new_error_at_span(
                         &ctx.module().source, expr.full_span, format!(
                             "Conflicting type for polymorphic variable '{}' while accessing field '{}' of '{}'",
                             poly_var, field_name.value.as_str(), struct_name
+                        )
+                    )
+                }
                 _ => unreachable!("called construct_poly_arg_error without an expected expression, got: {:?}", expr)
+            }
+        }
         // Actual checking
         let expr = &ctx.heap[expr_id];
         let (expr_args, expr_return_name) = match expr {
             Expression::Call(expr) =>
+                (
                     expr.arguments.clone(),
                     "return type"
                 ),
             Expression::Literal(expr) => {
                 let expressions = match &expr.value {
                     Literal::Struct(v) => v.fields.iter()
                         .map(|f| f.value)
                         .collect(),
                     Literal::Enum(_) => Vec::new(),
                     Literal::Union(v) => v.values.clone(),
                     _ => unreachable!()
                 };
                 ( expressions, "literal" )
             },
             Expression::Select(expr) =>
                 // Select expression uses the polymorphic variables of the
                 // struct it is accessing, so get the subject expression.
+                (
                     vec![expr.subject],
                     "selected field"
                 ),
             _ => unreachable!(),
         };
         // - check return type with itself
         if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(
             &poly_data.returned, &poly_data.returned
+            &poly_data.expr_types.returned, &poly_data.expr_types.returned
         ) {
             return construct_main_error(ctx, poly_data, poly_idx, expr)
                 .with_info_at_span(
                     &ctx.module().source, expr.full_span(), format!(
                         "The {} inferred the conflicting types '{}' and '{}'",
                         expr_return_name,
                         InferenceType::partial_display_name(&ctx.heap, section_a),
                         InferenceType::partial_display_name(&ctx.heap, section_b)
+                    )
                 );
+        }
         // - check arguments with each other argument and with return type
         for (arg_a_idx, arg_a) in poly_data.associated.iter().enumerate() {
             for (arg_b_idx, arg_b) in poly_data.associated.iter().enumerate() {
         for (arg_a_idx, arg_a) in poly_data.expr_types.associated.iter().enumerate() {
             for (arg_b_idx, arg_b) in poly_data.expr_types.associated.iter().enumerate() {
                 if arg_b_idx > arg_a_idx {
                     break;
+                }
                 if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&arg_a, &arg_b) {
                     let error = construct_main_error(ctx, poly_data, poly_idx, expr);
                     if arg_a_idx == arg_b_idx {
                         // Same argument
                         let arg = &ctx.heap[expr_args[arg_a_idx]];
                         return error.with_info_at_span(
                             &ctx.module().source, arg.full_span(), format!(
                                 "This argument inferred the conflicting types '{}' and '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a),
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
                         );
                     } else {
                         let arg_a = &ctx.heap[expr_args[arg_a_idx]];
                         let arg_b = &ctx.heap[expr_args[arg_b_idx]];
                         return error.with_info_at_span(
                             &ctx.module().source, arg_a.full_span(), format!(
                                 "This argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a)
+                            )
                         ).with_info_at_span(
                             &ctx.module().source, arg_b.full_span(), format!(
                                 "While this argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
+                        )
+                    }
+                }
+            }
             // Check with return type
             if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &poly_data.returned) {
+            if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &poly_data.expr_types.returned) {
                 let arg = &ctx.heap[expr_args[arg_a_idx]];
                 return construct_main_error(ctx, poly_data, poly_idx, expr)
                     .with_info_at_span(
                         &ctx.module().source, arg.full_span(), format!(
                             "This argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, section_arg)
+                        )
+                    )
                     .with_info_at_span(
                         &ctx.module().source, expr.full_span(), format!(
                             "While the {} inferred it to '{}'",
                             expr_return_name,
                             InferenceType::partial_display_name(&ctx.heap, section_ret)
+                        )
                     );
+            }
+        }
         // Now check against the explicitly specified polymorphic variables (if
         // any).
         for (arg_idx, arg) in poly_data.associated.iter().enumerate() {
+        for (arg_idx, arg) in poly_data.expr_types.associated.iter().enumerate() {
             if let Some((poly_idx, poly_section, arg_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, arg) {
                 let arg = &ctx.heap[expr_args[arg_idx]];
                 return construct_main_error(ctx, poly_data, poly_idx, expr)
                     .with_info_at_span(
                         &ctx.module().source, arg.full_span(), format!(
                             "The polymorphic variable has type '{}' (which might have been partially inferred) while the argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, poly_section),
                             InferenceType::partial_display_name(&ctx.heap, arg_section)
+                        )
                     );
+            }
+        }
         if let Some((poly_idx, poly_section, ret_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, &poly_data.returned) {
+        if let Some((poly_idx, poly_section, ret_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, &poly_data.expr_types.returned) {
             return construct_main_error(ctx, poly_data, poly_idx, expr)
                 .with_info_at_span(
                     &ctx.module().source, expr.full_span(), format!(
                         "The polymorphic variable has type '{}' (which might have been partially inferred) while the {} inferred it to '{}'",
                         InferenceType::partial_display_name(&ctx.heap, poly_section),
                         expr_return_name,
                         InferenceType::partial_display_name(&ctx.heap, ret_section)
+                    )
+                )
+        }
         unreachable!("construct_poly_arg_error without actual error found?")
+    }
+}
 fn get_tuple_size_from_inference_type(inference_type: &InferenceType) -> Result<Option<u32>, ()> {
     for part in &inference_type.parts {
         if part.is_marker() { continue; }
         if !part.is_concrete() { break; }
         if let InferenceTypePart::Tuple(size) = part {
             return Ok(Some(*size));
         } else {
             return Err(()); // not a tuple!
+        }
+    }
     return Ok(None);
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::protocol::arena::Id;
     use InferenceTypePart as ITP;
     use InferenceType as IT;
     #[test]
     fn test_single_part_inference() {
         // lhs argument inferred from rhs
         let pairs = [
             (ITP::NumberLike, ITP::UInt8),
             (ITP::IntegerLike, ITP::SInt32),
             (ITP::Unknown, ITP::UInt64),
             (ITP::Unknown, ITP::Bool)
         ];
         for (lhs, rhs) in pairs.iter() {
             // Using infer-both

src/protocol/tests/parser_validation.rs

➞

Show inline comments

@@ @@ -302,97 +302,97 @@ fn test_incorrect_union_instance() { @@
         union Foo{ A(s32), A(s8) }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A(s8)")
         .assert_msg_has(0, "union variant is defined more than once")
         .assert_occurs_at(1, "A(s32)")
         .assert_msg_has(1, "other union variant");
     });
     Tester::new_single_source_expect_err(
         "undefined variant",
+        "
         union Silly{ Thing(s8) }
         func bar() -> Silly { return Silly::Undefined(5); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'Undefined' does not exist on the union 'Silly'");
     });
     Tester::new_single_source_expect_err(
         "using tag instead of embedded",
+        "
         union Foo{ A(s32) }
         func bar() -> Foo { return Foo::A; }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'A' of union 'Foo' expects 1 embedded values, but 0 were");
     });
     Tester::new_single_source_expect_err(
         "using embedded instead of tag",
+        "
         union Foo{ A }
         func bar() -> Foo { return Foo::A(3); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "The variant 'A' of union 'Foo' expects 0");
     });
     Tester::new_single_source_expect_err(
         "wrong embedded value",
+        "
         union Foo{ A(s32) }
         func bar() -> Foo { return Foo::A(false); }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo::A")
-        .assert_msg_has(0, "failed to fully resolve")
         .assert_msg_has(0, "failed to resolve")
         .assert_occurs_at(1, "false")
         .assert_msg_has(1, "has been resolved to 's32'")
         .assert_msg_has(1, "has been resolved to 'bool'");
     });
+}
 #[test]
 fn test_correct_tuple_members() {
     // Tuples with zero members
     Tester::new_single_source_expect_ok(
         "single zero-tuple",
         "struct Foo{ () bar }"
     ).for_struct("Foo", |s| { s
         .for_field("bar", |f| { f.assert_parser_type("()"); })
         .assert_size_alignment("Foo", 0, 1);
     });
     Tester::new_single_source_expect_ok(
         "triple zero-tuple",
         "struct Foo{ () bar, () baz, () qux }"
     ).for_struct("Foo", |s| { s
         .assert_size_alignment("Foo", 0, 1);
     });
     // Tuples with one member (which are elided, because due to ambiguity
     // between a one-tuple literal and a parenthesized expression, we're not
     // going to be able to construct one-tuples).
     Tester::new_single_source_expect_ok(
         "single elided one-tuple",
         "struct Foo{ (u32) bar }"
     ).for_struct("Foo", |s| { s
         .for_field("bar", |f| { f.assert_parser_type("u32"); })
         .assert_size_alignment("Foo", 4, 4);
     });
     Tester::new_single_source_expect_ok(
         "triple elided one-tuple",
         "struct Foo{ (u8) bar, (u16) baz, (u32) qux }"
     ).for_struct("Foo", |s| { s
         .assert_size_alignment("Foo", 8, 4);
     });
     // Tuples with three members
     Tester::new_single_source_expect_ok(
         "single three-tuple",
         "struct Foo{ (u8, u16, u32) bar }"
     ).for_struct("Foo", |s| { s
         .for_field("bar", |f| { f.assert_parser_type("(u8,u16,u32)"); })

0 comments (0 inline, 0 general)