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

Changeset - 622cf123a4e6

Parent rev.

Child rev.

[Not reviewed]

0 9 0

MH - 4 years ago 2021-05-27 18:56:55
contact@maxhenger.nl

Add concatenation assignment

9 files changed with 68 insertions and 11 deletions:

src/protocol/ast.rs

src/protocol/eval/executor.rs

src/protocol/eval/value.rs

src/protocol/parser/mod.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_tokenizer.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/tokens.rs

src/protocol/tests/eval_binding.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -1090,384 +1090,385 @@ pub struct EndWhileStatement { @@
+}
 #[derive(Debug, Clone)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "break" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<EndWhileStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "continue" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<WhileStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "sync" keyword
     pub body: BlockStatementId,
     // Phase 2: linker
     pub end_sync: EndSynchronousStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     pub start_sync: SynchronousStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "return" keyword
     pub expressions: Vec<ExpressionId>,
+}
 #[derive(Debug, Clone)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "goto" keyword
     pub label: Identifier,
     // Phase 2: linker
     pub target: Option<LabeledStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "new" keyword
     pub expression: CallExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
     pub span: InputSpan,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ExpressionParent {
     None, // only set during initial parsing
     If(IfStatementId),
     While(WhileStatementId),
     Return(ReturnStatementId),
     New(NewStatementId),
     ExpressionStmt(ExpressionStatementId),
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)
+}
 impl ExpressionParent {
     pub fn is_new(&self) -> bool {
         match self {
             ExpressionParent::New(_) => true,
             _ => false,
+        }
+    }
     pub fn as_expression(&self) -> ExpressionId {
         match self {
             ExpressionParent::Expression(id, _) => *id,
             _ => panic!("called as_expression() on {:?}", self),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Binding(BindingExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Literal(LiteralExpression),
     Cast(CastExpression),
     Call(CallExpression),
     Variable(VariableExpression),
+}
 impl Expression {
     pub fn as_variable(&self) -> &VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Expression::Assignment(expr) => expr.span,
             Expression::Binding(expr) => expr.span,
             Expression::Conditional(expr) => expr.span,
             Expression::Binary(expr) => expr.span,
             Expression::Unary(expr) => expr.span,
             Expression::Indexing(expr) => expr.span,
             Expression::Slicing(expr) => expr.span,
             Expression::Select(expr) => expr.span,
             Expression::Literal(expr) => expr.span,
             Expression::Cast(expr) => expr.span,
             Expression::Call(expr) => expr.span,
             Expression::Variable(expr) => expr.identifier.span,
+        }
+    }
     // TODO: @cleanup
     pub fn parent(&self) -> &ExpressionParent {
         match self {
             Expression::Assignment(expr) => &expr.parent,
             Expression::Binding(expr) => &expr.parent,
             Expression::Conditional(expr) => &expr.parent,
             Expression::Binary(expr) => &expr.parent,
             Expression::Unary(expr) => &expr.parent,
             Expression::Indexing(expr) => &expr.parent,
             Expression::Slicing(expr) => &expr.parent,
             Expression::Select(expr) => &expr.parent,
             Expression::Literal(expr) => &expr.parent,
             Expression::Cast(expr) => &expr.parent,
             Expression::Call(expr) => &expr.parent,
             Expression::Variable(expr) => &expr.parent,
+        }
+    }
     // TODO: @cleanup
     pub fn parent_expr_id(&self) -> Option<ExpressionId> {
         if let ExpressionParent::Expression(id, _) = self.parent() {
             Some(*id)
         } else {
             None
+        }
+    }
     pub fn get_unique_id_in_definition(&self) -> i32 {
         match self {
             Expression::Assignment(expr) => expr.unique_id_in_definition,
             Expression::Binding(expr) => expr.unique_id_in_definition,
             Expression::Conditional(expr) => expr.unique_id_in_definition,
             Expression::Binary(expr) => expr.unique_id_in_definition,
             Expression::Unary(expr) => expr.unique_id_in_definition,
             Expression::Indexing(expr) => expr.unique_id_in_definition,
             Expression::Slicing(expr) => expr.unique_id_in_definition,
             Expression::Select(expr) => expr.unique_id_in_definition,
             Expression::Literal(expr) => expr.unique_id_in_definition,
             Expression::Cast(expr) => expr.unique_id_in_definition,
             Expression::Call(expr) => expr.unique_id_in_definition,
             Expression::Variable(expr) => expr.unique_id_in_definition,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum AssignmentOperator {
     Set,
     Concatenated,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct BindingExpression {
     pub this: BindingExpressionId,
     // Parsing
     pub span: InputSpan, // of the binding keyword
     pub bound_to: ExpressionId,
     pub bound_from: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Parsing
     pub span: InputSpan, // of question mark operator
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
     pub false_expression: ExpressionId,
     // Validator/Linking
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
     LogicalAnd,
     BitwiseOr,
     BitwiseXor,
     BitwiseAnd,
     Equality,
     Inequality,
     LessThan,
     GreaterThan,
     LessThanEqual,
     GreaterThanEqual,
     ShiftLeft,
     ShiftRight,
     Add,
     Subtract,
     Multiply,
     Divide,
     Remainder,
+}
 #[derive(Debug, Clone)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub left: ExpressionId,
     pub operation: BinaryOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum UnaryOperator {
     Positive,
     Negative,
     BitwiseNot,
     LogicalNot,
+}
 #[derive(Debug, Clone)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub operation: UnaryOperator,
     pub expression: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Parsing
     pub span: InputSpan,
     pub subject: ExpressionId,
     pub index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Parsing
     pub span: InputSpan, // from '[' to ']';
     pub subject: ExpressionId,
     pub from_index: ExpressionId,
     pub to_index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Parsing
     pub span: InputSpan, // of the '.'
     pub subject: ExpressionId,
     pub field_name: Identifier,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CastExpression {
     pub this: CastExpressionId,
     // Parsing
     pub span: InputSpan, // of the "cast" keyword,
     pub to_type: ParserType,
     pub subject: ExpressionId,
     // Validator/linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Parsing
     pub span: InputSpan,
     pub parser_type: ParserType, // of the function call, not the return type
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub definition: DefinitionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Method {
     // Builtin
     Get,
     Put,
     Fires,
     Create,
     Length,
     Assert,
     UserFunction,
     UserComponent,
+}
 #[derive(Debug, Clone)]
 pub struct MethodSymbolic {
     pub(crate) parser_type: ParserType,
     pub(crate) definition: DefinitionId
+}
 #[derive(Debug, Clone)]
 pub struct LiteralExpression {
     pub this: LiteralExpressionId,
     // Parsing

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -540,385 +540,385 @@ impl Prompt { @@
                                         cur_frame, &mut self.store, lit_value.len()
                                     );
                                     Value::Array(heap_pos)
+                                }
                             };
                             cur_frame.expr_values.push_back(value);
                         },
                         Expression::Cast(expr) => {
                             let mono_data = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                             let output_type = &mono_data.expr_data[expr.unique_id_in_definition as usize].expr_type;
                             // Typechecking reduced this to two cases: either we
                             // have casting noop (same types), or we're casting
                             // between integer/bool/char types.
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             match apply_casting(&mut self.store, output_type, &subject) {
                                 Ok(value) => cur_frame.expr_values.push_back(value),
                                 Err(msg) => {
                                     return Err(EvalError::new_error_at_expr(self, modules, heap, expr.this.upcast(), msg));
+                                }
+                            }
                             self.store.drop_value(subject.get_heap_pos());
+                        }
                         Expression::Call(expr) => {
                             // If we're dealing with a builtin we don't do any
                             // fancy shenanigans at all, just push the result.
                             match expr.method {
                                 Method::Get => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value = self.store.maybe_read_ref(&value).clone();
                                     match ctx.get(value.clone(), &mut self.store) {
                                         Some(result) => {
                                             cur_frame.expr_values.push_back(result)
                                         },
                                         None => {
                                             cur_frame.expr_values.push_front(value.clone());
                                             cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
                                             return Ok(EvalContinuation::BlockGet(value));
+                                        }
+                                    }
                                 },
                                 Method::Put => {
                                     let port_value = cur_frame.expr_values.pop_front().unwrap();
                                     let deref_port_value = self.store.maybe_read_ref(&port_value).clone();
                                     let msg_value = cur_frame.expr_values.pop_front().unwrap();
                                     let deref_msg_value = self.store.maybe_read_ref(&msg_value).clone();
                                     if ctx.did_put(deref_port_value.clone()) {
                                         // We're fine, deallocate in case the expression value stack
                                         // held an owned value
                                         self.store.drop_value(msg_value.get_heap_pos());
                                     } else {
                                         cur_frame.expr_values.push_front(msg_value);
                                         cur_frame.expr_values.push_front(port_value);
                                         cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
                                         return Ok(EvalContinuation::Put(deref_port_value, deref_msg_value));
+                                    }
                                 },
                                 Method::Fires => {
                                     let port_value = cur_frame.expr_values.pop_front().unwrap();
                                     let port_value_deref = self.store.maybe_read_ref(&port_value).clone();
                                     match ctx.fires(port_value_deref.clone()) {
                                         None => {
                                             cur_frame.expr_values.push_front(port_value);
                                             cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
                                             return Ok(EvalContinuation::BlockFires(port_value_deref));
                                         },
                                         Some(value) => {
                                             cur_frame.expr_values.push_back(value);
+                                        }
+                                    }
                                 },
                                 Method::Create => {
                                     let length_value = cur_frame.expr_values.pop_front().unwrap();
                                     let length_value = self.store.maybe_read_ref(&length_value);
                                     let length = if length_value.is_signed_integer() {
                                         let length_value = length_value.as_signed_integer();
                                         if length_value < 0 {
                                             return Err(EvalError::new_error_at_expr(
                                                 self, modules, heap, expr_id,
                                                 format!("got length '{}', can only create a message with a non-negative length", length_value)
                                             ));
+                                        }
                                         length_value as u64
                                     } else {
                                         debug_assert!(length_value.is_unsigned_integer());
                                         length_value.as_unsigned_integer()
                                     };
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.resize(length as usize, Value::UInt8(0));
                                     cur_frame.expr_values.push_back(Value::Message(heap_pos));
                                 },
                                 Method::Length => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value_heap_pos = value.get_heap_pos();
                                     let value = self.store.maybe_read_ref(&value);
                                     let heap_pos = match value {
                                         Value::Array(pos) => *pos,
                                         Value::String(pos) => *pos,
                                         _ => unreachable!("length(...) on {:?}", value),
                                     };
                                     let len = self.store.heap_regions[heap_pos as usize].values.len();
                                     // TODO: @PtrInt
                                     cur_frame.expr_values.push_back(Value::UInt32(len as u32));
                                     self.store.drop_value(value_heap_pos);
                                 },
                                 Method::Assert => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value = self.store.maybe_read_ref(&value).clone();
                                     if !value.as_bool() {
                                         return Ok(EvalContinuation::Inconsistent)
+                                    }
                                 },
                                 Method::UserComponent => {
                                     // This is actually handled by the evaluation
                                     // of the statement.
                                     debug_assert_eq!(heap[expr.definition].parameters().len(), cur_frame.expr_values.len());
                                     debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this)
                                 },
                                 Method::UserFunction => {
                                     // Push a new frame. Note that all expressions have
                                     // been pushed to the front, so they're in the order
                                     // of the definition.
                                     let num_args = expr.arguments.len();
                                     // Determine stack boundaries
                                     let cur_stack_boundary = self.store.cur_stack_boundary;
                                     let new_stack_boundary = self.store.stack.len();
                                     // Push new boundary and function arguments for new frame
                                     self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));
                                     for _ in 0..num_args {
                                         let argument = self.store.read_take_ownership(cur_frame.expr_values.pop_front().unwrap());
                                         self.store.stack.push(argument);
+                                    }
                                     // Determine the monomorph index of the function we're calling
                                     let mono_data = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                                     let call_data = &mono_data.expr_data[expr.unique_id_in_definition as usize];
                                     // Push the new frame and reserve its stack size
                                     let new_frame = Frame::new(heap, expr.definition, call_data.field_or_monomorph_idx);
                                     let new_stack_size = new_frame.max_stack_size;
                                     self.frames.push(new_frame);
                                     self.store.cur_stack_boundary = new_stack_boundary;
                                     self.store.reserve_stack(new_stack_size);
                                     // To simplify the logic a little bit we will now
                                     // return and ask our caller to call us again
                                     return Ok(EvalContinuation::Stepping);
                                 },
+                            }
                         },
                         Expression::Variable(expr) => {
                             let variable = &heap[expr.declaration.unwrap()];
                             let ref_value = if expr.used_as_binding_target {
                                 Value::Binding(variable.unique_id_in_scope as StackPos)
                             } else {
                                 Value::Ref(ValueId::Stack(variable.unique_id_in_scope as StackPos))
                             };
                             cur_frame.expr_values.push_back(ref_value);
+                        }
+                    }
+                }
+            }
+        }
         debug_log!("Frame [{:?}] at {:?}", cur_frame.definition, cur_frame.position);
         if debug_enabled!() {
             debug_log!("Expression value stack (size = {}):", cur_frame.expr_values.len());
             for (_stack_idx, _stack_val) in cur_frame.expr_values.iter().enumerate() {
                 debug_log!("  [{:03}] {:?}", _stack_idx, _stack_val);
+            }
             debug_log!("Stack (size = {}):", self.store.stack.len());
             for (_stack_idx, _stack_val) in self.store.stack.iter().enumerate() {
                 debug_log!("  [{:03}] {:?}", _stack_idx, _stack_val);
+            }
             debug_log!("Heap:");
             for (_heap_idx, _heap_region) in self.store.heap_regions.iter().enumerate() {
                 let _is_free = self.store.free_regions.iter().any(|idx| *idx as usize == _heap_idx);
-                debug_log!("  [{:03}] in_use: {}, len: {}, vals: {:?}", _heap_idx, !_is_free, heap_region.values.len(), &_heap_region.values);
+                debug_log!("  [{:03}] in_use: {}, len: {}, vals: {:?}", _heap_idx, !_is_free, _heap_region.values.len(), &_heap_region.values);
+            }
+        }
         // No (more) expressions to evaluate. So evaluate statement (that may
         // depend on the result on the last evaluated expression(s))
         let stmt = &heap[cur_frame.position];
         let return_value = match stmt {
             Statement::Block(stmt) => {
                 debug_assert!(stmt.statements.is_empty() || stmt.next == stmt.statements[0]);
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndBlock(stmt) => {
                 let block = &heap[stmt.start_block];
                 self.store.clear_stack(block.first_unique_id_in_scope as usize);
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         cur_frame.position = stmt.next;
                     },
                     LocalStatement::Channel(stmt) => {
                         let [from_value, to_value] = ctx.new_channel();
                         self.store.write(ValueId::Stack(heap[stmt.from].unique_id_in_scope as u32), from_value);
                         self.store.write(ValueId::Stack(heap[stmt.to].unique_id_in_scope as u32), to_value);
                         cur_frame.position = stmt.next;
+                    }
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Labeled(stmt) => {
                 cur_frame.position = stmt.body;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::If(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for if statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap();
                 let test_value = self.store.maybe_read_ref(&test_value).as_bool();
                 if test_value {
                     cur_frame.position = stmt.true_body.upcast();
                 } else if let Some(false_body) = stmt.false_body {
                     cur_frame.position = false_body.upcast();
                 } else {
                     // Not true, and no false body
                     cur_frame.position = stmt.end_if.upcast();
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndIf(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::While(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for while statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap();
                 let test_value = self.store.maybe_read_ref(&test_value).as_bool();
                 if test_value {
                     cur_frame.position = stmt.body.upcast();
                 } else {
                     cur_frame.position = stmt.end_while.upcast();
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndWhile(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Break(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Continue(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Synchronous(stmt) => {
                 cur_frame.position = stmt.body.upcast();
                 Ok(EvalContinuation::SyncBlockStart)
             },
             Statement::EndSynchronous(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::SyncBlockEnd)
             },
             Statement::Return(_stmt) => {
                 debug_assert!(heap[cur_frame.definition].is_function());
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");
                 // The preceding frame has executed a call, so is expecting the
                 // return expression on its expression value stack. Note that
                 // we may be returning a reference to something on our stack,
                 // so we need to read that value and clone it.
                 let return_value = cur_frame.expr_values.pop_back().unwrap();
                 let return_value = match return_value {
                     Value::Ref(value_id) => self.store.read_copy(value_id),
                     _ => return_value,
                 };
                 // Pre-emptively pop our stack frame
                 self.frames.pop();
                 // Clean up our section of the stack
                 self.store.clear_stack(0);
                 self.store.stack.truncate(self.store.cur_stack_boundary + 1);
                 let prev_stack_idx = self.store.stack.pop().unwrap().as_stack_boundary();
                 // TODO: Temporary hack for testing, remove at some point
                 if self.frames.is_empty() {
                     debug_assert!(prev_stack_idx == -1);
                     debug_assert!(self.store.stack.len() == 0);
                     self.store.stack.push(return_value);
                     return Ok(EvalContinuation::Terminal);
+                }
                 debug_assert!(prev_stack_idx >= 0);
                 // Return to original state of stack frame
                 self.store.cur_stack_boundary = prev_stack_idx as usize;
                 let cur_frame = self.frames.last_mut().unwrap();
                 cur_frame.expr_values.push_back(return_value);
                 // We just returned to the previous frame, which might be in
                 // the middle of evaluating expressions for a particular
                 // statement. So we don't want to enter the code below.
                 return Ok(EvalContinuation::Stepping);
             },
             Statement::Goto(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert!(heap[call_expr.definition].is_component());
                 debug_assert_eq!(
                     cur_frame.expr_values.len(), heap[call_expr.definition].parameters().len(),
                     "mismatch in expr stack size and number of arguments for new statement"
                 );
                 let mono_data = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                 let expr_data = &mono_data.expr_data[call_expr.unique_id_in_definition as usize];
                 // Note that due to expression value evaluation they exist in
                 // reverse order on the stack.
                 // TODO: Revise this code, keep it as is to be compatible with current runtime
                 let mut args = Vec::new();
                 while let Some(value) = cur_frame.expr_values.pop_front() {
                     args.push(value);
+                }
                 // Construct argument group, thereby copying heap regions
                 let argument_group = ValueGroup::from_store(&self.store, &args);
                 // Clear any heap regions
                 for arg in &args {
                     self.store.drop_value(arg.get_heap_pos());
+                }
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::NewComponent(call_expr.definition, expr_data.field_or_monomorph_idx, argument_group))
             },
             Statement::Expression(stmt) => {
                 // The expression has just been completely evaluated. Some
                 // values might have remained on the expression value stack.
                 // cur_frame.expr_values.clear(); PROPER CLEARING
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
         };
         assert!(
             cur_frame.expr_values.is_empty(),
             "This is a debugging assertion that will fail if you perform expressions without \
             assigning to anything. This should be completely valid, and this assertion should be \
             replaced by something that clears the expression values if needed, but I'll keep this \
             in for now for debugging purposes."
         );

src/protocol/eval/value.rs

➞

Show inline comments

 impl_union_unpack_as_value!(as_output,  Value::Output,  PortId);
 impl_union_unpack_as_value!(as_message, Value::Message, HeapPos);
 impl_union_unpack_as_value!(as_bool,    Value::Bool,    bool);
 impl_union_unpack_as_value!(as_char,    Value::Char,    char);
 impl_union_unpack_as_value!(as_string,  Value::String,  HeapPos);
 impl_union_unpack_as_value!(as_uint8,   Value::UInt8,   u8);
 impl_union_unpack_as_value!(as_uint16,  Value::UInt16,  u16);
 impl_union_unpack_as_value!(as_uint32,  Value::UInt32,  u32);
 impl_union_unpack_as_value!(as_uint64,  Value::UInt64,  u64);
 impl_union_unpack_as_value!(as_sint8,   Value::SInt8,   i8);
 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_enum,    Value::Enum,    i64);
 impl_union_unpack_as_value!(as_struct,  Value::Struct,  HeapPos);
 impl Value {
     pub(crate) fn as_union(&self) -> (i64, HeapPos) {
         match self {
             Value::Union(tag, v) => (*tag, *v),
             _ => panic!("called as_union on {:?}", self),
+        }
+    }
     pub(crate) fn is_integer(&self) -> bool {
         match self {
             Value::UInt8(_) | Value::UInt16(_) | Value::UInt32(_) | Value::UInt64(_) |
             Value::SInt8(_) | Value::SInt16(_) | Value::SInt32(_) | Value::SInt64(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn is_unsigned_integer(&self) -> bool {
         match self {
             Value::UInt8(_) | Value::UInt16(_) | Value::UInt32(_) | Value::UInt64(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn is_signed_integer(&self) -> bool {
         match self {
             Value::SInt8(_) | Value::SInt16(_) | Value::SInt32(_) | Value::SInt64(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn as_unsigned_integer(&self) -> u64 {
         match self {
             Value::UInt8(v)  => *v as u64,
             Value::UInt16(v) => *v as u64,
             Value::UInt32(v) => *v as u64,
             Value::UInt64(v) => *v as u64,
             _ => unreachable!("called as_unsigned_integer on {:?}", self),
+        }
+    }
     pub(crate) fn as_signed_integer(&self) -> i64 {
         match self {
             Value::SInt8(v)  => *v as i64,
             Value::SInt16(v) => *v as i64,
             Value::SInt32(v) => *v as i64,
             Value::SInt64(v) => *v as i64,
             _ => unreachable!("called as_signed_integer on {:?}", self)
+        }
+    }
     /// Returns the heap position associated with the value. If the value
     /// doesn't store anything in the heap then we return `None`.
     pub(crate) fn get_heap_pos(&self) -> Option<HeapPos> {
         match self {
             Value::Message(v) => Some(*v),
             Value::Array(v) => Some(*v),
             Value::Union(_, v) => Some(*v),
             Value::Struct(v) => Some(*v),
             _ => None
+        }
+    }
+}
 /// When providing arguments to a new component, or when transferring values
 /// from one component's store to a newly instantiated component, one has to
 /// transfer stack and heap values. This `ValueGroup` represents such a
 /// temporary group of values with potential heap allocations.
 ///
 /// Constructing such a ValueGroup manually requires some extra care to make
 /// sure all elements of `values` point to valid elements of `regions`.
 ///
 /// Again: this is a temporary thing, hopefully removed once we move to a
 /// bytecode interpreter.
 pub struct ValueGroup {
     pub(crate) values: Vec<Value>,
     pub(crate) regions: Vec<Vec<Value>>
+}
 impl ValueGroup {
     pub(crate) fn new_stack(values: Vec<Value>) -> Self {
         debug_assert!(values.iter().all(|v| v.get_heap_pos().is_none()));
         Self{
             values,
             regions: Vec::new(),
+        }
+    }
     pub(crate) fn from_store(store: &Store, values: &[Value]) -> Self {
         let mut group = ValueGroup{
             values: Vec::with_capacity(values.len()),
             regions: Vec::with_capacity(values.len()), // estimation
         };
         for value in values {
             let transferred = group.retrieve_value(value, store);
             group.values.push(transferred);
+        }
         group
+    }
     /// Transfers a provided value from a store into a local value with its
     /// heap allocations (if any) stored in the ValueGroup. Calling this
     /// function will not store the returned value in the `values` member.
     fn retrieve_value(&mut self, value: &Value, from_store: &Store) -> Value {
         let value = from_store.maybe_read_ref(value);
         if let Some(heap_pos) = value.get_heap_pos() {
             // Value points to a heap allocation, so transfer the heap values
             // internally.
             let from_region = &from_store.heap_regions[heap_pos as usize].values;
             let mut new_region = Vec::with_capacity(from_region.len());
             for value in from_region {
                 let transferred = self.retrieve_value(value, from_store);
                 new_region.push(transferred);
+            }
             // Region is constructed, store internally and return the new value.
             let new_region_idx = self.regions.len() as HeapPos;
             self.regions.push(new_region);
             return match value {
                 Value::Message(_)    => Value::Message(new_region_idx),
                 Value::String(_)     => Value::String(new_region_idx),
                 Value::Array(_)      => Value::Array(new_region_idx),
                 Value::Union(tag, _) => Value::Union(*tag, new_region_idx),
                 Value::Struct(_)     => Value::Struct(new_region_idx),
                 _ => unreachable!(),
             };
         } else {
             return value.clone();
+        }
+    }
     /// Transfers the heap values and the stack values into the store. Stack
     /// values are pushed onto the Store's stack in the order in which they
     /// appear in the value group.
     pub(crate) fn into_store(self, store: &mut Store) {
         for value in &self.values {
             let transferred = self.provide_value(value, store);
             store.stack.push(transferred);
+        }
+    }
     fn provide_value(&self, value: &Value, to_store: &mut Store) -> Value {
         if let Some(from_heap_pos) = value.get_heap_pos() {
             let from_heap_pos = from_heap_pos as usize;
             let to_heap_pos = to_store.alloc_heap();
             let to_heap_pos_usize = to_heap_pos as usize;
             to_store.heap_regions[to_heap_pos_usize].values.reserve(self.regions[from_heap_pos].len());
             for value in &self.regions[from_heap_pos as usize] {
                 let transferred = self.provide_value(value, to_store);
                 to_store.heap_regions[to_heap_pos_usize].values.push(transferred);
+            }
             return match value {
                 Value::Message(_)    => Value::Message(to_heap_pos),
                 Value::String(_)     => Value::String(to_heap_pos),
                 Value::Array(_)      => Value::Array(to_heap_pos),
                 Value::Union(tag, _) => Value::Union(*tag, to_heap_pos),
                 Value::Struct(_)     => Value::Struct(to_heap_pos),
                 _ => unreachable!(),
             };
         } else {
             return value.clone();
+        }
+    }
+}
 impl Default for ValueGroup {
     /// Returns an empty ValueGroup
     fn default() -> Self {
         Self { values: Vec::new(), regions: Vec::new() }
+    }
+}
 enum ValueKind { Message, String, Array }
 pub(crate) fn apply_assignment_operator(store: &mut Store, lhs: ValueId, op: AssignmentOperator, rhs: Value) {
     use AssignmentOperator as AO;
     macro_rules! apply_int_op {
         ($lhs:ident, $assignment_tokens:tt, $operator:ident, $rhs:ident) => {
             match $lhs {
                 Value::UInt8(v)  => { *v $assignment_tokens $rhs.as_uint8();  },
                 Value::UInt16(v) => { *v $assignment_tokens $rhs.as_uint16(); },
                 Value::UInt32(v) => { *v $assignment_tokens $rhs.as_uint32(); },
                 Value::UInt64(v) => { *v $assignment_tokens $rhs.as_uint64(); },
                 Value::SInt8(v)  => { *v $assignment_tokens $rhs.as_sint8();  },
                 Value::SInt16(v) => { *v $assignment_tokens $rhs.as_sint16(); },
                 Value::SInt32(v) => { *v $assignment_tokens $rhs.as_sint32(); },
                 Value::SInt64(v) => { *v $assignment_tokens $rhs.as_sint64(); },
                 _ => unreachable!("apply_assignment_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs),
+            }
+        }
+    }
     // let rhs = store.maybe_read_ref(&rhs).clone(); // we don't own this thing, so don't drop it
     let lhs = store.read_mut_ref(lhs);
     let mut to_dealloc = None;
     match op {
         AO::Set => {
             match lhs {
                 Value::Unassigned => { *lhs = rhs; },
                 Value::Input(v)  => { *v = rhs.as_input(); },
                 Value::Output(v) => { *v = rhs.as_output(); },
                 Value::Message(v)  => { to_dealloc = Some(*v); *v = rhs.as_message(); },
                 Value::Bool(v)    => { *v = rhs.as_bool(); },
                 Value::Char(v) => { *v = rhs.as_char(); },
                 Value::String(v) => { *v = rhs.as_string().clone(); },
                 Value::UInt8(v) => { *v = rhs.as_uint8(); },
                 Value::UInt16(v) => { *v = rhs.as_uint16(); },
                 Value::UInt32(v) => { *v = rhs.as_uint32(); },
                 Value::UInt64(v) => { *v = rhs.as_uint64(); },
                 Value::SInt8(v) => { *v = rhs.as_sint8(); },
                 Value::SInt16(v) => { *v = rhs.as_sint16(); },
                 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::Enum(v) => { *v = rhs.as_enum(); },
                 Value::Union(lhs_tag, lhs_heap_pos) => {
                     to_dealloc = Some(*lhs_heap_pos);
                     let (rhs_tag, rhs_heap_pos) = rhs.as_union();
                     *lhs_tag = rhs_tag;
                     *lhs_heap_pos = rhs_heap_pos;
+                }
                 Value::Struct(v) => { to_dealloc = Some(*v); *v = rhs.as_struct(); },
                 _ => unreachable!("apply_assignment_operator {:?} on lhs {:?} and rhs {:?}", op, lhs, rhs),
+            }
         },
         AO::Concatenated => {
             let lhs_heap_pos = lhs.get_heap_pos().unwrap() as usize;
             let rhs_heap_pos = rhs.get_heap_pos().unwrap() as usize;
             // To prevent borrowing crap, swap out heap region with a temp empty array
             let mut total = Vec::new();
             std::mem::swap(&mut total, &mut store.heap_regions[lhs_heap_pos].values);
             // Push everything onto the swapped vector
             let rhs_len = store.heap_regions[rhs_heap_pos].values.len();
             total.reserve(rhs_len);
             for value_idx in 0..rhs_len {
                 total.push(store.clone_value(store.heap_regions[rhs_heap_pos].values[value_idx].clone()));
+            }
             // Swap back in place
             std::mem::swap(&mut total, &mut store.heap_regions[lhs_heap_pos].values);
             // We took ownership of the RHS, but we copied it into the LHS, so
             // different form assignment we need to drop the RHS heap pos.
             to_dealloc = Some(rhs_heap_pos as u32);
         },
         AO::Multiplied =>   { apply_int_op!(lhs, *=,  op, rhs) },
         AO::Divided =>      { apply_int_op!(lhs, /=,  op, rhs) },
         AO::Remained =>     { apply_int_op!(lhs, %=,  op, rhs) },
         AO::Added =>        { apply_int_op!(lhs, +=,  op, rhs) },
         AO::Subtracted =>   { apply_int_op!(lhs, -=,  op, rhs) },
         AO::ShiftedLeft =>  { apply_int_op!(lhs, <<=, op, rhs) },
         AO::ShiftedRight => { apply_int_op!(lhs, >>=, op, rhs) },
         AO::BitwiseAnded => { apply_int_op!(lhs, &=,  op, rhs) },
         AO::BitwiseXored => { apply_int_op!(lhs, ^=,  op, rhs) },
         AO::BitwiseOred =>  { apply_int_op!(lhs, |=,  op, rhs) },
+    }
     if let Some(heap_pos) = to_dealloc {
         store.drop_heap_pos(heap_pos);
+    }
+}
 pub(crate) fn apply_binary_operator(store: &mut Store, lhs: &Value, op: BinaryOperator, rhs: &Value) -> Value {
     use BinaryOperator as BO;
     macro_rules! apply_int_op_and_return_self {
         ($lhs:ident, $operator_tokens:tt, $operator:ident, $rhs:ident) => {
             return match $lhs {
                 Value::UInt8(v)  => { Value::UInt8( *v $operator_tokens $rhs.as_uint8() ) },
                 Value::UInt16(v) => { Value::UInt16(*v $operator_tokens $rhs.as_uint16()) },
                 Value::UInt32(v) => { Value::UInt32(*v $operator_tokens $rhs.as_uint32()) },
                 Value::UInt64(v) => { Value::UInt64(*v $operator_tokens $rhs.as_uint64()) },
                 Value::SInt8(v)  => { Value::SInt8( *v $operator_tokens $rhs.as_sint8() ) },
                 Value::SInt16(v) => { Value::SInt16(*v $operator_tokens $rhs.as_sint16()) },
                 Value::SInt32(v) => { Value::SInt32(*v $operator_tokens $rhs.as_sint32()) },
                 Value::SInt64(v) => { Value::SInt64(*v $operator_tokens $rhs.as_sint64()) },
                 _ => unreachable!("apply_binary_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs)
             };
+        }
+    }
     macro_rules! apply_int_op_and_return_bool {
         ($lhs:ident, $operator_tokens:tt, $operator:ident, $rhs:ident) => {
             return match $lhs {
                 Value::UInt8(v)  => { Value::Bool(*v $operator_tokens $rhs.as_uint8() ) },
                 Value::UInt16(v) => { Value::Bool(*v $operator_tokens $rhs.as_uint16()) },
                 Value::UInt32(v) => { Value::Bool(*v $operator_tokens $rhs.as_uint32()) },
                 Value::UInt64(v) => { Value::Bool(*v $operator_tokens $rhs.as_uint64()) },
                 Value::SInt8(v)  => { Value::Bool(*v $operator_tokens $rhs.as_sint8() ) },
                 Value::SInt16(v) => { Value::Bool(*v $operator_tokens $rhs.as_sint16()) },
                 Value::SInt32(v) => { Value::Bool(*v $operator_tokens $rhs.as_sint32()) },
                 Value::SInt64(v) => { Value::Bool(*v $operator_tokens $rhs.as_sint64()) },
                 _ => unreachable!("apply_binary_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs)
             };
+        }
+    }
     // We need to handle concatenate in a special way because it needs the store
     // mutably.
     if op == BO::Concatenate {
         let target_heap_pos = store.alloc_heap();
         let lhs_heap_pos;
         let rhs_heap_pos;
         let lhs = store.maybe_read_ref(lhs);
         let rhs = store.maybe_read_ref(rhs);
         enum ValueKind { Message, String, Array }
         let value_kind;
         match lhs {
             Value::Message(lhs_pos) => {
                 lhs_heap_pos = *lhs_pos;
                 rhs_heap_pos = rhs.as_message();
                 value_kind = ValueKind::Message;
             },
             Value::String(lhs_pos) => {
                 lhs_heap_pos = *lhs_pos;
                 rhs_heap_pos = rhs.as_string();
                 value_kind = ValueKind::String;
             },
             Value::Array(lhs_pos) => {
                 lhs_heap_pos = *lhs_pos;
                 rhs_heap_pos = rhs.as_array();
                 value_kind = ValueKind::Array;
             },
             _ => unreachable!("apply_binary_operator {:?} on lhs {:?} and rhs {:?}", op, lhs, rhs)
+        }
         let lhs_heap_pos = lhs_heap_pos as usize;
         let rhs_heap_pos = rhs_heap_pos as usize;
         // TODO: I hate this, but fine...
         let mut concatenated = Vec::new();
         let lhs_len = store.heap_regions[lhs_heap_pos].values.len();
         let rhs_len = store.heap_regions[rhs_heap_pos].values.len();
         concatenated.reserve(lhs_len + rhs_len);
         for idx in 0..lhs_len {
             concatenated.push(store.clone_value(store.heap_regions[lhs_heap_pos].values[idx].clone()));
+        }
         for idx in 0..rhs_len {
             concatenated.push(store.clone_value(store.heap_regions[rhs_heap_pos].values[idx].clone()));
+        }
         store.heap_regions[target_heap_pos as usize].values = concatenated;
         return match value_kind{
             ValueKind::Message => Value::Message(target_heap_pos),
             ValueKind::String => Value::String(target_heap_pos),
             ValueKind::Array => Value::Array(target_heap_pos),
         };
+    }
     // If any of the values are references, retrieve the thing they're referring
     // to.
     let lhs = store.maybe_read_ref(lhs);
     let rhs = store.maybe_read_ref(rhs);
     match op {
         BO::Concatenate => unreachable!(),
         BO::LogicalOr => {
             return Value::Bool(lhs.as_bool() || rhs.as_bool());
         },
         BO::LogicalAnd => {
             return Value::Bool(lhs.as_bool() && rhs.as_bool());
         },
         BO::BitwiseOr        => { apply_int_op_and_return_self!(lhs, |,  op, rhs); },
         BO::BitwiseXor       => { apply_int_op_and_return_self!(lhs, ^,  op, rhs); },
         BO::BitwiseAnd       => { apply_int_op_and_return_self!(lhs, &,  op, rhs); },
         BO::Equality         => { Value::Bool(apply_equality_operator(store, lhs, rhs)) },
         BO::Inequality       => { Value::Bool(apply_inequality_operator(store, lhs, rhs)) },
         BO::LessThan         => { apply_int_op_and_return_bool!(lhs, <,  op, rhs); },
         BO::GreaterThan      => { apply_int_op_and_return_bool!(lhs, >,  op, rhs); },
         BO::LessThanEqual    => { apply_int_op_and_return_bool!(lhs, <=, op, rhs); },
         BO::GreaterThanEqual => { apply_int_op_and_return_bool!(lhs, >=, op, rhs); },
         BO::ShiftLeft        => { apply_int_op_and_return_self!(lhs, <<, op, rhs); },
         BO::ShiftRight       => { apply_int_op_and_return_self!(lhs, >>, op, rhs); },
         BO::Add              => { apply_int_op_and_return_self!(lhs, +,  op, rhs); },
         BO::Subtract         => { apply_int_op_and_return_self!(lhs, -,  op, rhs); },
         BO::Multiply         => { apply_int_op_and_return_self!(lhs, *,  op, rhs); },
         BO::Divide           => { apply_int_op_and_return_self!(lhs, /,  op, rhs); },
         BO::Remainder        => { apply_int_op_and_return_self!(lhs, %,  op, rhs); }
+    }
+}
 pub(crate) fn apply_unary_operator(store: &mut Store, op: UnaryOperator, value: &Value) -> Value {
     use UnaryOperator as UO;
     macro_rules! apply_int_expr_and_return {
         ($value:ident, $apply:tt, $op:ident) => {
             return match $value {
                 Value::UInt8(v)  => Value::UInt8($apply *v),
                 Value::UInt16(v) => Value::UInt16($apply *v),
                 Value::UInt32(v) => Value::UInt32($apply *v),
                 Value::UInt64(v) => Value::UInt64($apply *v),
                 Value::SInt8(v)  => Value::SInt8($apply *v),
                 Value::SInt16(v) => Value::SInt16($apply *v),
                 Value::SInt32(v) => Value::SInt32($apply *v),
                 Value::SInt64(v) => Value::SInt64($apply *v),
                 _ => unreachable!("apply_unary_operator {:?} on value {:?}", $op, $value),
             };
+        }
+    }
     // If the value is a reference, retrieve the thing it is referring to
     let value = store.maybe_read_ref(value);
     match op {
         UO::Positive => {
             debug_assert!(value.is_integer());
             return value.clone();
         },
         UO::Negative => {
             // TODO: Error on negating unsigned integers
             return match value {
                 Value::SInt8(v) => Value::SInt8(-*v),
                 Value::SInt16(v) => Value::SInt16(-*v),
                 Value::SInt32(v) => Value::SInt32(-*v),
                 Value::SInt64(v) => Value::SInt64(-*v),
                 _ => unreachable!("apply_unary_operator {:?} on value {:?}", op, value),
+            }
         },
         UO::BitwiseNot => { apply_int_expr_and_return!(value, !, op)},
         UO::LogicalNot => { return Value::Bool(!value.as_bool()); },
+    }
+}
 pub(crate) fn apply_casting(store: &mut Store, output_type: &ConcreteType, subject: &Value) -> Result<Value, String> {
     // To simplify the casting logic: if the output type is not a simple
     // integer/boolean/character, then the type checker made sure that the two
     // types must be equal, hence we can do a simple clone.
     use ConcreteTypePart as CTP;
     let part = &output_type.parts[0];
     match part {
         CTP::Bool | CTP::Character |
         CTP::UInt8 | CTP::UInt16 | CTP::UInt32 | CTP::UInt64 |
         CTP::SInt8 | CTP::SInt16 | CTP::SInt32 | CTP::SInt64 => {
             // Do the checking of these below
             debug_assert_eq!(output_type.parts.len(), 1);
         },
         _ => {
             return Ok(store.clone_value(subject.clone()));
         },
+    }
     // Note: character is not included, needs per-type checking
     macro_rules! unchecked_cast {
         ($input: expr, $output_part: expr) => {
             return Ok(match $output_part {
                 CTP::UInt8 => Value::UInt8($input as u8),
                 CTP::UInt16 => Value::UInt16($input as u16),
                 CTP::UInt32 => Value::UInt32($input as u32),
                 CTP::UInt64 => Value::UInt64($input as u64),
                 CTP::SInt8 => Value::SInt8($input as i8),
                 CTP::SInt16 => Value::SInt16($input as i16),
                 CTP::SInt32 => Value::SInt32($input as i32),
                 CTP::SInt64 => Value::SInt64($input as i64),
                 _ => unreachable!()
             })
+        }
+    }
     macro_rules! from_unsigned_cast {
         ($input:expr, $input_type:ty, $output_part:expr) => {
+            {
                 let target_type_name = match $output_part {
                     CTP::Bool => return Ok(Value::Bool($input != 0)),
                     CTP::Character => if $input <= u8::MAX as $input_type {
                         return Ok(Value::Char(($input as u8) as char))
                     } else {
                         KW_TYPE_CHAR_STR
                     },
                     CTP::UInt8 => if $input <= u8::MAX as $input_type {
                         return Ok(Value::UInt8($input as u8))
                     } else {
                         KW_TYPE_UINT8_STR
                     },
                     CTP::UInt16 => if $input <= u16::MAX as $input_type {
                         return Ok(Value::UInt16($input as u16))
                     } else {
                         KW_TYPE_UINT16_STR
                     },
                     CTP::UInt32 => if $input <= u32::MAX as $input_type {
                         return Ok(Value::UInt32($input as u32))
                     } else {
                         KW_TYPE_UINT32_STR
                     },
                     CTP::UInt64 => return Ok(Value::UInt64($input as u64)), // any unsigned int to u64 is fine
                     CTP::SInt8 => if $input <= i8::MAX as $input_type {
                         return Ok(Value::SInt8($input as i8))
                     } else {
                         KW_TYPE_SINT8_STR
                     },
                     CTP::SInt16 => if $input <= i16::MAX as $input_type {
                         return Ok(Value::SInt16($input as i16))
                     } else {
                         KW_TYPE_SINT16_STR
                     },
                     CTP::SInt32 => if $input <= i32::MAX as $input_type {
                         return Ok(Value::SInt32($input as i32))

src/protocol/parser/mod.rs

➞

Show inline comments

 pub(crate) mod symbol_table;
 pub(crate) mod type_table;
 pub(crate) mod tokens;
 pub(crate) mod token_parsing;
 pub(crate) mod pass_tokenizer;
 pub(crate) mod pass_symbols;
 pub(crate) mod pass_imports;
 pub(crate) mod pass_definitions;
 pub(crate) mod pass_validation_linking;
 pub(crate) mod pass_typing;
 mod visitor;
 use tokens::*;
 use crate::collections::*;
 use visitor::Visitor;
 use pass_tokenizer::PassTokenizer;
 use pass_symbols::PassSymbols;
 use pass_imports::PassImport;
 use pass_definitions::PassDefinitions;
 use pass_validation_linking::PassValidationLinking;
 use pass_typing::{PassTyping, ResolveQueue};
 use symbol_table::*;
 use type_table::TypeTable;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::ast_printer::ASTWriter;
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ModuleCompilationPhase {
     Tokenized,              // source is tokenized
     SymbolsScanned,         // all definitions are linked to their type class
     ImportsResolved,        // all imports are added to the symbol table
     DefinitionsParsed,      // produced the AST for the entire module
     TypesAddedToTable,      // added all definitions to the type table
     ValidatedAndLinked,     // AST is traversed and has linked the required AST nodes
     // When we continue with the compiler:
     // Typed,                  // Type inference and checking has been performed
+}
 pub struct Module {
     // Buffers
     pub source: InputSource,
     pub tokens: TokenBuffer,
     // Identifiers
     pub root_id: RootId,
     pub name: Option<(PragmaId, StringRef<'static>)>,
     pub version: Option<(PragmaId, i64)>,
     pub phase: ModuleCompilationPhase,
+}
 pub struct PassCtx<'a> {
     heap: &'a mut Heap,
     symbols: &'a mut SymbolTable,
     pool: &'a mut StringPool,
+}
 pub struct Parser {
     // Storage of all information created/gathered during compilation.
     pub(crate) heap: Heap,
     pub(crate) string_pool: StringPool, // Do not deallocate, holds all strings
     pub(crate) modules: Vec<Module>,
     pub(crate) symbol_table: SymbolTable,
     pub(crate) type_table: TypeTable,
     // Compiler passes, used as little state machine that keep their memory
     // around.
     pass_tokenizer: PassTokenizer,
     pass_symbols: PassSymbols,
     pass_import: PassImport,
     pass_definitions: PassDefinitions,
     pass_validation: PassValidationLinking,
     pass_typing: PassTyping,
     // Compiler options
     pub write_ast_to: Option<String>,
+}
 impl Parser {
     pub fn new() -> Self {
         let mut parser = Parser{
             heap: Heap::new(),
             string_pool: StringPool::new(),
             modules: Vec::new(),
             symbol_table: SymbolTable::new(),
             type_table: TypeTable::new(),
             pass_tokenizer: PassTokenizer::new(),
             pass_symbols: PassSymbols::new(),
             pass_import: PassImport::new(),
             pass_definitions: PassDefinitions::new(),
             pass_validation: PassValidationLinking::new(),
             pass_typing: PassTyping::new(),
             write_ast_to: None,
         };
         parser.symbol_table.insert_scope(None, SymbolScope::Global);
         fn quick_type(variants: &[ParserTypeVariant]) -> ParserType {
             let mut t = ParserType{ elements: Vec::with_capacity(variants.len()) };
             for variant in variants {
                 t.elements.push(ParserTypeElement{ full_span: InputSpan::new(), variant: variant.clone() });
+            }
+            t
+        }
         use ParserTypeVariant as PTV;
         insert_builtin_function(&mut parser, "get", &["T"], |id| (
             vec![
                 ("input", quick_type(&[PTV::Input, PTV::PolymorphicArgument(id.upcast(), 0)]))
             ],
             quick_type(&[PTV::PolymorphicArgument(id.upcast(), 0)])
         ));
         insert_builtin_function(&mut parser, "put", &["T"], |id| (
             vec![
                 ("output", quick_type(&[PTV::Output, PTV::PolymorphicArgument(id.upcast(), 0)])),
                 ("value", quick_type(&[PTV::PolymorphicArgument(id.upcast(), 0)])),
             ],
             quick_type(&[PTV::Void])
         ));
         insert_builtin_function(&mut parser, "fires", &["T"], |id| (
             vec![
                 ("port", quick_type(&[PTV::InputOrOutput, PTV::PolymorphicArgument(id.upcast(), 0)]))
             ],
             quick_type(&[PTV::Bool])
         ));
         insert_builtin_function(&mut parser, "create", &["T"], |id| (
             vec![
                 ("length", quick_type(&[PTV::IntegerLike]))
             ],
             quick_type(&[PTV::ArrayLike, PTV::PolymorphicArgument(id.upcast(), 0)])
         ));
         insert_builtin_function(&mut parser, "length", &["T"], |id| (
             vec![
                 ("array", quick_type(&[PTV::ArrayLike, PTV::PolymorphicArgument(id.upcast(), 0)]))
             ],
             quick_type(&[PTV::UInt32]) // TODO: @PtrInt
         ));
         insert_builtin_function(&mut parser, "assert", &[], |_id| (
             vec![
                 ("condition", quick_type(&[PTV::Bool])),
             ],
             quick_type(&[PTV::Void])
         ));
         parser
+    }
     pub fn feed(&mut self, mut source: InputSource) -> Result<(), ParseError> {
         // TODO: @Optimize
         let mut token_buffer = TokenBuffer::new();
         self.pass_tokenizer.tokenize(&mut source, &mut token_buffer)?;
         let module = Module{
             source,
             tokens: token_buffer,
             root_id: RootId::new_invalid(),
             name: None,
             version: None,
             phase: ModuleCompilationPhase::Tokenized,
         };
         self.modules.push(module);
         Ok(())
+    }
     pub fn parse(&mut self) -> Result<(), ParseError> {
         let mut pass_ctx = PassCtx{
             heap: &mut self.heap,
             symbols: &mut self.symbol_table,
             pool: &mut self.string_pool,
         };
         // Advance all modules to the phase where all symbols are scanned
         for module_idx in 0..self.modules.len() {
             self.pass_symbols.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // With all symbols scanned, perform further compilation until we can
         // add all base types to the type table.
         for module_idx in 0..self.modules.len() {
             self.pass_import.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
             self.pass_definitions.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // Add every known type to the type table
         self.type_table.build_base_types(&mut self.modules, &mut pass_ctx)?;
         // Continue compilation with the remaining phases now that the types
         // are all in the type table
         for module_idx in 0..self.modules.len() {
             // TODO: Remove the entire Visitor abstraction. It really doesn't
             //  make sense considering the amount of special handling we do
             //  in each pass.
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module: &mut self.modules[module_idx],
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
             };
             self.pass_validation.visit_module(&mut ctx)?;
+        }
         // Perform typechecking on all modules
         let mut queue = ResolveQueue::new();
         for module in &mut self.modules {
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
             };
             PassTyping::queue_module_definitions(&mut ctx, &mut queue);
         };
         while !queue.is_empty() {
             let top = queue.pop().unwrap();
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module: &mut self.modules[top.root_id.index as usize],
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
             };
             self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;
+        }
         // Write out desired information
         if let Some(filename) = &self.write_ast_to {
             let mut writer = ASTWriter::new();
             let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();
             writer.write_ast(&mut file, &self.heap);
+        }
         Ok(())
+    }
+}
 // Note: args and return type need to be a function because we need to know the function ID.
 fn insert_builtin_function<T: Fn(FunctionDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (
     p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T) {
     let mut poly_vars = Vec::with_capacity(polymorphic.len());
     for poly_var in polymorphic {
         poly_vars.push(Identifier{ span: InputSpan::new(), value: p.string_pool.intern(poly_var.as_bytes()) });
+    }
     let func_ident_ref = p.string_pool.intern(func_name.as_bytes());
     let func_id = p.heap.alloc_function_definition(|this| FunctionDefinition{
         this,
         defined_in: RootId::new_invalid(),
         builtin: true,
         span: InputSpan::new(),
         identifier: Identifier{ span: InputSpan::new(), value: func_ident_ref.clone() },
         poly_vars,
         return_types: Vec::new(),
         parameters: Vec::new(),
         body: BlockStatementId::new_invalid(),
         num_expressions_in_body: -1,
     });
     let (args, ret) = arg_and_return_fn(func_id);
     let mut parameters = Vec::with_capacity(args.len());
     for (arg_name, arg_type) in args {
         let identifier = Identifier{ span: InputSpan::new(), value: p.string_pool.intern(arg_name.as_bytes()) };
         let param_id = p.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Parameter,
             parser_type: arg_type.clone(),
             identifier,
             relative_pos_in_block: 0,
             unique_id_in_scope: 0
         });
         parameters.push(param_id);
+    }
     let func = &mut p.heap[func_id];
     func.parameters = parameters;
     func.return_types.push(ret);
     p.symbol_table.insert_symbol(SymbolScope::Global, Symbol{
         name: func_ident_ref,
         variant: SymbolVariant::Definition(SymbolDefinition{
             defined_in_module: RootId::new_invalid(),
             defined_in_scope: SymbolScope::Global,
             definition_span: InputSpan::new(),
             identifier_span: InputSpan::new(),
             imported_at: None,
             class: DefinitionClass::Function,
             definition_id: func_id.upcast(),
         })
     }).unwrap();
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -727,384 +727,385 @@ impl PassDefinitions { @@
         from_port_type.elements.extend_from_slice(&inner_port_type.elements);
         let from = ctx.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Local,
             identifier: from_identifier,
             parser_type: from_port_type,
             relative_pos_in_block: 0,
             unique_id_in_scope: -1,
         });
         let mut to_port_type = ParserType{ elements: Vec::with_capacity(port_type_len) };
         to_port_type.elements.push(ParserTypeElement{ full_span: channel_span, variant: ParserTypeVariant::Input });
         to_port_type.elements.extend_from_slice(&inner_port_type.elements);
         let to = ctx.heap.alloc_variable(|this|Variable{
             this,
             kind: VariableKind::Local,
             identifier: to_identifier,
             parser_type: to_port_type,
             relative_pos_in_block: 0,
             unique_id_in_scope: -1,
         });
         // Construct the channel
         Ok(ctx.heap.alloc_channel_statement(|this| ChannelStatement{
             this,
             span: channel_span,
             from, to,
             relative_pos_in_block: 0,
             next: StatementId::new_invalid(),
         }))
+    }
     fn consume_labeled_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, section: &mut ScopedSection<StatementId>
     ) -> Result<(), ParseError> {
         let label = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::Colon)?;
         // Not pretty: consume_statement may produce more than one statement.
         // The values in the section need to be in the correct order if some
         // kind of outer block is consumed, so we take another section, push
         // the expressions in that one, and then allocate the labeled statement.
         let mut inner_section = self.statements.start_section();
         self.consume_statement(module, iter, ctx, &mut inner_section)?;
         debug_assert!(inner_section.len() >= 1);
         let stmt_id = ctx.heap.alloc_labeled_statement(|this| LabeledStatement {
             this,
             label,
             body: inner_section[0],
             relative_pos_in_block: 0,
             in_sync: SynchronousStatementId::new_invalid(),
         });
         if inner_section.len() == 1 {
             // Produce the labeled statement pointing to the first statement.
             // This is by far the most common case.
             inner_section.forget();
             section.push(stmt_id.upcast());
         } else {
             // Produce the labeled statement using the first statement, and push
             // the remaining ones at the end.
             let inner_statements = inner_section.into_vec();
             section.push(stmt_id.upcast());
             for idx in 1..inner_statements.len() {
                 section.push(inner_statements[idx])
+            }
+        }
         Ok(())
+    }
     fn maybe_consume_memory_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<Option<(MemoryStatementId, ExpressionStatementId)>, ParseError> {
         // This is a bit ugly. It would be nicer if we could somehow
         // consume the expression with a type hint if we do get a valid
         // type, but we don't get an identifier following it
         let iter_state = iter.save();
         let definition_id = self.cur_definition;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         let parser_type = consume_parser_type(
             &module.source, iter, &ctx.symbols, &ctx.heap, poly_vars,
             SymbolScope::Definition(definition_id), definition_id, true, 0
         );
         if let Ok(parser_type) = parser_type {
             if Some(TokenKind::Ident) == iter.next() {
                 // Assume this is a proper memory statement
                 let identifier = consume_ident_interned(&module.source, iter, ctx)?;
                 let memory_span = InputSpan::from_positions(parser_type.elements[0].full_span.begin, identifier.span.end);
                 let assign_span = consume_token(&module.source, iter, TokenKind::Equal)?;
                 let initial_expr_begin_pos = iter.last_valid_pos();
                 let initial_expr_id = self.consume_expression(module, iter, ctx)?;
                 let initial_expr_end_pos = iter.last_valid_pos();
                 consume_token(&module.source, iter, TokenKind::SemiColon)?;
                 // Allocate the memory statement with the variable
                 let local_id = ctx.heap.alloc_variable(|this| Variable{
                     this,
                     kind: VariableKind::Local,
                     identifier: identifier.clone(),
                     parser_type,
                     relative_pos_in_block: 0,
                     unique_id_in_scope: -1,
                 });
                 let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
                     this,
                     span: memory_span,
                     variable: local_id,
                     next: StatementId::new_invalid()
                 });
                 // Allocate the initial assignment
                 let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
                     this,
                     identifier,
                     declaration: None,
                     used_as_binding_target: false,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                     this,
                     span: assign_span,
                     left: variable_expr_id.upcast(),
                     operation: AssignmentOperator::Set,
                     right: initial_expr_id,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 let assignment_stmt_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
                     this,
                     span: InputSpan::from_positions(initial_expr_begin_pos, initial_expr_end_pos),
                     expression: assignment_expr_id.upcast(),
                     next: StatementId::new_invalid(),
                 });
                 return Ok(Some((memory_stmt_id, assignment_stmt_id)))
+            }
+        }
         // If here then one of the preconditions for a memory statement was not
         // met. So recover the iterator and return
         iter.load(iter_state);
         Ok(None)
+    }
     fn consume_expression_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionStatementId, ParseError> {
         let start_pos = iter.last_valid_pos();
         let expression = self.consume_expression(module, iter, ctx)?;
         let end_pos = iter.last_valid_pos();
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
             this,
             span: InputSpan::from_positions(start_pos, end_pos),
             expression,
             next: StatementId::new_invalid(),
         }))
+    }
     //--------------------------------------------------------------------------
     // Expression Parsing
     //--------------------------------------------------------------------------
     // TODO: @Cleanup This is fine for now. But I prefer my stacktraces not to
     //  look like enterprise Java code...
     fn consume_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_assignment_expression(module, iter, ctx)
+    }
     fn consume_assignment_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         // Utility to convert token into assignment operator
         fn parse_assignment_operator(token: Option<TokenKind>) -> Option<AssignmentOperator> {
             use TokenKind as TK;
             use AssignmentOperator as AO;
             if token.is_none() {
                 return None
+            }
             match token.unwrap() {
                 TK::Equal               => Some(AO::Set),
                 TK::AtEquals            => Some(AO::Concatenated),
                 TK::StarEquals          => Some(AO::Multiplied),
                 TK::SlashEquals         => Some(AO::Divided),
                 TK::PercentEquals       => Some(AO::Remained),
                 TK::PlusEquals          => Some(AO::Added),
                 TK::MinusEquals         => Some(AO::Subtracted),
                 TK::ShiftLeftEquals     => Some(AO::ShiftedLeft),
                 TK::ShiftRightEquals    => Some(AO::ShiftedRight),
                 TK::AndEquals           => Some(AO::BitwiseAnded),
                 TK::CaretEquals         => Some(AO::BitwiseXored),
                 TK::OrEquals            => Some(AO::BitwiseOred),
                 _                       => None
+            }
+        }
         let expr = self.consume_conditional_expression(module, iter, ctx)?;
         if let Some(operation) = parse_assignment_operator(iter.next()) {
             let span = iter.next_span();
             iter.consume();
             let left = expr;
             let right = self.consume_expression(module, iter, ctx)?;
             Ok(ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                 this, span, left, operation, right,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast())
         } else {
             Ok(expr)
+        }
+    }
     fn consume_conditional_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let result = self.consume_concat_expression(module, iter, ctx)?;
         if let Some(TokenKind::Question) = iter.next() {
             let span = iter.next_span();
             iter.consume();
             let test = result;
             let true_expression = self.consume_expression(module, iter, ctx)?;
             consume_token(&module.source, iter, TokenKind::Colon)?;
             let false_expression = self.consume_expression(module, iter, ctx)?;
             Ok(ctx.heap.alloc_conditional_expression(|this| ConditionalExpression{
                 this, span, test, true_expression, false_expression,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast())
         } else {
             Ok(result)
+        }
+    }
     fn consume_concat_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::At) => Some(BinaryOperator::Concatenate),
                 _ => None
             },
             Self::consume_logical_or_expression
+        )
+    }
     fn consume_logical_or_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::OrOr) => Some(BinaryOperator::LogicalOr),
                 _ => None
             },
             Self::consume_logical_and_expression
+        )
+    }
     fn consume_logical_and_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::AndAnd) => Some(BinaryOperator::LogicalAnd),
                 _ => None
             },
             Self::consume_bitwise_or_expression
+        )
+    }
     fn consume_bitwise_or_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Or) => Some(BinaryOperator::BitwiseOr),
                 _ => None
             },
             Self::consume_bitwise_xor_expression
+        )
+    }
     fn consume_bitwise_xor_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Caret) => Some(BinaryOperator::BitwiseXor),
                 _ => None
             },
             Self::consume_bitwise_and_expression
+        )
+    }
     fn consume_bitwise_and_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::And) => Some(BinaryOperator::BitwiseAnd),
                 _ => None
             },
             Self::consume_equality_expression
+        )
+    }
     fn consume_equality_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::EqualEqual) => Some(BinaryOperator::Equality),
                 Some(TokenKind::NotEqual) => Some(BinaryOperator::Inequality),
                 _ => None
             },
             Self::consume_relational_expression
+        )
+    }
     fn consume_relational_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::OpenAngle) => Some(BinaryOperator::LessThan),
                 Some(TokenKind::CloseAngle) => Some(BinaryOperator::GreaterThan),
                 Some(TokenKind::LessEquals) => Some(BinaryOperator::LessThanEqual),
                 Some(TokenKind::GreaterEquals) => Some(BinaryOperator::GreaterThanEqual),
                 _ => None
             },
             Self::consume_shift_expression
+        )
+    }
     fn consume_shift_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::ShiftLeft) => Some(BinaryOperator::ShiftLeft),
                 Some(TokenKind::ShiftRight) => Some(BinaryOperator::ShiftRight),
                 _ => None
             },
             Self::consume_add_or_subtract_expression
+        )
+    }
     fn consume_add_or_subtract_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Plus) => Some(BinaryOperator::Add),
                 Some(TokenKind::Minus) => Some(BinaryOperator::Subtract),
                 _ => None,
             },
             Self::consume_multiply_divide_or_modulus_expression
+        )
+    }
     fn consume_multiply_divide_or_modulus_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

src/protocol/parser/pass_tokenizer.rs

➞

Show inline comments

@@ @@ -166,385 +166,390 @@ impl PassTokenizer { @@
                 if cur_range.num_child_ranges == 0 {
                     assert_eq!(cur_range.first_child_idx, NO_RELATION);
                     assert_eq!(cur_range.last_child_idx, NO_RELATION);
                 } else {
                     assert_ne!(cur_range.first_child_idx, NO_RELATION);
                     assert_ne!(cur_range.last_child_idx, NO_RELATION);
                     let mut child_counter = 0u32;
                     let mut last_valid_child_idx = cur_range.first_child_idx;
                     let mut child_idx = cur_range.first_child_idx;
                     while child_idx != NO_RELATION {
                         let child_range = &target.ranges[child_idx as usize];
                         assert_eq!(child_range.parent_idx, parent_idx as i32);
                         last_valid_child_idx = child_idx;
                         child_idx = child_range.next_sibling_idx;
                         child_counter += 1;
+                    }
                     assert_eq!(cur_range.last_child_idx, last_valid_child_idx);
                     assert_eq!(cur_range.num_child_ranges, child_counter);
+                }
+            }
+        }
         Ok(())
+    }
     fn is_line_comment_start(&self, first_char: u8, source: &InputSource) -> bool {
         return first_char == b'/' && Some(b'/') == source.lookahead(1);
+    }
     fn is_block_comment_start(&self, first_char: u8, source: &InputSource) -> bool {
         return first_char == b'/' && Some(b'*') == source.lookahead(1);
+    }
     fn maybe_parse_punctuation(
         &mut self, first_char: u8, source: &mut InputSource, target: &mut TokenBuffer
     ) -> Result<Option<(TokenKind, InputPosition)>, ParseError> {
         debug_assert!(first_char != b'#', "'#' needs special handling");
         debug_assert!(first_char != b'\'', "'\'' needs special handling");
         debug_assert!(first_char != b'"', "'\"' needs special handling");
         let pos = source.pos();
         let token_kind;
         if first_char == b'!' {
             source.consume();
             if Some(b'=') == source.next() {
                 source.consume();
                 token_kind = TokenKind::NotEqual;
             } else {
                 token_kind = TokenKind::Exclamation;
+            }
         } else if first_char == b'%' {
             source.consume();
             if Some(b'=') == source.next() {
                 source.consume();
                 token_kind = TokenKind::PercentEquals;
             } else {
                 token_kind = TokenKind::Percent;
+            }
         } else if first_char == b'&' {
             source.consume();
             let next = source.next();
             if Some(b'&') == next {
                 source.consume();
                 token_kind = TokenKind::AndAnd;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::AndEquals;
             } else {
                 token_kind = TokenKind::And;
+            }
         } else if first_char == b'(' {
             source.consume();
             token_kind = TokenKind::OpenParen;
         } else if first_char == b')' {
             source.consume();
             token_kind = TokenKind::CloseParen;
         } else if first_char == b'*' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::StarEquals;
             } else {
                 token_kind = TokenKind::Star;
+            }
         } else if first_char == b'+' {
             source.consume();
             let next = source.next();
             if Some(b'+') == next {
                 source.consume();
                 token_kind = TokenKind::PlusPlus;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::PlusEquals;
             } else {
                 token_kind = TokenKind::Plus;
+            }
         } else if first_char == b',' {
             source.consume();
             token_kind = TokenKind::Comma;
         } else if first_char == b'-' {
             source.consume();
             let next = source.next();
             if Some(b'-') == next {
                 source.consume();
                 token_kind = TokenKind::MinusMinus;
             } else if Some(b'>') == next {
                 source.consume();
                 token_kind = TokenKind::ArrowRight;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::MinusEquals;
             } else {
                 token_kind = TokenKind::Minus;
+            }
         } else if first_char == b'.' {
             source.consume();
             if let Some(b'.') = source.next() {
                 source.consume();
                 token_kind = TokenKind::DotDot;
             } else {
                 token_kind = TokenKind::Dot
+            }
         } else if first_char == b'/' {
             source.consume();
             debug_assert_ne!(Some(b'/'), source.next());
             debug_assert_ne!(Some(b'*'), source.next());
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::SlashEquals;
             } else {
                 token_kind = TokenKind::Slash;
+            }
         } else if first_char == b':' {
             source.consume();
             if let Some(b':') = source.next() {
                 source.consume();
                 token_kind = TokenKind::ColonColon;
             } else {
                 token_kind = TokenKind::Colon;
+            }
         } else if first_char == b';' {
             source.consume();
             token_kind = TokenKind::SemiColon;
         } else if first_char == b'<' {
             source.consume();
             let next = source.next();
             if let Some(b'<') = next {
                 source.consume();
                 if let Some(b'=') = source.next() {
                     source.consume();
                     token_kind = TokenKind::ShiftLeftEquals;
                 } else {
                     token_kind = TokenKind::ShiftLeft;
+                }
             } else if let Some(b'=') = next {
                 source.consume();
                 token_kind = TokenKind::LessEquals;
             } else {
                 token_kind = TokenKind::OpenAngle;
+            }
         } else if first_char == b'=' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::EqualEqual;
             } else {
                 token_kind = TokenKind::Equal;
+            }
         } else if first_char == b'>' {
             source.consume();
             let next = source.next();
             if Some(b'>') == next {
                 source.consume();
                 if Some(b'=') == source.next() {
                     source.consume();
                     token_kind = TokenKind::ShiftRightEquals;
                 } else {
                     token_kind = TokenKind::ShiftRight;
+                }
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::GreaterEquals;
             } else {
                 token_kind = TokenKind::CloseAngle;
+            }
         } else if first_char == b'?' {
             source.consume();
             token_kind = TokenKind::Question;
         } else if first_char == b'@' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::AtEquals;
             } else {
                 token_kind = TokenKind::At;
+            }
         } else if first_char == b'[' {
             source.consume();
             token_kind = TokenKind::OpenSquare;
         } else if first_char == b']' {
             source.consume();
             token_kind = TokenKind::CloseSquare;
         } else if first_char == b'^' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::CaretEquals;
             } else {
                 token_kind = TokenKind::Caret;
+            }
         } else if first_char == b'{' {
             source.consume();
             token_kind = TokenKind::OpenCurly;
         } else if first_char == b'|' {
             source.consume();
             let next = source.next();
             if Some(b'|') == next {
                 source.consume();
                 token_kind = TokenKind::OrOr;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::OrEquals;
             } else {
                 token_kind = TokenKind::Or;
+            }
         } else if first_char == b'}' {
             source.consume();
             token_kind = TokenKind::CloseCurly;
         } else if first_char == b'~' {
             source.consume();
             token_kind = TokenKind::Tilde;
         } else {
             self.check_ascii(source)?;
             return Ok(None);
+        }
         target.tokens.push(Token::new(token_kind, pos));
         Ok(Some((token_kind, pos)))
+    }
     fn consume_char_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading quote
         debug_assert!(source.next().unwrap() == b'\'');
         source.consume();
         let mut prev_char = b'\'';
         while let Some(c) = source.next() {
             if !c.is_ascii() {
                 return Err(ParseError::new_error_str_at_pos(source, source.pos(), "non-ASCII character in char literal"));
+            }
             source.consume();
             // Make sure ending quote was not escaped
             if c == b'\'' && prev_char != b'\\' {
                 prev_char = c;
                 break;
+            }
             prev_char = c;
+        }
         if prev_char != b'\'' {
             // Unterminated character literal, reached end of file.
             return Err(ParseError::new_error_str_at_pos(source, begin_pos, "encountered unterminated character literal"));
+        }
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::Character, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_string_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading double quotes
         debug_assert!(source.next().unwrap() == b'"');
         source.consume();
         let mut prev_char = b'"';
         while let Some(c) = source.next() {
             if !c.is_ascii() {
                 return Err(ParseError::new_error_str_at_pos(source, source.pos(), "non-ASCII character in string literal"));
+            }
             source.consume();
             if c == b'"' && prev_char != b'\\' {
                 prev_char = c;
                 break;
+            }
             prev_char = c;
+        }
         if prev_char != b'"' {
             // Unterminated string literal
             return Err(ParseError::new_error_str_at_pos(source, begin_pos, "encountered unterminated string literal"));
+        }
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::String, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_pragma_or_pound(&mut self, first_char: u8, source: &mut InputSource, target: &mut TokenBuffer) -> Result<bool, ParseError> {
         let start_pos = source.pos();
         debug_assert_eq!(first_char, b'#');
         source.consume();
         let next = source.next();
         if next.is_none() || !is_identifier_start(next.unwrap()) {
             // Just a pound sign
             target.tokens.push(Token::new(TokenKind::Pound, start_pos));
             Ok(false)
         } else {
             // Pound sign followed by identifier
             source.consume();
             while let Some(c) = source.next() {
                 if !is_identifier_remaining(c) {
                     break;
+                }
                 source.consume();
+            }
             self.check_ascii(source)?;
             let end_pos = source.pos();
             target.tokens.push(Token::new(TokenKind::Pragma, start_pos));
             target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
             Ok(true)
+        }
+    }
     fn consume_line_comment(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading "//"
         debug_assert!(source.next().unwrap() == b'/' && source.lookahead(1).unwrap() == b'/');
         source.consume();
         source.consume();
         let mut prev_char = b'/';
         let mut cur_char = b'/';
         while let Some(c) = source.next() {
             prev_char = cur_char;
             cur_char = c;
             if c == b'\n' {
                 // End of line, note that the newline is not consumed
                 break;
+            }
             source.consume();
+        }
         let mut end_pos = source.pos();
         debug_assert_eq!(begin_pos.line, end_pos.line);
         // Modify offset to not include the newline characters
         if cur_char == b'\n' {
             if prev_char == b'\r' {
                 end_pos.offset -= 2;
             } else {
                 end_pos.offset -= 1;
+            }
             // Consume final newline
             source.consume();
         } else {
             // End of comment was due to EOF
             debug_assert!(source.next().is_none())
+        }
         target.tokens.push(Token::new(TokenKind::LineComment, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_block_comment(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading "/*"

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -1442,395 +1442,396 @@ impl PassTyping { @@
+            }
             Ok(concrete)
+        }
         // 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.span(), format!(
                             "could not fully infer the type of this expression (got '{}')",
                             expr_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
+            }
             // Expression is fine, check if any extra data is attached
             if infer_expr.extra_data_idx < 0 { continue; }
             // Extra data is attached, perform typechecking and transfer
             // resolved information to the expression
             let extra_data = &self.extra_data[infer_expr.extra_data_idx as usize];
             if extra_data.poly_vars.is_empty() { continue; }
             // 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] {
                 Expression::Call(expr) => {
                     if expr.method != Method::UserFunction && expr.method != Method::UserComponent {
                         // Builtin function
                         continue;
+                    }
                     let definition_id = expr.definition;
                     let poly_types = poly_inference_to_concrete_type(ctx, extra_data.expr_id, &extra_data.poly_vars)?;
                     match ctx.types.get_procedure_monomorph_index(&definition_id, &poly_types) {
                         Some(reserved_idx) => {
                             // Already typechecked, or already put into the resolve queue
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                         },
                         None => {
                             // Not typechecked yet, so add an entry in the queue
                             let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, Some(poly_types.clone()));
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                             queue.push(ResolveQueueElement{
                                 root_id: ctx.heap[definition_id].defined_in(),
                                 definition_id,
                                 monomorph_types: poly_types,
                                 reserved_monomorph_idx: reserved_idx,
                             });
+                        }
+                    }
                 },
                 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 poly_types = poly_inference_to_concrete_type(ctx, extra_data.expr_id, &extra_data.poly_vars)?;
                     let mono_index = ctx.types.add_data_monomorph(&definition_id, poly_types);
                     infer_expr.field_or_monomorph_idx = mono_index;
                 },
                 Expression::Select(_) => {
                     debug_assert!(infer_expr.field_or_monomorph_idx >= 0);
                 },
                 _ => {
                     unreachable!("handling extra data for expression {:?}", &ctx.heap[extra_data.expr_id]);
+                }
+            }
+        }
         // 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 definition_id = match &self.definition_type {
             DefinitionType::Component(id) => id.upcast(),
             DefinitionType::Function(id) => id.upcast(),
         };
         let target = ctx.types.get_procedure_expression_data_mut(&definition_id, self.reserved_idx);
         debug_assert!(target.poly_args == self.poly_vars);
         debug_assert!(target.expr_data.is_empty()); // makes sure we never queue something twice
         target.expr_data.reserve(self.expr_types.len());
         for infer_expr in self.expr_types.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_idx
             });
+        }
         Ok(())
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {
         let id = self.expr_types[idx as usize].expr_id; // TODO: @Temp
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Binding(expr) => {
                 let id = expr.this;
                 self.progress_binding_expr(ctx, id)
             },
             Expression::Conditional(expr) => {
                 let id = expr.this;
                 self.progress_conditional_expr(ctx, id)
             },
             Expression::Binary(expr) => {
                 let id = expr.this;
                 self.progress_binary_expr(ctx, id)
             },
             Expression::Unary(expr) => {
                 let id = expr.this;
                 self.progress_unary_expr(ctx, id)
             },
             Expression::Indexing(expr) => {
                 let id = expr.this;
                 self.progress_indexing_expr(ctx, id)
             },
             Expression::Slicing(expr) => {
                 let id = expr.this;
                 self.progress_slicing_expr(ctx, id)
             },
             Expression::Select(expr) => {
                 let id = expr.this;
                 self.progress_select_expr(ctx, id)
             },
             Expression::Literal(expr) => {
                 let id = expr.this;
                 self.progress_literal_expr(ctx, id)
             },
             Expression::Cast(expr) => {
                 let id = expr.this;
                 self.progress_cast_expr(ctx, id)
             },
             Expression::Call(expr) => {
                 let id = expr.this;
                 self.progress_call_expr(ctx, id)
             },
             Expression::Variable(expr) => {
                 let id = expr.this;
                 self.progress_variable_expr(ctx, id)
+            }
+        }
+    }
     fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError> {
         use AssignmentOperator as AO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.left;
         let arg2_expr_id = expr.right;
         debug_log!("Assignment expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.debug_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
         // Assignment does not return anything (it operates like a statement)
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &VOID_TEMPLATE)?;
         // Apply forced constraint to LHS value
         let progress_forced = match expr.operation {
             AO::Set =>
                 false,
             AO::Concatenated =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &ARRAYLIKE_TEMPLATE)?,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &INTEGERLIKE_TEMPLATE)?,
         };
         let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(
             ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0
         )?;
         debug_assert!(if progress_forced { progress_arg2 } else { true });
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_forced || progress_arg1, self.debug_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.debug_get_display_name(ctx, arg2_expr_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); }
         if progress_forced || progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }
         Ok(())
+    }
     fn progress_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let binding_expr = &ctx.heap[id];
         let bound_from_id = binding_expr.bound_from;
         let bound_to_id = binding_expr.bound_to;
         // Output is always a boolean. The two arguments should be of equal
         // type.
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
         let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, bound_from_id, 0, bound_to_id, 0)?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_from { self.queue_expr(ctx, bound_from_id); }
         if progress_to { self.queue_expr(ctx, bound_to_id); }
         Ok(())
+    }
     fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError> {
         // Note: test expression type is already enforced
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.true_expression;
         let arg2_expr_id = expr.false_expression;
         debug_log!("Conditional expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.debug_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
         // I keep confusing myself: this applies equality of types between the
         // condition branches' types, and the result from the conditional
         // expression, because the result from the conditional is one of the
         // branches.
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.debug_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.debug_get_display_name(ctx, arg2_expr_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); }
         if progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }
         Ok(())
+    }
     fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError> {
         // Note: our expression type might be fixed by our parent, but we still
         // need to make sure it matches the type associated with our operation.
         use BinaryOperator as BO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_id = expr.left;
         let arg2_id = expr.right;
         debug_log!("Binary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.debug_get_display_name(ctx, arg1_id));
         debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_id));
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
         let (progress_expr, progress_arg1, progress_arg2) = match expr.operation {
             BO::Concatenate => {
                 // Arguments may be arrays/slices, output is always an array
                 let progress_expr = self.apply_template_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
                 let progress_arg1 = self.apply_template_constraint(ctx, arg1_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_arg2 = self.apply_template_constraint(ctx, arg2_id, &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, upcast_id, arg1_id, arg2_id, 1)?;
                 (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)
             },
             BO::LogicalAnd => {
                 // Forced boolean on all
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::LogicalOr => {
                 // Forced boolean on all
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &BOOL_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::BitwiseOr | BO::BitwiseXor | BO::BitwiseAnd | BO::Remainder | BO::ShiftLeft | BO::ShiftRight => {
                 // All equal of integer type
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
             BO::Equality | BO::Inequality => {
                 // Equal2 on args, forced boolean output
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::LessThan | BO::GreaterThan | BO::LessThanEqual | BO::GreaterThanEqual => {
                 // Equal2 on args with numberlike type, forced boolean output
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg_base = self.apply_template_constraint(ctx, arg1_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg_base || progress_arg1, progress_arg_base || progress_arg2)
             },
             BO::Add | BO::Subtract | BO::Multiply | BO::Divide => {
                 // All equal of number type
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
         };
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.debug_get_display_name(ctx, arg1_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.debug_get_display_name(ctx, arg2_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); }
         if progress_arg1 { self.queue_expr(ctx, arg1_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_id); }
         Ok(())
+    }
     fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError> {
         use UnaryOperator as UO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg_id = expr.expression;
         debug_log!("Unary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg  type: {}", self.debug_get_display_name(ctx, arg_id));
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
         let (progress_expr, progress_arg) = match expr.operation {
             UO::Positive | UO::Negative => {
                 // Equal types of numeric class
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::BitwiseNot => {
                 // Equal types of integer class
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::LogicalNot => {
                 // Both bools
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg)
+            }

src/protocol/parser/tokens.rs

➞

Show inline comments

 use crate::protocol::input_source::{
     InputPosition as InputPosition,
     InputSpan
 };
 /// Represents a particular kind of token. Some tokens represent
 /// variable-character tokens. Such a token is always followed by a
 /// `TokenKind::SpanEnd` token.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TokenKind {
     // Variable-character tokens, followed by a SpanEnd token
     Ident,          // regular identifier
     Pragma,         // identifier with prefixed `#`, range includes `#`
     Integer,        // integer literal
     String,         // string literal, range includes `"`
     Character,      // character literal, range includes `'`
     LineComment,    // line comment, range includes leading `//`, but not newline
     BlockComment,   // block comment, range includes leading `/*` and trailing `*/`
     // Punctuation (single character)
     Exclamation,    // !
     Question,       // ?
     Pound,          // #
     OpenAngle,      // <
     OpenCurly,      // {
     OpenParen,      // (
     OpenSquare,     // [
     CloseAngle,     // >
     CloseCurly,     // }
     CloseParen,     // )
     CloseSquare,    // ]
     Colon,          // :
     Comma,          // ,
     Dot,            // .
     SemiColon,      // ;
     // Operator-like (single character)
     At,             // @
     Plus,           // +
     Minus,          // -
     Star,           // *
     Slash,          // /
     Percent,        // %
     Caret,          // ^
     And,            // &
     Or,             // |
     Tilde,          // ~
     Equal,          // =
     // Punctuation (two characters)
     ColonColon,     // ::
     DotDot,         // ..
     ArrowRight,     // ->
     // Operator-like (two characters)
     AtEquals,       // @=
     PlusPlus,       // ++
     PlusEquals,     // +=
     MinusMinus,     // --
     MinusEquals,    // -=
     StarEquals,     // *=
     SlashEquals,    // /=
     PercentEquals,  // %=
     CaretEquals,    // ^=
     AndAnd,         // &&
     AndEquals,      // &=
     OrOr,           // ||
     OrEquals,       // |=
     EqualEqual,     // ==
     NotEqual,       // !=
     ShiftLeft,      // <<
     LessEquals,     // <=
     ShiftRight,     // >>
     GreaterEquals,  // >=
     // Operator-like (three characters)
     ShiftLeftEquals,// <<=
     ShiftRightEquals, // >>=
     // Special marker token to indicate end of variable-character tokens
     SpanEnd,
+}
 impl TokenKind {
     /// Returns true if the next expected token is the special `TokenKind::SpanEnd` token. This is
     /// the case for tokens of variable length (e.g. an identifier).
     fn has_span_end(&self) -> bool {
         return *self <= TokenKind::BlockComment
+    }
     /// Returns the number of characters associated with the token. May only be called on tokens
     /// that do not have a variable length.
     fn num_characters(&self) -> u32 {
         debug_assert!(!self.has_span_end() && *self != TokenKind::SpanEnd);
         if *self <= TokenKind::Equal {
-        } else if *self <= TokenKind::ShiftRight {
+        } else if *self <= TokenKind::GreaterEquals {
         } else {
+        }
+    }
     /// Returns the characters that are represented by the token, may only be called on tokens that
     /// do not have a variable length.
     pub fn token_chars(&self) -> &'static str {
         debug_assert!(!self.has_span_end() && *self != TokenKind::SpanEnd);
         use TokenKind as TK;
         match self {
             TK::Exclamation => "!",
             TK::Question => "?",
             TK::Pound => "#",
             TK::OpenAngle => "<",
             TK::OpenCurly => "{",
             TK::OpenParen => "(",
             TK::OpenSquare => "[",
             TK::CloseAngle => ">",
             TK::CloseCurly => "}",
             TK::CloseParen => ")",
             TK::CloseSquare => "]",
             TK::Colon => ":",
             TK::Comma => ",",
             TK::Dot => ".",
             TK::SemiColon => ";",
             TK::At => "@",
             TK::Plus => "+",
             TK::Minus => "-",
             TK::Star => "*",
             TK::Slash => "/",
             TK::Percent => "%",
             TK::Caret => "^",
             TK::And => "&",
             TK::Or => "|",
             TK::Tilde => "~",
             TK::Equal => "=",
             TK::ColonColon => "::",
             TK::DotDot => "..",
             TK::ArrowRight => "->",
             TK::AtEquals => "@=",
             TK::PlusPlus => "++",
             TK::PlusEquals => "+=",
             TK::MinusMinus => "--",
             TK::MinusEquals => "-=",
             TK::StarEquals => "*=",
             TK::SlashEquals => "/=",
             TK::PercentEquals => "%=",
             TK::CaretEquals => "^=",
             TK::AndAnd => "&&",
             TK::AndEquals => "&=",
             TK::OrOr => "||",
             TK::OrEquals => "|=",
             TK::EqualEqual => "==",
             TK::NotEqual => "!=",
             TK::ShiftLeft => "<<",
             TK::LessEquals => "<=",
             TK::ShiftRight => ">>",
             TK::GreaterEquals => ">=",
             TK::ShiftLeftEquals => "<<=",
             TK::ShiftRightEquals => ">>=",
             // Lets keep these in explicitly for now, in case we want to add more symbols
             TK::Ident | TK::Pragma | TK::Integer | TK::String | TK::Character |
             TK::LineComment | TK::BlockComment | TK::SpanEnd => unreachable!(),
+        }
+    }
+}
 /// Represents a single token at a particular position.
 pub struct Token {
     pub kind: TokenKind,
     pub pos: InputPosition,
+}
 impl Token {
     pub(crate) fn new(kind: TokenKind, pos: InputPosition) -> Self {
         Self{ kind, pos }
+    }
+}
 /// The kind of token ranges that are specially parsed by the tokenizer.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum TokenRangeKind {
     Module,
     Pragma,
     Import,
     Definition,
     Code,
+}
 pub const NO_RELATION: i32 = -1;
 pub const NO_SIBLING: i32 = NO_RELATION;
 /// A range of tokens with a specific meaning. Such a range is part of a tree
 /// where each parent tree envelops all of its children.
 #[derive(Debug)]
 pub struct TokenRange {
     // Index of parent in `TokenBuffer.ranges`, does not have a parent if the
     // range kind is Module, in that case the parent index is -1.
     pub parent_idx: i32,
     pub range_kind: TokenRangeKind,
     pub curly_depth: u32,
     // Offsets into `TokenBuffer.ranges`: the tokens belonging to this range.
     pub start: u32,             // first token (inclusive index)
     pub end: u32,               // last token (exclusive index)
     // Child ranges
     pub num_child_ranges: u32,  // Number of subranges
     pub first_child_idx: i32,   // First subrange (or -1 if no subranges)
     pub last_child_idx: i32,    // Last subrange (or -1 if no subranges)
     pub next_sibling_idx: i32,  // Next subrange (or -1 if no next subrange)
+}
 pub struct TokenBuffer {
     pub tokens: Vec<Token>,
     pub ranges: Vec<TokenRange>,
+}
 impl TokenBuffer {
     pub(crate) fn new() -> Self {
         Self{ tokens: Vec::new(), ranges: Vec::new() }
+    }
     pub(crate) fn iter_range<'a>(&'a self, range: &TokenRange) -> TokenIter<'a> {
         TokenIter::new(self, range.start as usize, range.end as usize)
+    }
     pub(crate) fn start_pos(&self, range: &TokenRange) -> InputPosition {
         self.tokens[range.start as usize].pos
+    }
     pub(crate) fn end_pos(&self, range: &TokenRange) -> InputPosition {
         let last_token = &self.tokens[range.end as usize - 1];
         if last_token.kind == TokenKind::SpanEnd {
             return last_token.pos
         } else {
             debug_assert!(!last_token.kind.has_span_end());
             return last_token.pos.with_offset(last_token.kind.num_characters());
+        }
+    }
+}
 /// Iterator over tokens within a specific `TokenRange`.
 pub(crate) struct TokenIter<'a> {
     tokens: &'a Vec<Token>,
     cur: usize,
     end: usize,
+}
 impl<'a> TokenIter<'a> {
     fn new(buffer: &'a TokenBuffer, start: usize, end: usize) -> Self {
         Self{ tokens: &buffer.tokens, cur: start, end }
+    }
     /// Returns the next token (may include comments), or `None` if at the end
     /// of the range.
     pub(crate) fn next_including_comments(&self) -> Option<TokenKind> {
         if self.cur >= self.end {
             return None;
+        }
         let token = &self.tokens[self.cur];
         Some(token.kind)
+    }
     /// Returns the next token (but skips over comments), or `None` if at the
     /// end of the range
     pub(crate) fn next(&mut self) -> Option<TokenKind> {
         while let Some(token_kind) = self.next_including_comments() {
             if token_kind != TokenKind::LineComment && token_kind != TokenKind::BlockComment {
                 return Some(token_kind);
+            }
             self.consume();
+        }
         return None
+    }
     /// Peeks ahead by one token (i.e. the one that comes after `next()`), and
     /// skips over comments
     pub(crate) fn peek(&self) -> Option<TokenKind> {
         for next_idx in self.cur + 1..self.end {
             let next_kind = self.tokens[next_idx].kind;
             if next_kind != TokenKind::LineComment && next_kind != TokenKind::BlockComment && next_kind != TokenKind::SpanEnd {
                 return Some(next_kind);
+            }
+        }
         return None;
+    }
     /// Returns the start position belonging to the token returned by `next`. If
     /// there is not a next token, then we return the end position of the
     /// previous token.
     pub(crate) fn last_valid_pos(&self) -> InputPosition {
         if self.cur < self.end {
             // Return token position
             return self.tokens[self.cur].pos
+        }
         // Return previous token end
         let token = &self.tokens[self.cur - 1];
         return if token.kind == TokenKind::SpanEnd {
             token.pos
         } else {
             token.pos.with_offset(token.kind.num_characters())
         };
+    }
     /// Returns the token range belonging to the token returned by `next`. This
     /// assumes that we're not at the end of the range we're iterating over.
     /// TODO: @cleanup Phase out?
     pub(crate) fn next_positions(&self) -> (InputPosition, InputPosition) {
         debug_assert!(self.cur < self.end);
         let token = &self.tokens[self.cur];
         if token.kind.has_span_end() {
             let span_end = &self.tokens[self.cur + 1];
             debug_assert_eq!(span_end.kind, TokenKind::SpanEnd);
             (token.pos, span_end.pos)
         } else {
             let offset = token.kind.num_characters();
             (token.pos, token.pos.with_offset(offset))
+        }
+    }
     /// See `next_positions`
     pub(crate) fn next_span(&self) -> InputSpan {
         let (begin, end) = self.next_positions();
         return InputSpan::from_positions(begin, end)
+    }
     /// Advances the iterator to the next (meaningful) token.
     pub(crate) fn consume(&mut self) {
         if let Some(kind) = self.next_including_comments() {

src/protocol/tests/eval_binding.rs

➞

Show inline comments

 use super::*;
 #[test]
 fn test_binding_from_struct() {
     Tester::new_single_source_expect_ok("top level", "
         struct Foo{ u32 field }
         func foo() -> u32 {
             if (let Foo{ field: thing } = Foo{ field: 1337 }) { return thing; }
             return 0;
+        }
     ").for_function("foo", |f| {
         f.call_ok(Some(Value::UInt32(1337)));
     });
     Tester::new_single_source_expect_ok("nested", "
         struct Nested<T>{ T inner }
         struct Foo{ u32 field }
         func make<T>(T val) -> Nested<T> {
             return Nested{ inner: val };
+        }
         func foo() -> u32 {
             if (let Nested{ inner: Nested { inner: to_get } } = make(make(Foo{ field: 42 }))) {
                 return to_get.field;
+            }
             return 0;
+        }
     ").for_function("foo", |f| {
         f.call_ok(Some(Value::UInt32(42)));
     });
+}
 #[test]
 fn test_binding_from_array() {
     Tester::new_single_source_expect_ok("top level", "
         func foo() -> bool {
             // Mismatches in length
             bool failure1 = false;
             u32[] vals = { 1, 2, 3 };
             if (let {1, a} = vals) { failure1 = true; }
             bool failure2 = false;
             if (let {} = vals) { failure2 = true; }
             bool failure3 = false;
             if (let {1, 2, 3, 4} = vals) { failure3 = true; }
             // Mismatches in known values
             bool failure4 = false;
             if (let {1, 3, a} = vals) { failure4 = true; }
             // Matching with known variables
             auto constant_one = 1;
             auto constant_two = 2;
             auto constant_three = 3;
             bool success1 = false;
             if (
                 let {binding_one, constant_two, constant_three} = vals &&
                 let {constant_one, binding_two, constant_three} = vals &&
                 let {constant_one, constant_two, binding_three} = vals
             ) {
                 success1 = binding_one == 1 && binding_two == 2 && binding_three == 3;
+            }
             // Matching with literals
             bool success2 = false;
             if (let {binding_one, 2, 3} = vals && let {1, binding_two, 3} = vals && let {1, 2, binding_three} = vals) {
                 success2 = binding_one == 1 && binding_two == 2 && binding_three == 3;
+            }
             // Matching all
             bool success3 = false;
             if (let {binding_one, binding_two, binding_three} = vals && let {1, 2, 3} = vals) {
                 success3 = true;
+            }
             return
                 !failure1 && !failure2 && !failure3 && !failure4 &&
                 success1 && success2 && success3;
+        }
     ").for_function("foo", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
+}
 #[test]
 fn test_binding_from_union() {
     Tester::new_single_source_expect_ok("option type", "
         union Option<T> { Some(T), None }
         func is_some<T>(Option<T> opt) -> bool {
             if (let Option::Some(throwaway) = opt) return true;
             else                                   return false;
+        }
         func is_none<T>(Option<T> opt) -> bool {
             if (let Option::Some(throwaway) = opt) return false;
             else                                   return true;
+        }
         func foo() -> u32 {
             // Hey look, we're so modern, we have algebraic discriminated sum datauniontypes
             auto something = Option::Some(5);
             auto nonething = Option<u32>::None;
             bool success1 = false;
             if (let Option::Some(value) = something && let Option::None = nonething) {
                 success1 = value == 5;
+            }
             bool success2 = false;
             if (is_some(something) && is_none(nonething)) {
                 success2 = true;
+            }
             bool success3 = true;
             if (let Option::None = something) success3 = false;
             if (let Option::Some(value) = nonething) success3 = false;
             bool success4 = true;
             if (is_none(something) || is_some(nonething)) success4 = false;
             if (success1 && success2 && success3 && success4) {
                 if (let Option::Some(value) = something) return value;
+            }
             return 0;
+        }
     ").for_function("foo", |f| { f
         .call_ok(Some(Value::UInt32(5)));
     });
+}
 #[test]
 fn test_binding_fizz_buzz() {
     Tester::new_single_source_expect_ok("am I employable?", "
         union Fizzable { Number(u32), FizzBuzz, Fizz, Buzz }
-        func construct_fizz_buzz(u32 num) -> Fizzable[] {
+        func construct_fizz_buzz_very_slow(u32 num) -> Fizzable[] {
             u32 counter = 1;
             auto result = {};
             while (counter <= num) {
                 auto value = Fizzable::Number(counter);
                 if (counter % 5 == 0) {
                     if (counter % 3 == 0) {
                         value = Fizzable::FizzBuzz;
                     } else {
                         value = Fizzable::Buzz;
+                    }
                 } else if (counter % 3 == 0) {
                     value = Fizzable::Fizz;
+                }
                 result = result @ { value }; // woohoo, no array builtins!
                 counter += 1;
+            }
             return result;
+        }
         func construct_fizz_buzz_slightly_less_slow(u32 num) -> Fizzable[] {
             u32 counter = 1;
             auto result = {};
             while (counter <= num) {
                 auto value = Fizzable::Number(counter);
                 if (counter % 5 == 0) {
                     if (counter % 3 == 0) {
                         value = Fizzable::FizzBuzz;
                     } else {
                         value = Fizzable::Buzz;
+                    }
                 } else if (counter % 3 == 0) {
                     value = Fizzable::Fizz;
+                }
                 result @= { value }; // woohoo, no array builtins!
                 counter += 1;
+            }
             return result;
+        }
         func test_fizz_buzz(Fizzable[] fizzoid) -> bool {
             u32 idx = 0;
             bool valid = true;
             while (idx < length(fizzoid)) {
                 auto number = idx + 1;
                 auto is_div3 = number % 3 == 0;
                 auto is_div5 = number % 5 == 0;
                 if (let Fizzable::Number(got) = fizzoid[idx]) {
                     valid = valid && got == number && !is_div3 && !is_div5;
                 } else if (let Fizzable::FizzBuzz = fizzoid[idx]) {
                     valid = valid && is_div3 && is_div5;
                 } else if (let Fizzable::Fizz = fizzoid[idx]) {
                     valid = valid && is_div3 && !is_div5;
                 } else if (let Fizzable::Buzz = fizzoid[idx]) {
                     valid = valid && !is_div3 && is_div5;
                 } else {
                     // Impossibruuu!
                     valid = false;
+                }
                 idx += 1;
+            }
             return valid;
+        }
         func fizz_buzz() -> bool {
             auto fizz = construct_fizz_buzz(100);
             return test_fizz_buzz(fizz);
             // auto fizz_more_slow = construct_fizz_buzz_very_slow(100);
             // return test_fizz_buzz(fizz_more_slow);
             // auto fizz_less_slow = construct_fizz_buzz_slightly_less_slow(100);
             // return test_fizz_buzz(fizz_less_slow);
             auto fizz_more_slow2 = construct_fizz_buzz_very_slow(100);
             auto fizz_less_slow2 = construct_fizz_buzz_slightly_less_slow(100);
             return test_fizz_buzz(fizz_more_slow2) && test_fizz_buzz(fizz_less_slow2);
+        }
     ").for_function("fizz_buzz", |f| { f
         .call_ok(Some(Value::Bool(true)));
     });
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)