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

Changeset - 77bdf7d1ef92

Parent rev.

Child rev.

[Not reviewed]

0 15 0

mh - 4 years ago 2021-12-15 14:34:28
contact@maxhenger.nl

Add tuple literals and implement their type inference

15 files changed with 327 insertions and 94 deletions:

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/eval/executor.rs

src/protocol/eval/value.rs

src/protocol/input_source.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_definitions_types.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/token_parsing.rs

src/protocol/parser/type_table.rs

src/protocol/tests/eval_binding.rs

src/protocol/tests/eval_operators.rs

src/protocol/tests/parser_literals.rs

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -1731,6 +1731,7 @@ pub enum Literal { @@
     Enum(LiteralEnum),
     Union(LiteralUnion),
     Array(Vec<ExpressionId>),
     Tuple(Vec<ExpressionId>),
+}
 impl Literal {

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -706,11 +706,19 @@ impl ASTWriter { @@
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
+                    }
+                    },
                     Literal::Array(data) => {
                         val.with_s_val("Array");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
                     },
                     Literal::Tuple(data) => {
                         val.with_s_val("Tuple");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -171,6 +171,12 @@ impl Frame { @@
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, *value_expr_id);
+                        }
                     },
                     Literal::Tuple(value_expr_ids) => {
                         for value_expr_id in value_expr_ids {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, *value_expr_id);
+                        }
+                    }
+                }
             },
@@ @@ -553,6 +559,12 @@ impl Prompt { @@
                                     );
                                     Value::Array(heap_pos)
+                                }
                                 Literal::Tuple(lit_value) => {
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.len()
                                     );
                                     Value::Tuple(heap_pos)
+                                }
                             };
                             cur_frame.expr_values.push_back(value);

src/protocol/eval/value.rs

➞

Show inline comments

@@ @@ -58,6 +58,7 @@ pub enum Value { @@
     SInt32(i32),
     SInt64(i64),
     Array(HeapPos),
     Tuple(HeapPos),
     // Instances of user-defined types
     Enum(i64),
     Union(i64, HeapPos),
@@ @@ -94,6 +95,7 @@ impl_union_unpack_as_value!(as_sint16, Value::SInt16, i16); @@
 impl_union_unpack_as_value!(as_sint32,  Value::SInt32,  i32);
 impl_union_unpack_as_value!(as_sint64,  Value::SInt64,  i64);
 impl_union_unpack_as_value!(as_array,   Value::Array,   HeapPos);
 impl_union_unpack_as_value!(as_tuple,   Value::Tuple,   HeapPos);
 impl_union_unpack_as_value!(as_enum,    Value::Enum,    i64);
 impl_union_unpack_as_value!(as_struct,  Value::Struct,  HeapPos);
@@ @@ -154,6 +156,7 @@ impl Value { @@
             Value::Message(v) => Some(*v),
             Value::String(v) => Some(*v),
             Value::Array(v) => Some(*v),
             Value::Tuple(v) => Some(*v),
             Value::Union(_, v) => Some(*v),
             Value::Struct(v) => Some(*v),
             _ => None
@@ @@ -222,6 +225,7 @@ impl ValueGroup { @@
                 Value::Message(_)    => Value::Message(new_region_idx),
                 Value::String(_)     => Value::String(new_region_idx),
                 Value::Array(_)      => Value::Array(new_region_idx),
                 Value::Tuple(_)      => Value::Tuple(new_region_idx),
                 Value::Union(tag, _) => Value::Union(*tag, new_region_idx),
                 Value::Struct(_)     => Value::Struct(new_region_idx),
                 _ => unreachable!(),
@@ @@ -268,6 +272,7 @@ impl ValueGroup { @@
                 Value::Message(_)    => Value::Message(to_heap_pos),
                 Value::String(_)     => Value::String(to_heap_pos),
                 Value::Array(_)      => Value::Array(to_heap_pos),
                 Value::Tuple(_)      => Value::Tuple(to_heap_pos),
                 Value::Union(tag, _) => Value::Union(*tag, to_heap_pos),
                 Value::Struct(_)     => Value::Struct(to_heap_pos),
                 _ => unreachable!(),
                 Value::SInt32(v) => { *v = rhs.as_sint32(); },
                 Value::SInt64(v) => { *v = rhs.as_sint64(); },
                 Value::Array(v) => { to_dealloc = Some(*v); *v = rhs.as_array(); },
                 Value::Tuple(v) => { to_dealloc = Some(*v); *v = rhs.as_tuple(); },
                 Value::Enum(v) => { *v = rhs.as_enum(); },
                 Value::Union(lhs_tag, lhs_heap_pos) => {
                     to_dealloc = Some(*lhs_heap_pos);
         Value::SInt32(v) => *v == rhs.as_sint32(),
         Value::SInt64(v) => *v == rhs.as_sint64(),
         Value::Array(lhs_pos) => eval_equality_heap(store, *lhs_pos, rhs.as_array()),
         Value::Tuple(lhs_pos) => eval_equality_heap(store, *lhs_pos, rhs.as_tuple()),
         Value::Enum(v) => *v == rhs.as_enum(),
         Value::Union(lhs_tag, lhs_pos) => {
             let (rhs_tag, rhs_pos) = rhs.as_union();
         Value::SInt32(v) => *v != rhs.as_sint32(),
         Value::SInt64(v) => *v != rhs.as_sint64(),
         Value::Array(lhs_pos) => eval_inequality_heap(store, *lhs_pos, rhs.as_array()),
         Value::Tuple(lhs_pos) => eval_inequality_heap(store, *lhs_pos, rhs.as_tuple()),
         Value::Enum(v) => *v != rhs.as_enum(),
         Value::Union(lhs_tag, lhs_pos) => {
             let (rhs_tag, rhs_pos) = rhs.as_union();
         Value::SInt32(v) => v == rhs.as_sint32(),
         Value::SInt64(v) => v == rhs.as_sint64(),
         Value::Array(lhs_pos) => eval_binding_heap(store, lhs_pos, rhs.as_array()),
         Value::Tuple(lhs_pos) => eval_binding_heap(store, lhs_pos, rhs.as_tuple()),
         Value::Enum(v) => v == rhs.as_enum(),
         Value::Union(lhs_tag, lhs_pos) => {
             let (rhs_tag, rhs_pos) = rhs.as_union();

src/protocol/input_source.rs

➞

Show inline comments

@@ @@ -61,12 +61,6 @@ impl InputSource { @@
+        }
+    }
     #[cfg(test)]
     pub fn new_test(input: &str) -> Self {
         let bytes = Vec::from(input.as_bytes());
         return Self::new(String::from("test"), bytes)
+    }
     #[inline]
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, offset: self.offset as u32 }

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -402,8 +402,10 @@ impl PassDefinitions { @@
                 let id = self.consume_if_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_if = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{
                     this, start_if: id, next: StatementId::new_invalid()
                 let end_if = ctx.heap.alloc_end_if_statement(|this| EndIfStatement {
                     this,
                     start_if: id,
                     next: StatementId::new_invalid()
                 });
                 section.push(end_if.upcast());
@@ @@ -413,8 +415,10 @@ impl PassDefinitions { @@
                 let id = self.consume_while_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_while = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement{
                     this, start_while: id, next: StatementId::new_invalid()
                 let end_while = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement {
                     this,
                     start_while: id,
                     next: StatementId::new_invalid()
                 });
                 section.push(end_while.upcast());
@@ @@ -443,7 +447,7 @@ impl PassDefinitions { @@
                 let id = self.consume_fork_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement{
+                let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement {
                     this,
                     start_fork: id,
                     next: StatementId::new_invalid(),
@@ @@ -478,6 +482,15 @@ impl PassDefinitions { @@
                     section.push(id.upcast());
+                }
+            }
         } else if next == TokenKind::OpenParen {
             // Same as above: memory statement or normal expression
             if let Some((memory_stmt_id, assignment_stmt_id)) = self.maybe_consume_memory_statement(module, iter, ctx)? {
                 section.push(memory_stmt_id.upcast().upcast());
                 section.push(assignment_stmt_id.upcast());
             } else {
                 let id = self.consume_expression_statement(module, iter, ctx)?;
                 section.push(id.upcast());
+            }
         } else {
             let id = self.consume_expression_statement(module, iter, ctx)?;
             section.push(id.upcast());
@@ @@ -1330,10 +1343,63 @@ impl PassDefinitions { @@
         let next = iter.next();
         let result = if next == Some(TokenKind::OpenParen) {
             // Expression between parentheses
             // Something parenthesized. This can mean several things: we have
             // a parenthesized expression or we have a tuple literal. They are
             // ambiguous when the tuple has one member. But like the tuple type
             // parsing we interpret all one-tuples as parenthesized expressions.
             //
             // Practically (to prevent unnecessary `consume_expression` calls)
             // we distinguish the zero-tuple, the parenthesized expression, and
             // the N-tuple (for N > 1).
             let open_paren_pos = iter.next_start_position();
             iter.consume();
             let result = self.consume_expression(module, iter, ctx)?;
             consume_token(&module.source, iter, TokenKind::CloseParen)?;
             let result = if Some(TokenKind::CloseParen) == iter.next() {
                 // Zero-tuple
                 let (_, close_paren_pos) = iter.next_positions();
                 iter.consume();
                 let literal_id = ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                     this,
                     span: InputSpan::from_positions(open_paren_pos, close_paren_pos),
                     value: Literal::Tuple(Vec::new()),
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 literal_id.upcast()
             } else {
                 // Start by consuming one expression, then check for a comma
                 let expr_id = self.consume_expression(module, iter, ctx)?;
                 if Some(TokenKind::Comma) == iter.next() && Some(TokenKind::CloseParen) != iter.peek() {
                     // Must be an N-tuple
                     iter.consume(); // the comma
                     let mut scoped_section = self.expressions.start_section();
                     scoped_section.push(expr_id);
                     let mut close_paren_pos = open_paren_pos;
                     consume_comma_separated_until(
                         TokenKind::CloseParen, &module.source, iter, ctx,
                         |_source, iter, ctx| self.consume_expression(module, iter, ctx),
                         &mut scoped_section, "an expression", Some(&mut close_paren_pos)
                     )?;
                     debug_assert!(scoped_section.len() > 1); // peeked token wasn't CloseParen, must be expression
                     let literal_id = ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                         this,
                         span: InputSpan::from_positions(open_paren_pos, close_paren_pos),
                         value: Literal::Tuple(scoped_section.into_vec()),
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     });
                     literal_id.upcast()
                 } else {
                     // Assume we're dealing with a normal expression
                     consume_token(&module.source, iter, TokenKind::CloseParen)?;
                     expr_id
+                }
             };
             result
         } else if next == Some(TokenKind::OpenCurly) {
@@ @@ -1385,6 +1451,7 @@ impl PassDefinitions { @@
             // May be a variable, a type instantiation or a function call. If we
             // have a single identifier that we cannot find in the type table
             // then we're going to assume that we're dealing with a variable.
             let ident_span = iter.next_span();
             let ident_text = module.source.section_at_span(ident_span);
             let symbol = ctx.symbols.get_symbol_by_name(SymbolScope::Module(module.root_id), ident_text);

src/protocol/parser/pass_definitions_types.rs

➞

Show inline comments

@@ @@ -164,11 +164,13 @@ impl ParserTypeParser { @@
+                    }
                 },
                 ParseState::TupleStart => {
                     // Allowed tokens: ident )
                     // Allowed tokens: ident ( )
                     // We'll strip the nested tuple later in this function
                     match next {
                         Some(TokenKind::Ident) => self.consume_type_idents(
                             source, heap, symbols, wrapping_definition, poly_vars, cur_scope, allow_inference, iter
                         )?,
                         Some(TokenKind::OpenParen) => self.consume_open_paren(iter),
                         Some(TokenKind::CloseParen) => self.consume_close_paren(source, iter)?,
                         _ => return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -1341,7 +1341,7 @@ impl Visitor for PassTyping { @@
                     self.visit_expr(ctx, expr_id)?;
+                }
             },
             Literal::Array(expressions) => {
+            Literal::Array(expressions) | Literal::Tuple(expressions) => {
                 // TODO: @performance
                 let expr_ids = expressions.clone();
                 for expr_id in expr_ids {
@@ @@ -1424,8 +1424,33 @@ impl PassTyping { @@
     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.expr_queued.is_empty() {
             let next_expr_idx = self.expr_queued.pop_front().unwrap();
             self.progress_expr(ctx, next_expr_idx)?;
             // Make as much progress as possible without forced integer
             // inference.
             while !self.expr_queued.is_empty() {
                 let next_expr_idx = self.expr_queued.pop_front().unwrap();
                 self.progress_expr(ctx, next_expr_idx)?;
+            }
             // 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_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {
                 let expr_type = &mut infer_expr.expr_type;
                 if !expr_type.is_done && expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     // Force integer type to s32
                     println!("DEBUG: Autoinferring (idx {}) {}", infer_expr.expr_id.index, String::from_utf8_lossy(ctx.module().source.section_at_span(ctx.heap[infer_expr.expr_id].full_span())));
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                     expr_type.is_done = true;
                     // Requeue expression (and its parent, if it exists)
                     self.expr_queued.push_back(infer_expr_idx as i32);
                     if let Some(parent_expr) = ctx.heap[infer_expr.expr_id].parent_expr_id() {
                         let parent_idx = ctx.heap[parent_expr].get_unique_id_in_definition();
                         self.expr_queued.push_back(parent_idx);
+                    }
+                }
+            }
+        }
         // Helper for transferring polymorphic variables to concrete types and
@@ @@ -1477,22 +1502,15 @@ impl PassTyping { @@
         // Inference is now done. But we may still have uninferred types. So we
         // check for these.
         for (infer_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {
             let expr_type = &mut infer_expr.expr_type;
             if !expr_type.is_done {
                 // Auto-infer numberlike/integerlike types to a regular int
                 if expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                     self.expr_queued.push_back(infer_expr_idx as i32);
                 } else {
                     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 '{}')",
                             expr_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
         for infer_expr in self.expr_types.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
@@ @@ -1532,7 +1550,7 @@ impl PassTyping { @@
                             // Not typechecked yet, so add an entry in the queue
                             let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, concrete_type);
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                             queue.push(ResolveQueueElement{
+                            queue.push(ResolveQueueElement {
                                 root_id: ctx.heap[definition_id].defined_in(),
                                 definition_id,
                                 reserved_monomorph_idx: reserved_idx,
@@ @@ -1563,13 +1581,6 @@ impl PassTyping { @@
+            }
+        }
         // If we did any implicit type forcing, then our queue isn't empty
         // anymore
         while !self.expr_queued.is_empty() {
             let expr_idx = self.expr_queued.pop_back().unwrap();
             self.progress_expr(ctx, expr_idx)?;
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the type table.
         let procedure_arguments = match &self.definition_type {
@@ @@ -2461,10 +2472,53 @@ impl PassTyping { @@
                 progress_expr
             },
             Literal::Tuple(data) => {
                 let expr_elements = data.clone(); // TODO: @performance
                 debug_log!("Tuple expr ({} elements): {}", expr_elements.len(), upcast_id.index);
                 debug_log!(" * Before:");
                 debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
                 // Initial tuple constraint
                 let num_members = expr_elements.len();
                 let mut initial_type = Vec::with_capacity(num_members + 1); // TODO: @performance
                 initial_type.push(InferenceTypePart::Tuple(num_members as u32));
                 for _ in 0..num_members {
                     initial_type.push(InferenceTypePart::Unknown);
+                }
                 let mut progress_expr = self.apply_template_constraint(ctx, upcast_id, &initial_type)?;
                 // The elements of the tuple can have any type, but they must
                 // end up as arguments to the output tuple type.
                 debug_log!(" * During (checking expressions constituting tuple):");
                 for (member_expr_index, member_expr_id) in expr_elements.iter().enumerate() {
                     // For the current expression index, (re)compute the
                     // position in the tuple type where the types should match.
                     let mut start_index = 1; // first element is Tuple type, second is the first child
                     for _ in 0..member_expr_index {
                         let tuple_expr_index = ctx.heap[id].unique_id_in_definition;
                         let tuple_type = &self.expr_types[tuple_expr_index as usize].expr_type;
                         start_index = InferenceType::find_subtree_end_idx(&tuple_type.parts, start_index);
                         debug_assert_ne!(start_index, tuple_type.parts.len()); // would imply less tuple type children than member expressions
+                    }
                     // Apply the constraint
                     let (member_progress_expr, member_progress) = self.apply_equal2_constraint(
                         ctx, upcast_id, upcast_id, start_index, *member_expr_id, 0
                     )?;
                     debug_log!("   - Member {} type | {}", member_expr_index, self.debug_get_display_name(ctx, *member_expr_id));
                     progress_expr = progress_expr || member_progress_expr;
                     if member_progress {
                         self.queue_expr(ctx, *member_expr_id);
+                    }
+                }
                 progress_expr
+            }
         };
         debug_log!(" * After:");
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
+        debug_log!("   - Expr type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
@@ @@ -3055,7 +3109,7 @@ impl PassTyping { @@
             _ => {}
+        }
         let mut progress = Vec::new();
+        let mut progress = Vec::new(); // TODO: @Performance
         progress.resize(args.len(), false);
         // Do pairwise inference, keep track of the last entry we made progress

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -1002,7 +1002,7 @@ impl Visitor for PassValidationLinking { @@
                 expr_section.forget();
             },
             Literal::Array(literal) => {
+            Literal::Array(literal) | Literal::Tuple(literal) => {
                 // Visit all expressions in the array
                 let upcast_id = id.upcast();
                 let expr_section = self.expression_buffer.start_section_initialized(literal);
@@ @@ -1225,7 +1225,7 @@ impl Visitor for PassValidationLinking { @@
                                 // subexpressions, so we're always fine
                                 if cfg!(debug_assertions) {
                                     match lit_expr.value {
                                         Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) => {},
+                                        Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},
                                         _ => unreachable!(),
+                                    }
+                                }

src/protocol/parser/token_parsing.rs

➞

Show inline comments

     Ok(span)
+}
 /// Consumes a comma separated list until the closing delimiter is encountered
 /// Consumes a comma separated list until the closing delimiter is encountered.
 /// The closing delimiter is consumed as well.
 pub(crate) fn consume_comma_separated_until<T, F, E>(
     close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     mut consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
@@ @@ -356,19 +357,20 @@ pub(crate) fn consume_character_literal( @@
         ));
+    }
     debug_assert!(char_text.len() >= 2); // always includes the bounding "'"
     match char_text.len() {
 => return Err(ParseError::new_error_str_at_span(source, span, "too little characters in character literal")),
 => {
 => return Err(ParseError::new_error_str_at_span(source, span, "too little characters in character literal")),
 => {
             // We already know the text is ascii, so just throw an error if we have the escape
             // character.
-            if char_text[0] == b'\\' {
+            if char_text[1] == b'\\' {
                 return Err(ParseError::new_error_str_at_span(source, span, "escape character without subsequent character"));
+            }
-            return Ok((char_text[0] as char, span));
+            return Ok((char_text[1] as char, span));
         },
 => {
             if char_text[0] == b'\\' {
                 let result = parse_escaped_character(source, span, char_text[1])?;
 => {
             if char_text[1] == b'\\' {
                 let result = parse_escaped_character(source, span, char_text[2])?;
                 return Ok((result, span))
+            }
         },

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -123,13 +123,6 @@ impl DefinedTypeVariant { @@
+        }
+    }
     pub(crate) fn as_struct_mut(&mut self) -> &mut StructType {
         match self {
             DefinedTypeVariant::Struct(v) => v,
             _ => unreachable!("Cannot convert {} to struct variant", self.type_class())
+        }
+    }
     pub(crate) fn as_enum(&self) -> &EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
@@ @@ -137,26 +130,12 @@ impl DefinedTypeVariant { @@
+        }
+    }
     pub(crate) fn as_enum_mut(&mut self) -> &mut EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
             _ => unreachable!("Cannot convert {} to enum variant", self.type_class())
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionType {
         match self {
             DefinedTypeVariant::Union(v) => v,
             _ => unreachable!("Cannot convert {} to union variant", self.type_class())
+        }
+    }
     pub(crate) fn as_union_mut(&mut self) -> &mut UnionType {
         match self {
             DefinedTypeVariant::Union(v) => v,
             _ => unreachable!("Cannot convert {} to union variant", self.type_class())
+        }
+    }
+}
 pub struct PolymorphicVariable {
@@ @@ -269,13 +248,6 @@ pub(crate) enum MonomorphVariant { @@
+}
 impl MonomorphVariant {
     fn as_struct(&self) -> &StructMonomorph {
         match self {
             MonomorphVariant::Struct(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_struct_mut(&mut self) -> &mut StructMonomorph {
         match self {
             MonomorphVariant::Struct(v) => v,
@@ @@ -297,13 +269,6 @@ impl MonomorphVariant { @@
+        }
+    }
     fn as_tuple(&self) -> &TupleMonomorph {
         match self {
             MonomorphVariant::Tuple(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {
         match self {
             MonomorphVariant::Tuple(v) => v,

src/protocol/tests/eval_binding.rs

➞

Show inline comments

@@ @@ -129,6 +129,40 @@ fn test_binding_from_union() { @@
     });
+}
 #[test]
 fn test_binding_from_tuple() {
     Tester::new_single_source_expect_ok("tuple binding", "
         func foo() -> u32 {
             u64 value = 2000;
             auto tuple = (\"hello\", value, 21);
             bool success1 = false;
             if (let (\"hello\", value, 21) = tuple && let (a, b, c) = tuple) {
                 success1 = a == \"hello\" && b == value && c == 21;
+            }
             bool success2 = true;
             if (let (\"nope\", a, b) = tuple) success2 = false;
             if (let (\"hello\", 2001, 21) = tuple) success2 = false;
             if (let (a, 2001, b) = tuple) success2 = false;
             if (let (a, b, 22) = tuple) success2 = false;
             bool success3 = false;
             if (let (\"hello\", v2a, v3a) = tuple && let (v1a, 2000, v3b) = tuple && let (v1b, v2b, 21) = tuple) {
                 success3 = v1a == v1b && v2a == v2b && v3a == v3b;
+            }
             if (success1 && success2 && success3 && let (\"hello\", a, b) = tuple) {
                 return cast(a) + b;
+            }
             return 0;
+        }
     ").for_function("foo", |f| { f
         .call_ok(Some(Value::UInt32(2021)));
     });
+}
 #[test]
 fn test_binding_fizz_buzz() {
     Tester::new_single_source_expect_ok("am I employable?", "

src/protocol/tests/eval_operators.rs

➞

Show inline comments

@@ @@ -146,6 +146,38 @@ fn test_binary_integer_operators() { @@
     );
+}
 #[test]
 fn test_tuple_operators() {
     Tester::new_single_source_expect_ok("tuple equality", "
     func test_func() -> bool {
         auto a1 = (8, 16, 32);
         (u8, u16, u32) a2 = (8, 16, 32);
         auto b1 = ();
         () b2 = ();
         return a1 == a2 && a2 == (8, 16, 32) && b1 == b2 && b2 == ();
+    }
     ").for_function("test_func", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
     Tester::new_single_source_expect_ok("tuple inequality", "
     func test_func() -> bool {
         auto a = (8, 16, 32);
         (u8, u16, u32) a_same = (8, 16, 32);
         auto a_diff = (0b111, 0b1111, 0b11111);
         auto b = ();
         return
             !(a != a_same) &&
             a != a_diff &&
             a != (8, 16, 320) &&
             !(b != ());
+    }
     ").for_function("test_func", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
+}
 #[test]
 fn test_string_operators() {
     Tester::new_single_source_expect_ok("string concatenation", "

src/protocol/tests/parser_literals.rs

➞

Show inline comments

@@ @@ -67,4 +67,58 @@ fn test_string_literals() { @@
     Tester::new_single_source_expect_err("non-ASCII string", "
         func test() -> string { return \"💧\"; }
     ").error(|e| { e.assert_msg_has(0, "non-ASCII character in string literal"); });
+}
 #[test]
 fn test_tuple_literals() {
     Tester::new_single_source_expect_ok("zero tuples", "
         func test() -> () {
             // Looks like lisp :)
             auto t1 = ();
             () t2 = ();
             auto t3 = (());
             () t4 = (());
             auto t5 = ((((()))));
             ((())) t6 = ((((()))));
             return ();
+        }
     ").for_function("test", |f| { f
         .for_variable("t1", |v| { v.assert_concrete_type("()"); })
         .for_variable("t2", |v| { v.assert_concrete_type("()"); })
         .for_variable("t3", |v| { v.assert_concrete_type("()"); })
         .for_variable("t4", |v| { v.assert_concrete_type("()"); })
         .for_variable("t5", |v| { v.assert_concrete_type("()"); })
         .for_variable("t6", |v| { v.assert_concrete_type("()"); });
     });
     // All one-tuples (T) are transformed into T to prevent ambiguity
     Tester::new_single_source_expect_ok("one tuples", "
         func test() -> (u32) {
             auto a = (0);
             (s32) b = (1);
             ((((s32)))) c = ((2));
+        }
     ").for_function("test", |f| { f
         .for_variable("a", |v| { v.assert_concrete_type("s32"); })
         .for_variable("b", |v| { v.assert_concrete_type("s32"); })
         .for_variable("c", |v| { v.assert_concrete_type("s32"); });
     });
     Tester::new_single_source_expect_ok("actual tuples", "
         func test() -> (u32, u32) {
             (u8,u16,u32) a = (0, 1, 2);
             auto b = a;
             auto c = (3, 4, 5);
             ((auto, auto)) d = (a, c);
             auto e = (\"hello\", 'c', 5 + 2);
             return ((0), (1));
+        }
     ").for_function("test", |f| { f
         .for_variable("a", |v| { v.assert_concrete_type("(u8,u16,u32)"); })
         .for_variable("b", |v| { v.assert_concrete_type("(u8,u16,u32)"); })
         .for_variable("c", |v| { v.assert_concrete_type("(s32,s32,s32)"); })
         .for_variable("d", |v| { v.assert_concrete_type("((u8,u16,u32),(s32,s32,s32))"); })
         .for_variable("e", |v| { v.assert_concrete_type("(string,char,s32)"); });
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -405,7 +405,7 @@ impl<'a> EnumTester<'a> { @@
     pub(crate) fn assert_size_alignment(mut self, serialized_monomorph: &str, size: usize, alignment: usize) -> Self {
         self = self.assert_has_monomorph(serialized_monomorph);
-        let (has_monomorph, serialized) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
+        let (has_monomorph, _) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
         let mono_index = has_monomorph.unwrap();
         let mono = self.ctx.types.get_monomorph(mono_index);
@@ @@ -753,7 +753,7 @@ impl<'a> VariableTester<'a> { @@
         let concrete_type = &mono_data.expr_data[self.var_expr.unique_id_in_definition as usize].expr_type;
         // Serialize and check
-        let mut serialized = concrete_type.display_name(self.ctx.heap);
         let serialized = concrete_type.display_name(self.ctx.heap);
         assert_eq!(
             expected, &serialized,
@@ @@ -788,7 +788,7 @@ impl<'a> ExpressionTester<'a> { @@
         let concrete_type = &mono_data.expr_data[expr_index as usize].expr_type;
         // Serialize and check type
-        let mut serialized = concrete_type.display_name(self.ctx.heap);
         let serialized = concrete_type.display_name(self.ctx.heap);
         assert_eq!(
             expected, &serialized,
@@ @@ -925,7 +925,6 @@ impl<'a> ErrorTester<'a> { @@
 fn has_equal_num_monomorphs(ctx: TestCtx, num: usize, definition_id: DefinitionId) -> (bool, usize) {
     // Again: inefficient, but its testing code
     let type_def = ctx.types.get_base_definition(&definition_id).unwrap();
     let mut num_on_type = 0;
     for mono in &ctx.types.mono_lookup.monomorphs {

0 comments (0 inline, 0 general)