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

Changeset - 729feec4d37a

Parent rev.

Child rev.

[Not reviewed]

0 6 1

MH - 4 years ago 2021-03-03 13:06:42
contact@maxhenger.nl

WIP on debugging AST writing

7 files changed with 405 insertions and 44 deletions:

src/protocol/ast.rs

src/protocol/ast_printer.rs

353

src/protocol/inputsource.rs

src/protocol/mod.rs

src/protocol/parser/depth_visitor.rs

src/protocol/parser/mod.rs

src/protocol/parser/visitor.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::{Index, IndexMut};
 use super::arena::{Arena, Id};
 // use super::containers::StringAllocator;
 // TODO: @cleanup, transform wrapping types into type aliases where possible
 use crate::protocol::inputsource::*;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct RootId(pub(crate) Id<Root>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PragmaId(Id<Pragma>);
+pub struct PragmaId(pub(crate) Id<Pragma>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ImportId(Id<Import>);
+pub struct ImportId(pub(crate) Id<Import>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct TypeAnnotationId(Id<TypeAnnotation>);
+pub struct TypeAnnotationId(pub(crate) Id<TypeAnnotation>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct VariableId(Id<Variable>);
+pub struct VariableId(pub(crate) Id<Variable>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct ParameterId(VariableId);
+pub struct ParameterId(pub(crate) VariableId);
 impl ParameterId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct LocalId(VariableId);
+pub struct LocalId(pub(crate) VariableId);
 impl LocalId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct DefinitionId(Id<Definition>);
+pub struct DefinitionId(pub(crate) Id<Definition>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct StructId(DefinitionId);
+pub struct StructId(pub(crate) DefinitionId);
 impl StructId {
     pub fn upcast(self) -> DefinitionId{
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EnumId(DefinitionId);
+pub struct EnumId(pub(crate) DefinitionId);
 impl EnumId {
     pub fn upcast(self) -> DefinitionId{
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ComponentId(DefinitionId);
+pub struct ComponentId(pub(crate) DefinitionId);
 impl ComponentId {
     pub fn upcast(self) -> DefinitionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct FunctionId(DefinitionId);
+pub struct FunctionId(pub(crate) DefinitionId);
 impl FunctionId {
     pub fn upcast(self) -> DefinitionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct StatementId(Id<Statement>);
+pub struct StatementId(pub(crate) Id<Statement>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 // TODO: Remove pub
 pub struct BlockStatementId(pub StatementId);
 impl BlockStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct LocalStatementId(StatementId);
+pub struct LocalStatementId(pub(crate) StatementId);
 impl LocalStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct MemoryStatementId(LocalStatementId);
+pub struct MemoryStatementId(pub(crate) LocalStatementId);
 impl MemoryStatementId {
     pub fn upcast(self) -> LocalStatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ChannelStatementId(LocalStatementId);
+pub struct ChannelStatementId(pub(crate) LocalStatementId);
 impl ChannelStatementId {
     pub fn upcast(self) -> LocalStatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SkipStatementId(StatementId);
+pub struct SkipStatementId(pub(crate) StatementId);
 impl SkipStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct LabeledStatementId(StatementId);
+pub struct LabeledStatementId(pub(crate) StatementId);
 impl LabeledStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct IfStatementId(StatementId);
+pub struct IfStatementId(pub(crate) StatementId);
 impl IfStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndIfStatementId(StatementId);
+pub struct EndIfStatementId(pub(crate) StatementId);
 impl EndIfStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct WhileStatementId(StatementId);
+pub struct WhileStatementId(pub(crate) StatementId);
 impl WhileStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndWhileStatementId(StatementId);
+pub struct EndWhileStatementId(pub(crate) StatementId);
 impl EndWhileStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BreakStatementId(StatementId);
+pub struct BreakStatementId(pub(crate) StatementId);
 impl BreakStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ContinueStatementId(StatementId);
+pub struct ContinueStatementId(pub(crate) StatementId);
 impl ContinueStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SynchronousStatementId(StatementId);
+pub struct SynchronousStatementId(pub(crate) StatementId);
 impl SynchronousStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndSynchronousStatementId(StatementId);
 impl EndSynchronousStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ReturnStatementId(StatementId);
 impl ReturnStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct AssertStatementId(StatementId);
 impl AssertStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct GotoStatementId(StatementId);
 impl GotoStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct NewStatementId(StatementId);
 impl NewStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PutStatementId(StatementId);
 impl PutStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionStatementId(StatementId);
 impl ExpressionStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionId(Id<Expression>);
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub struct AssignmentExpressionId(ExpressionId);
 impl AssignmentExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ConditionalExpressionId(ExpressionId);
 impl ConditionalExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BinaryExpressionId(ExpressionId);
 impl BinaryExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct UnaryExpressionId(ExpressionId);
 impl UnaryExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct IndexingExpressionId(ExpressionId);
 impl IndexingExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SlicingExpressionId(ExpressionId);
 impl SlicingExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SelectExpressionId(ExpressionId);
 impl SelectExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ArrayExpressionId(ExpressionId);
 impl ArrayExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ConstantExpressionId(ExpressionId);
 impl ConstantExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct CallExpressionId(ExpressionId);
 impl CallExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct VariableExpressionId(ExpressionId);
 impl VariableExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DeclarationId(Id<Declaration>);
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DefinedDeclarationId(DeclarationId);
 impl DefinedDeclarationId {
     pub fn upcast(self) -> DeclarationId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ImportedDeclarationId(DeclarationId);
 impl ImportedDeclarationId {
     pub fn upcast(self) -> DeclarationId {
         self.0
+    }
+}
 // TODO: @cleanup - pub qualifiers can be removed once done
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct Heap {
     // Allocators
     // #[serde(skip)] string_alloc: StringAllocator,
     // Root arena, contains the entry point for different modules. Each root
     // contains lists of IDs that correspond to the other arenas.
     protocol_descriptions: Arena<Root>,
+    pub(crate) protocol_descriptions: Arena<Root>,
     // Contents of a file, these are the elements the `Root` elements refer to
     pragmas: Arena<Pragma>,
     pub(crate) imports: Arena<Import>,
     identifiers: Arena<Identifier>,
     pub(crate) type_annotations: Arena<TypeAnnotation>,
     pub(crate) variables: Arena<Variable>,
     pub(crate) definitions: Arena<Definition>,
     pub(crate) statements: Arena<Statement>,
     pub(crate) expressions: Arena<Expression>,
     declarations: Arena<Declaration>,
+}
 impl Heap {
     pub fn new() -> Heap {
         Heap {
             // string_alloc: StringAllocator::new(),
             protocol_descriptions: Arena::new(),
             pragmas: Arena::new(),
             imports: Arena::new(),
             identifiers: Arena::new(),
             type_annotations: Arena::new(),
             variables: Arena::new(),
             definitions: Arena::new(),
             statements: Arena::new(),
             expressions: Arena::new(),
             declarations: Arena::new(),
+        }
+    }
     pub fn alloc_type_annotation(
         &mut self,
         f: impl FnOnce(TypeAnnotationId) -> TypeAnnotation,
     ) -> TypeAnnotationId {
         TypeAnnotationId(self.type_annotations.alloc_with_id(|id| f(TypeAnnotationId(id))))
+    }
     pub fn alloc_parameter(&mut self, f: impl FnOnce(ParameterId) -> Parameter) -> ParameterId {
         ParameterId(VariableId(
             self.variables.alloc_with_id(|id| Variable::Parameter(f(ParameterId(VariableId(id))))),
         ))
+    }
     pub fn alloc_local(&mut self, f: impl FnOnce(LocalId) -> Local) -> LocalId {
         LocalId(VariableId(
             self.variables.alloc_with_id(|id| Variable::Local(f(LocalId(VariableId(id))))),
         ))
+    }
     pub fn alloc_assignment_expression(
         &mut self,
         f: impl FnOnce(AssignmentExpressionId) -> AssignmentExpression,
     ) -> AssignmentExpressionId {
         AssignmentExpressionId(ExpressionId(self.expressions.alloc_with_id(|id| {
             Expression::Assignment(f(AssignmentExpressionId(ExpressionId(id))))
         })))
+    }
     pub fn alloc_conditional_expression(
         &mut self,
         f: impl FnOnce(ConditionalExpressionId) -> ConditionalExpression,
     ) -> ConditionalExpressionId {
         ConditionalExpressionId(ExpressionId(self.expressions.alloc_with_id(|id| {
             Expression::Conditional(f(ConditionalExpressionId(ExpressionId(id))))
         })))
+    }
     pub fn alloc_binary_expression(
         &mut self,
         f: impl FnOnce(BinaryExpressionId) -> BinaryExpression,
     ) -> BinaryExpressionId {
         BinaryExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Binary(f(BinaryExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_unary_expression(
         &mut self,
         f: impl FnOnce(UnaryExpressionId) -> UnaryExpression,
     ) -> UnaryExpressionId {
         UnaryExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Unary(f(UnaryExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_slicing_expression(
         &mut self,
         f: impl FnOnce(SlicingExpressionId) -> SlicingExpression,
     ) -> SlicingExpressionId {
         SlicingExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Slicing(f(SlicingExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_indexing_expression(
         &mut self,
         f: impl FnOnce(IndexingExpressionId) -> IndexingExpression,
     ) -> IndexingExpressionId {
         IndexingExpressionId(ExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Indexing(f(IndexingExpressionId(ExpressionId(id))))
             }),
         ))
+    }
     pub fn alloc_select_expression(
         &mut self,
         f: impl FnOnce(SelectExpressionId) -> SelectExpression,
     ) -> SelectExpressionId {
         SelectExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Select(f(SelectExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_array_expression(
         &mut self,
         f: impl FnOnce(ArrayExpressionId) -> ArrayExpression,
     ) -> ArrayExpressionId {
         ArrayExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Array(f(ArrayExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_constant_expression(
         &mut self,
         f: impl FnOnce(ConstantExpressionId) -> ConstantExpression,
     ) -> ConstantExpressionId {
         ConstantExpressionId(ExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Constant(f(ConstantExpressionId(ExpressionId(id))))
             }),
         ))
+    }
     pub fn alloc_call_expression(
         &mut self,
         f: impl FnOnce(CallExpressionId) -> CallExpression,
     ) -> CallExpressionId {
         CallExpressionId(ExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Call(f(CallExpressionId(ExpressionId(id))))),
         ))
+    }
     pub fn alloc_variable_expression(
         &mut self,
         f: impl FnOnce(VariableExpressionId) -> VariableExpression,
     ) -> VariableExpressionId {
         VariableExpressionId(ExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Variable(f(VariableExpressionId(ExpressionId(id))))
             }),
         ))
+    }
     pub fn alloc_block_statement(
         &mut self,
         f: impl FnOnce(BlockStatementId) -> BlockStatement,
     ) -> BlockStatementId {
         BlockStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Block(f(BlockStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_memory_statement(
         &mut self,
         f: impl FnOnce(MemoryStatementId) -> MemoryStatement,
     ) -> MemoryStatementId {
         MemoryStatementId(LocalStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Memory(f(MemoryStatementId(LocalStatementId(
                 StatementId(id),
             )))))
         }))))
+    }
     pub fn alloc_channel_statement(
         &mut self,
         f: impl FnOnce(ChannelStatementId) -> ChannelStatement,
     ) -> ChannelStatementId {
         ChannelStatementId(LocalStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Channel(f(ChannelStatementId(LocalStatementId(
                 StatementId(id),
             )))))
         }))))
+    }
     pub fn alloc_skip_statement(
         &mut self,
         f: impl FnOnce(SkipStatementId) -> SkipStatement,
     ) -> SkipStatementId {
         SkipStatementId(StatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Skip(f(SkipStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_if_statement(
         &mut self,
         f: impl FnOnce(IfStatementId) -> IfStatement,
     ) -> IfStatementId {
         IfStatementId(StatementId(
             self.statements.alloc_with_id(|id| Statement::If(f(IfStatementId(StatementId(id))))),
         ))
+    }
     pub fn alloc_end_if_statement(
         &mut self,

src/protocol/ast_printer.rs

➞

Show inline comments

@@ new file 100644 @@
 use std::fmt::{Display, Write};
 use std::io::Write as IOWrite;
 use super::ast::*;
 use std::borrow::Borrow;
 const INDENT: usize = 2;
 const PREFIX_EMPTY: &'static str = "    ";
 const PREFIX_ROOT_ID: &'static str = "Root";
 const PREFIX_PRAGMA_ID: &'static str = "Prag";
 const PREFIX_IMPORT_ID: &'static str = "Imp ";
 const PREFIX_TYPE_ANNOT_ID: &'static str = "TyAn";
 const PREFIX_VARIABLE_ID: &'static str = "Var ";
 const PREFIX_PARAMETER_ID: &'static str = "Par ";
 const PREFIX_LOCAL_ID: &'static str = "Loc ";
 const PREFIX_DEFINITION_ID: &'static str = "Def ";
 const PREFIX_STRUCT_ID: &'static str = "DefS";
 const PREFIX_ENUM_ID: &'static str = "DefE";
 const PREFIX_COMPONENT_ID: &'static str = "DefC";
 const PREFIX_FUNCTION_ID: &'static str = "DefF";
 const PREFIX_STMT_ID: &'static str = "Stmt";
 const PREFIX_BLOCK_STMT_ID: &'static str = "SBl ";
 const PREFIX_LOCAL_STMT_ID: &'static str = "SLoc";
 const PREFIX_MEM_STMT_ID: &'static str = "SMem";
 const PREFIX_CHANNEL_STMT_ID: &'static str = "SCha";
 const PREFIX_SKIP_STMT_ID: &'static str = "SSki";
 const PREFIX_LABELED_STMT_ID: &'static str = "SLab";
 const PREFIX_IF_STMT_ID: &'static str = "SIf ";
 const PREFIX_ENDIF_STMT_ID: &'static str = "SEIf";
 const PREFIX_WHILE_STMT_ID: &'static str = "SWhi";
 const PREFIX_ENDWHILE_STMT_ID: &'static str = "SEWh";
 const PREFIX_BREAK_STMT_ID: &'static str = "SBre";
 const PREFIX_CONTINUE_STMT_ID: &'static str = "SCon";
 const PREFIX_SYNC_STMT_ID: &'static str = "SSyn";
 const PREFIX_ENDSYNC_STMT_ID: &'static str = "SESy";
 const PREFIX_RETURN_STMT_ID: &'static str = "SRet";
 const PREFIX_ASSERT_STMT_ID: &'static str = "SAsr";
 const PREFIX_GOTO_STMT_ID: &'static str = "SGot";
 const PREFIX_NEW_STMT_ID: &'static str = "SNew";
 const PREFIX_PUT_STMT_ID: &'static str = "SPut";
 const PREFIX_EXPR_STMT_ID: &'static str = "SExp";
 const PREFIX_ASSIGNMENT_EXPR_ID: &'static str = "EAsi";
 const PREFIX_CONDITIONAL_EXPR_ID: &'static str = "ECnd";
 const PREFIX_BINARY_EXPR_ID: &'static str = "EBin";
 const PREFIX_UNARY_EXPR_ID: &'static str = "EUna";
 const PREFIX_INDEXING_EXPR_ID: &'static str = "EIdx";
 const PREFIX_SLICING_EXPR_ID: &'static str = "ESli";
 const PREFIX_SELECT_EXPR_ID: &'static str = "ESel";
 const PREFIX_ARRAY_EXPR_ID: &'static str = "EArr";
 const PREFIX_CONST_EXPR_ID: &'static str = "ECns";
 const PREFIX_CALL_EXPR_ID: &'static str = "ECll";
 const PREFIX_VARIABLE_EXPR_ID: &'static str = "EVar";
 pub(crate) struct ASTWriter {
     buffer: String,
     temp: String,
+}
 impl ASTWriter {
     pub(crate) fn new() -> Self {
         Self{ buffer: String::with_capacity(4096), temp: String::with_capacity(256) }
+    }
     pub(crate) fn write_ast<W: IOWrite>(&mut self, w: &mut W, heap: &Heap) {
         for root_id in heap.protocol_descriptions.iter().map(|v| v.this) {
             self.write_module(heap, root_id);
             w.write_all(self.buffer.as_bytes()).expect("flush buffer");
             self.buffer.clear();
+        }
+    }
     //--------------------------------------------------------------------------
     // Top-level module writing
     //--------------------------------------------------------------------------
     fn write_module(&mut self, heap: &Heap, root_id: RootId) {
         self.write_id_and_indent(PREFIX_ROOT_ID, root_id.0.index, 0);
         self.buffer.write_str("Module:\n");
         let root = &heap[root_id];
         self.write_indent(0);
         write!(&mut self.buffer, "- ID: {}\n", root.this.0.index);
         self.write_indent(0);
         self.buffer.write_str("- Pragmas:\n");
         for pragma_id in &root.pragmas {
             self.write_pragma(&heap[*pragma_id], 1);
+        }
         self.write_indent(0);
         self.buffer.write_str("- Imports:\n");
         for import_id in &root.imports {
             self.write_import(&heap[*import_id], 1);
+        }
         self.write_indent(0);
         self.buffer.write_str("- Definitions:\n");
         for definition_id in &root.definitions {
             self.write_definition(heap, &heap[*definition_id], 1);
+        }
+    }
     fn write_pragma(&mut self, pragma: &Pragma, indent: usize) {
         match pragma {
             Pragma::Version(pragma) => {
                 self.write_id_and_indent(PREFIX_PRAGMA_ID, pragma.this.0.index, indent);
                 write!(&mut self.buffer, "- Version: {}\n", pragma.version);
             },
             Pragma::Module(pragma) => {
                 self.write_id_and_indent(PREFIX_PRAGMA_ID, pragma.this.0.index, indent);
                 write!(&mut self.buffer, "- Module: {}\n", String::from_utf8_lossy(&pragma.value));
+            }
+        }
+    }
     fn write_import(&mut self, import: &Import, indent: usize) {
         let indent2 = indent + 1;
         match import {
             Import::Module(import) => {
                 self.write_id_and_indent(PREFIX_IMPORT_ID, import.this.0.index, indent);
                 write!(&mut self.buffer, "- ModuleImport:\n");
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Name: {}\n", String::from_utf8_lossy(&import.module_name));
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Alias: {}\n", String::from_utf8_lossy(&import.alias));
                 self.write_indent(indent2);
                 write_option(&mut self.temp, import.module_id.map(|v| v.0.index));
                 write!(&mut self.buffer, "- Target: {}\n", &self.temp);
             },
             Import::Symbols(import) => {
                 self.write_id_and_indent(PREFIX_IMPORT_ID, import.this.0.index, indent);
                 write!(&mut self.buffer, "- SymbolImport:\n");
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Name: {}\n", String::from_utf8_lossy(&import.module_name));
                 self.write_indent(indent2);
                 write_option(&mut self.temp, import.module_id.map(|v| v.0.index));
                 write!(&mut self.buffer, "- Target: {}\n", &self.temp);
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Symbols:\n");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for symbol in &import.symbols {
                     self.write_indent(indent3);
                     write!(&mut self.buffer, "- AliasedSymbol:\n");
                     self.write_indent(indent4);
                     write!(&mut self.buffer, "- Name: {}\n", String::from_utf8_lossy(&symbol.name));
                     self.write_indent(indent4);
                     write!(&mut self.buffer, "- Alias: {}\n", String::from_utf8_lossy(&symbol.alias));
                     self.write_indent(indent4);
                     write_option(&mut self.temp, symbol.definition_id.map(|v| v.0.index));
                     write!(&mut self.buffer, "- Definition: {}\n", &self.temp);
+                }
+            }
+        }
+    }
     //--------------------------------------------------------------------------
     // Top-level definition writing
     //--------------------------------------------------------------------------
     fn write_definition(&mut self, heap: &Heap, def: &Definition, indent: usize) {
         match def {
             Definition::Struct(_) => todo!("implement Definition::Struct"),
             Definition::Enum(_) => todo!("implement Definition::Enum"),
             Definition::Function(_) => todo!("implement Definition::Function"),
             Definition::Component(def) => {
                 self.write_id_and_indent(PREFIX_COMPONENT_ID, def.this.0.0.index, indent);
                 write!(&mut self.buffer, "- Component:\n");
                 let indent2 = indent + 1;
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Name: {}\n", String::from_utf8_lossy(&def.identifier.value));
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Variant: {:?}\n", &def.variant);
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Parameters:\n");
                 for parameter_id in &def.parameters {
                     let param = &heap[*parameter_id];
                     self.write_indent(indent3);
                     write!(&mut self.buffer, "- Parameter\n");
                     self.write_indent(indent4);
                     write!(&mut self.buffer, "- Name: {}\n", String::from_utf8_lossy(&param.identifier.value));
                     self.write_indent(indent4);
                     write!(&mut self.buffer, "- Type: ");
                     write_type(&mut self.buffer, &heap[param.type_annotation]);
                     self.buffer.push('\n');
+                }
                 self.write_indent(indent2);
                 write!(&mut self.buffer, "- Body:\n");
                 self.write_stmt(heap, def.body, indent3);
+            }
+        }
+    }
     fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {
         let stmt = &heap[stmt_id];
         match stmt {
             Statement::Block(stmt) => {
                 self.write_id_and_indent(PREFIX_BLOCK_STMT_ID, stmt.this.0.0.index, indent);
                 write!(&mut self.buffer, "- Block:\n");
                 for stmt_id in &stmt.statements {
                     self.write_stmt(heap, *stmt_id, indent + 1);
+                }
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Channel(stmt) => {
                         self.write_id_and_indent(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.0.index, indent);
                         write!(&mut self.buffer, "- Channel:\n");
                         let indent2 = indent + 1;
                         let indent3 = indent2 + 1;
                         let from = &heap[stmt.from];
                         self.write_id_and_indent(PREFIX_LOCAL_ID, stmt.from.0.0.index, indent2);
                     },
                     LocalStatement::Memory(stmt) => {
+                    }
+                }
             },
             Statement::Skip(stmt) => {
                 self.write_id_and_indent(PREFIX_SKIP_STMT_ID, stmt.this.0.0.index, indent);
                 write!(&mut self.buffer, "- Skip\n");
             },
             Statement::Labeled(stmt) => {
                 self.write_id_and_indent(PREFIX_LABELED_STMT_ID, stmt.this.0.0.index, indent);
                 write!(&mut self.buffer, "- LabeledStatement\n");
                 let indent1 = indent + 1;
                 let indent2 = indent + 2;
                 self.write_indent(indent1);
                 write!(&mut self.buffer, "- Label: {}\n", String::from_utf8_lossy(&stmt.label.value));
                 self.write_indent(indent1);
                 write!(&mut self.buffer, "- Statement:\n");
                 self.write_stmt(heap, stmt.body, indent2);
             },
             Statement::If(stmt) => {
             },
             Statement::EndIf(stmt) => {
             },
             Statement::While(stmt) => {
             },
             Statement::EndWhile(stmt) => {
             },
             Statement::Break(stmt) => {
             },
             Statement::Continue(stmt) => {
             },
             Statement::Synchronous(stmt) => {
             },
             Statement::EndSynchronous(stmt) => {
             },
             Statement::Return(stmt) => {
             },
             Statement::Assert(stmt) => {
             },
             Statement::Goto(stmt) => {
             },
             Statement::New(stmt) => {
             },
             Statement::Put(stmt) => {
             },
             Statement::Expression(stmt) => {
+            }
+        }
+    }
     fn write_local(&mut self, heap: &Heap, local_id: LocalId, indent: usize) {
+        o
+    }
     //--------------------------------------------------------------------------
     // Printing Utilities
     //--------------------------------------------------------------------------
     fn write_id_and_indent(&mut self, prefix: &'static str, id: u32, indent: usize) {
         write!(&mut self.buffer, "{}[{:04}] ", prefix, id);
         for _ in 0..indent*INDENT {
             self.buffer.push(' ');
+        }
+    }
     fn write_indent(&mut self, indent: usize) {
         write!(&mut self.buffer, "{}       ", PREFIX_EMPTY);
         for _ in 0..indent*INDENT {
             self.buffer.push(' ');
+        }
+    }
     fn flush<W: IOWrite>(&mut self, w: &mut W) {
         w.write(self.buffer.as_bytes()).unwrap();
         self.buffer.clear()
+    }
+}
 fn write_option<V: Display>(target: &mut String, value: Option<V>) {
     target.clear();
     match &value {
         Some(v) => write!(target, "Some({})", v),
         None => target.write_str("None")
     };
+}
 fn write_type(target: &mut String, t: &TypeAnnotation) {
     match &t.the_type.primitive {
         PrimitiveType::Input => target.write_str("in"),
         PrimitiveType::Output => target.write_str("out"),
         PrimitiveType::Message => target.write_str("msg"),
         PrimitiveType::Boolean => target.write_str("bool"),
         PrimitiveType::Byte => target.write_str("byte"),
         PrimitiveType::Short => target.write_str("short"),
         PrimitiveType::Int => target.write_str("int"),
         PrimitiveType::Long => target.write_str("long"),
         PrimitiveType::Symbolic(symbolic) => {
             let mut temp = String::new();
             write_option(&mut temp, symbolic.definition.map(|v| v.0.index));
             write!(target, "Symbolic(name: {}, target: {})", String::from_utf8_lossy(&symbolic.identifier.value), &temp);
+        }
     };
     if t.the_type.array {
         target.push_str("[]");
+    }
+}
@@ \ No newline at end of file @@

src/protocol/inputsource.rs

➞

Show inline comments

@@ @@ -23,386 +23,384 @@ primitive sync(in i, out o) { @@
+}
 primitive alternator(in i, out l, out r) {
     while(true) {
         synchronous if(fires(i)) put(l, get(i));
         synchronous if(fires(i)) put(r, get(i));
+    }
+}
 primitive replicator(in i, out l, out r) {
     while(true) synchronous {
         if(fires(i)) {
             msg m = get(i);
             put(l, m);
             put(r, m);
+        }
+    }
+}
 primitive merger(in l, in r, out o) {
     while(true) synchronous {
         if(fires(l))      put(o, get(l));
         else if(fires(r)) put(o, get(r));
+    }
+}
 ";
 impl InputSource {
     // Constructors
     pub fn new<R: io::Read, S: ToString>(filename: S, reader: &mut R) -> io::Result<InputSource> {
         let mut vec = Vec::new();
         reader.read_to_end(&mut vec)?;
         vec.extend(STD_LIB_PDL.to_vec());
         Ok(InputSource {
             filename: filename.to_string(),
             input: vec,
             line: 1,
             column: 1,
             offset: 0,
         })
+    }
     // Constructor helpers
     pub fn from_file(path: &Path) -> io::Result<InputSource> {
         let filename = path.file_name();
         match filename {
             Some(filename) => {
                 let mut f = File::open(path)?;
                 InputSource::new(filename.to_string_lossy(), &mut f)
+            }
             None => Err(io::Error::new(io::ErrorKind::NotFound, "Invalid path")),
+        }
+    }
     pub fn from_string(string: &str) -> io::Result<InputSource> {
         let buffer = Box::new(string);
         let mut bytes = buffer.as_bytes();
         InputSource::new(String::new(), &mut bytes)
+    }
     pub fn from_buffer(buffer: &[u8]) -> io::Result<InputSource> {
         InputSource::new(String::new(), &mut Box::new(buffer))
+    }
     // Internal methods
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, column: self.column, offset: self.offset }
+    }
     pub fn seek(&mut self, pos: InputPosition) {
         debug_assert!(pos.offset < self.input.len());
         self.line = pos.line;
         self.column = pos.column;
         self.offset = pos.offset;
+    }
     // pub fn error<S: ToString>(&self, message: S) -> ParseError {
     //     self.pos().parse_error(message)
     // }
     pub fn is_eof(&self) -> bool {
         self.next() == None
+    }
     pub fn next(&self) -> Option<u8> {
         if self.offset < self.input.len() {
             Some(self.input[self.offset])
         } else {
             None
+        }
+    }
     pub fn lookahead(&self, pos: usize) -> Option<u8> {
         let offset_pos = self.offset + pos;
         if offset_pos < self.input.len() {
             Some(self.input[offset_pos])
         } else {
             None
+        }
+    }
     pub fn has(&self, to_compare: &[u8]) -> bool {
         if self.offset + to_compare.len() <= self.input.len() {
             for idx in 0..to_compare.len() {
                 if to_compare[idx] != self.input[self.offset + idx] {
                     return false;
+                }
+            }
             true
         } else {
             false
+        }
+    }
     pub fn consume(&mut self) {
         match self.next() {
             Some(x) if x == b'\r' && self.lookahead(1) != Some(b'\n') || x == b'\n' => {
                 self.line += 1;
                 self.offset += 1;
                 self.column = 1;
+            }
             Some(_) => {
                 self.offset += 1;
                 self.column += 1;
+            }
             None => {}
+        }
+    }
+}
 impl fmt::Display for InputSource {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.pos().fmt(f)
+    }
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub struct InputPosition {
     line: usize,
     column: usize,
     offset: usize,
+}
 impl InputPosition {
     fn context<'a>(&self, source: &'a InputSource) -> &'a [u8] {
         let start = self.offset - (self.column - 1);
         let mut end = self.offset;
         while end < source.input.len() {
             let cur = (*source.input)[end];
             if cur == b'\n' || cur == b'\r' {
                 break;
+            }
             end += 1;
+        }
         &source.input[start..end]
+    }
     // fn parse_error<S: ToString>(&self, message: S) -> ParseError {
     //     ParseError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }
     // }
     fn eval_error<S: ToString>(&self, message: S) -> EvalError {
         EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }
+    }
+}
 impl Default for InputPosition {
     fn default() -> Self {
         Self{ line: 1, column: 1, offset: 0 }
+    }
+}
 impl fmt::Display for InputPosition {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}:{}", self.line, self.column)
+    }
+}
 pub trait SyntaxElement {
     fn position(&self) -> InputPosition;
     fn error<S: ToString>(&self, message: S) -> EvalError {
         self.position().eval_error(message)
+    }
+}
 #[derive(Debug)]
 pub enum ParseErrorType {
     Info,
     Error
+}
 #[derive(Debug)]
 pub struct ParseErrorStatement {
     error_type: ParseErrorType,
     position: InputPosition,
     filename: String,
     context: String,
     message: String,
+}
 impl ParseErrorStatement {
     fn from_source(error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         // Seek line start and end
         println!("DEBUG[1]:\nPos {}, msg: {},\nDEBUG[2]: In source:\n{}",
             position, msg, String::from_utf8_lossy(&source.input));
         debug_assert!(position.column < position.offset);
         let line_start = position.offset - (position.column - 1);
         let mut line_end = position.offset;
         while line_end < source.input.len() && source.input[line_end] != b'\n' {
             line_end += 1;
+        }
         // Compensate for '\r\n'
         if line_end > line_start && source.input[line_end - 1] == b'\r' {
             line_end -= 1;
+        }
         Self{
             error_type,
             position,
             filename: source.filename.clone(),
             context: String::from_utf8_lossy(&source.input[line_start..line_end]).to_string(),
             message: msg.to_string()
+        }
+    }
+}
 impl fmt::Display for ParseErrorStatement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Write message
         match self.error_type {
             ParseErrorType::Info => write!(f, " INFO: ")?,
             ParseErrorType::Error => write!(f, "ERROR: ")?,
+        }
         writeln!(f, "{}", &self.message);
         // Write originating file/line/column
         if self.filename.is_empty() {
             writeln!(f, " +- at {}:{}", self.position.line, self.position.column)?;
         } else {
             writeln!(f, " +- at {}:{}:{}", self.filename, self.position.line, self.position.column)?;
+        }
         // Write source context
         writeln!(f, " | ")?;
         writeln!(f, " | {}", self.context)?;
         // Write underline indicating where the error ocurred
         debug_assert!(self.position.column <= self.context.chars().count());
         let mut arrow = String::with_capacity(self.context.len() + 3);
         arrow.push_str(" | ");
         let mut char_col = 1;
         for char in self.context.chars() {
             if char_col == self.position.column { break; }
             if char == '\t' {
                 arrow.push('\t');
             } else {
                 arrow.push(' ');
+            }
             char_col += 1;
+        }
         arrow.push('^');
         writeln!(f, "{}", arrow)?;
         Ok(())
+    }
+}
 #[derive(Debug)]
 pub struct ParseError2 {
     statements: Vec<ParseErrorStatement>
+}
 impl fmt::Display for ParseError2 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.statements.is_empty() {
             return Ok(())
+        }
         self.statements[0].fmt(f)?;
         for statement in self.statements.iter().skip(1) {
             writeln!(f)?;
             statement.fmt(f)?;
+        }
         Ok(())
+    }
+}
 impl ParseError2 {
     pub fn empty() -> Self {
         Self{ statements: Vec::new() }
+    }
     pub fn new_error(source: &InputSource, position: InputPosition, msg: &str) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source(ParseErrorType::Error, source, position, msg))}
+    }
     pub fn with_prefixed(mut self, error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.statements.insert(0, ParseErrorStatement::from_source(error_type, source, position, msg));
         self
+    }
     pub fn with_postfixed(mut self, error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.statements.push(ParseErrorStatement::from_source(error_type, source, position, msg));
         self
+    }
     pub fn with_postfixed_info(self, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.with_postfixed(ParseErrorType::Info, source, position, msg)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct EvalError {
     position: InputPosition,
     message: String,
     backtrace: Backtrace,
+}
 impl EvalError {
     pub fn new<S: ToString>(position: InputPosition, message: S) -> EvalError {
         EvalError { position, message: message.to_string(), backtrace: Backtrace::new() }
+    }
     // Diagnostic methods
     pub fn write<A: io::Write>(&self, source: &InputSource, writer: &mut A) -> io::Result<()> {
         if !source.filename.is_empty() {
             writeln!(
                 writer,
                 "Evaluation error at {}:{}: {}",
                 source.filename, self.position, self.message
             )?;
         } else {
             writeln!(writer, "Evaluation error at {}: {}", self.position, self.message)?;
+        }
         let line = self.position.context(source);
         writeln!(writer, "{}", String::from_utf8_lossy(line))?;
         let mut arrow: Vec<u8> = Vec::new();
         for pos in 1..self.position.column {
             let c = line[pos - 1];
             if c == b'\t' {
                 arrow.push(b'\t')
             } else {
                 arrow.push(b' ')
+            }
+        }
         arrow.push(b'^');
         writeln!(writer, "{}", String::from_utf8_lossy(&arrow))
+    }
     pub fn print(&self, source: &InputSource) {
         self.write(source, &mut std::io::stdout()).unwrap()
+    }
     pub fn display<'a>(&'a self, source: &'a InputSource) -> DisplayEvalError<'a> {
         DisplayEvalError::new(self, source)
+    }
+}
 impl From<EvalError> for io::Error {
     fn from(_: EvalError) -> io::Error {
         io::Error::new(io::ErrorKind::InvalidInput, "eval error")
+    }
+}
 #[derive(Clone, Copy)]
 pub struct DisplayEvalError<'a> {
     error: &'a EvalError,
     source: &'a InputSource,
+}
 impl DisplayEvalError<'_> {
     fn new<'a>(error: &'a EvalError, source: &'a InputSource) -> DisplayEvalError<'a> {
         DisplayEvalError { error, source }
+    }
+}
 impl fmt::Display for DisplayEvalError<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut vec: Vec<u8> = Vec::new();
         match self.error.write(self.source, &mut vec) {
             Err(_) => {
                 return fmt::Result::Err(fmt::Error);
+            }
             Ok(_) => {}
+        }
         write!(f, "{}", String::from_utf8_lossy(&vec))
+    }
+}
 // #[cfg(test)]
 // mod tests {
 //     use super::*;
 //     #[test]
 //     fn test_from_string() {
 //         let mut is = InputSource::from_string("#version 100\n").unwrap();
 //         assert!(is.input.len() == 13);

src/protocol/mod.rs

➞

Show inline comments

 mod arena;
 // mod ast;
 mod eval;
 pub(crate) mod inputsource;
 // mod lexer;
 mod library;
 mod parser;
 // TODO: Remove when not benchmarking
 pub(crate) mod ast;
 pub(crate) mod ast_printer;
 pub(crate) mod lexer;
 lazy_static::lazy_static! {
     /// Conveniently-provided protocol description initialized with a zero-length PDL string.
     /// Exposed to minimize repeated initializations of this common protocol description.
     pub static ref TRIVIAL_PD: std::sync::Arc<ProtocolDescription> = {
         std::sync::Arc::new(ProtocolDescription::parse(b"").unwrap())
     };
+}
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 /// Description of a protocol object, used to configure new connectors.
 /// (De)serializable.
 #[derive(serde::Serialize, serde::Deserialize)]
 #[repr(C)]
 pub struct ProtocolDescription {
     heap: Heap,
     source: InputSource,
     root: RootId,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub(crate) struct ComponentState {
     prompt: Prompt,
+}
 pub(crate) enum EvalContext<'a> {
     Nonsync(&'a mut NonsyncProtoContext<'a>),
     Sync(&'a mut SyncProtoContext<'a>),
     // None,
+}
 //////////////////////////////////////////////
 impl std::fmt::Debug for ProtocolDescription {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "(An opaque protocol description)")
+    }
+}
 impl ProtocolDescription {
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         // TODO: @fixme, keep code compilable, but needs support for multiple
         //  input files.
         let source = InputSource::from_buffer(buffer).unwrap();
         let mut parser = Parser::new();
         parser.feed(source).expect("failed to parse source");
         match parser.parse() {
             Ok(root) => {
                 return Ok(ProtocolDescription { heap: parser.heap, source: parser.modules[0].source.clone(), root });
+            }
             Err(err) => {
                 println!("ERROR:\n{}", err);
                 Err(format!("{}", err))
+            }
+        }
+    }
     pub(crate) fn component_polarities(
         &self,
         identifier: &[u8],
     ) -> Result<Vec<Polarity>, AddComponentError> {
         use AddComponentError::*;
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier);
         if def.is_none() {
             return Err(NoSuchComponent);
+        }
         let def = &h[def.unwrap()];
         if !def.is_component() {
             return Err(NoSuchComponent);
+        }
         for &param in def.parameters().iter() {
             let param = &h[param];
             let type_annot = &h[param.type_annotation];
             if type_annot.the_type.array {
                 return Err(NonPortTypeParameters);
+            }
             match type_annot.the_type.primitive {
                 PrimitiveType::Input | PrimitiveType::Output => continue,
                 _ => {
                     return Err(NonPortTypeParameters);
+                }
+            }
+        }
         let mut result = Vec::new();
         for &param in def.parameters().iter() {
             let param = &h[param];
             let type_annot = &h[param.type_annotation];
             let ptype = &type_annot.the_type.primitive;
             if ptype == &PrimitiveType::Input {
                 result.push(Polarity::Getter)
             } else if ptype == &PrimitiveType::Output {
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     // expects port polarities to be correct
     pub(crate) fn new_component(&self, identifier: &[u8], ports: &[PortId]) -> ComponentState {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
             match y {
                 Polarity::Getter => args.push(Value::Input(InputValue(x))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(x))),
+            }
+        }
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier).unwrap();
         ComponentState { prompt: Prompt::new(h, def, &args) }
+    }
+}
 impl ComponentState {
     pub(crate) fn nonsync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut NonsyncProtoContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> NonsyncBlocker {
         let mut context = EvalContext::Nonsync(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // In component definitions, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return NonsyncBlocker::Inconsistent,
                     EvalContinuation::Terminal => return NonsyncBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return NonsyncBlocker::SyncBlockStart,
                     // Not possible to end sync block if never entered one
                     EvalContinuation::SyncBlockEnd => unreachable!(),
                     EvalContinuation::NewComponent(definition_id, args) => {
                         // Look up definition (TODO for now, assume it is a definition)
                         let h = &pd.heap;
                         let init_state = ComponentState { prompt: Prompt::new(h, definition_id, &args) };
                         context.new_component(&args, init_state);
                         // Continue stepping
                         continue;
+                    }
                     // Outside synchronous blocks, no fires/get/put happens
                     EvalContinuation::BlockFires(_) => unreachable!(),
                     EvalContinuation::BlockGet(_) => unreachable!(),
                     EvalContinuation::Put(_, _) => unreachable!(),
                 },
+            }
+        }
+    }
     pub(crate) fn sync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut SyncProtoContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> SyncBlocker {
         let mut context = EvalContext::Sync(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // Inside synchronous blocks, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return SyncBlocker::Inconsistent,
                     // First need to exit synchronous block before definition may end
                     EvalContinuation::Terminal => unreachable!(),
                     // No nested synchronous blocks
                     EvalContinuation::SyncBlockStart => unreachable!(),
                     EvalContinuation::SyncBlockEnd => return SyncBlocker::SyncBlockEnd,
                     // Not possible to create component in sync block
                     EvalContinuation::NewComponent(_, _) => unreachable!(),
                     EvalContinuation::BlockFires(port) => match port {
                         Value::Output(OutputValue(port)) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         Value::Input(InputValue(port)) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::BlockGet(port) => match port {
                         Value::Output(OutputValue(port)) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
                         Value::Input(InputValue(port)) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::Put(port, message) => {
                         let value;
                         match port {
                             Value::Output(OutputValue(port_value)) => {
                                 value = port_value;
+                            }
                             Value::Input(InputValue(port_value)) => {
                                 value = port_value;
+                            }
                             _ => unreachable!(),
+                        }
                         let payload;
                         match message {
                             Value::Message(MessageValue(None)) => {
                                 // Putting a null message is inconsistent
                                 return SyncBlocker::Inconsistent;
+                            }
                             Value::Message(MessageValue(Some(buffer))) => {
                                 // Create a copy of the payload
                                 payload = buffer;
+                            }
                             _ => unreachable!(),
+                        }
                         return SyncBlocker::PutMsg(value, payload);
+                    }
                 },
+            }
+        }
+    }
+}
 impl EvalContext<'_> {
     // fn random(&mut self) -> LongValue {
     //     match self {
     //         // EvalContext::None => unreachable!(),
     //         EvalContext::Nonsync(_context) => todo!(),
     //         EvalContext::Sync(_) => unreachable!(),
     //     }
     // }
     fn new_component(&mut self, args: &[Value], init_state: ComponentState) -> () {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let mut moved_ports = HashSet::new();
                 for arg in args.iter() {
                     match arg {
                         Value::Output(OutputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         Value::Input(InputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         _ => {}
+                    }
+                }
                 context.new_component(moved_ports, init_state)

src/protocol/parser/depth_visitor.rs

➞

Show inline comments

@@ @@ -126,385 +126,386 @@ pub(crate) trait Visitor: Sized { @@
+    }
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         recursive_assignment_expression(self, h, expr)
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         recursive_conditional_expression(self, h, expr)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         recursive_binary_expression(self, h, expr)
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         recursive_unary_expression(self, h, expr)
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         recursive_indexing_expression(self, h, expr)
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         recursive_slicing_expression(self, h, expr)
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         recursive_select_expression(self, h, expr)
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         recursive_array_expression(self, h, expr)
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         recursive_call_expression(self, h, expr)
+    }
     fn visit_constant_expression(
         &mut self,
         _h: &mut Heap,
         _expr: ConstantExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
         _h: &mut Heap,
         _expr: VariableExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
+}
 // Bubble-up helpers
 fn recursive_parameter_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     param: ParameterId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, param.upcast())
+}
 fn recursive_local_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     local: LocalId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, local.upcast())
+}
 fn recursive_call_expression_as_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     call: CallExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, call.upcast())
+}
 // Recursive procedures
 fn recursive_protocol_description<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     pd: RootId,
 ) -> VisitorResult {
     for &pragma in h[pd].pragmas.clone().iter() {
         this.visit_pragma(h, pragma)?;
+    }
     for &import in h[pd].imports.clone().iter() {
         this.visit_import(h, import)?;
+    }
     for &def in h[pd].definitions.clone().iter() {
         this.visit_symbol_definition(h, def)?;
+    }
     Ok(())
+}
 fn recursive_symbol_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: DefinitionId,
 ) -> VisitorResult {
     // We clone the definition in case it is modified
     // TODO: Fix me
     match h[def].clone() {
         Definition::Struct(def) => this.visit_struct_definition(h, def.this),
         Definition::Enum(def) => this.visit_enum_definition(h, def.this),
         Definition::Component(cdef) => this.visit_component_definition(h, cdef.this),
         Definition::Function(fdef) => this.visit_function_definition(h, fdef.this),
+    }
+}
 fn recursive_component_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentId,
 ) -> VisitorResult {
     let component_variant = h[def].variant;
     match component_variant {
         ComponentVariant::Primitive => this.visit_primitive_definition(h, def),
         ComponentVariant::Composite => this.visit_composite_definition(h, def),
+    }
+}
 fn recursive_composite_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_primitive_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_function_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: FunctionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_variable_declaration<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     decl: VariableId,
 ) -> VisitorResult {
     match h[decl].clone() {
         Variable::Parameter(decl) => this.visit_parameter_declaration(h, decl.this),
         Variable::Local(decl) => this.visit_local_declaration(h, decl.this),
+    }
+}
 fn recursive_statement<T: Visitor>(this: &mut T, h: &mut Heap, stmt: StatementId) -> VisitorResult {
     match h[stmt].clone() {
         Statement::Block(stmt) => this.visit_block_statement(h, stmt.this),
         Statement::Local(stmt) => this.visit_local_statement(h, stmt.this()),
         Statement::Skip(stmt) => this.visit_skip_statement(h, stmt.this),
         Statement::Labeled(stmt) => this.visit_labeled_statement(h, stmt.this),
         Statement::If(stmt) => this.visit_if_statement(h, stmt.this),
         Statement::While(stmt) => this.visit_while_statement(h, stmt.this),
         Statement::Break(stmt) => this.visit_break_statement(h, stmt.this),
         Statement::Continue(stmt) => this.visit_continue_statement(h, stmt.this),
         Statement::Synchronous(stmt) => this.visit_synchronous_statement(h, stmt.this),
         Statement::Return(stmt) => this.visit_return_statement(h, stmt.this),
         Statement::Assert(stmt) => this.visit_assert_statement(h, stmt.this),
         Statement::Goto(stmt) => this.visit_goto_statement(h, stmt.this),
         Statement::New(stmt) => this.visit_new_statement(h, stmt.this),
         Statement::Put(stmt) => this.visit_put_statement(h, stmt.this),
         Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),
         Statement::EndSynchronous(_) | Statement::EndWhile(_) | Statement::EndIf(_) => {
             unreachable!() // pseudo-statement
             // unreachable!() // pseudo-statement
             Ok(())
+        }
+    }
+}
 fn recursive_block_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     block: BlockStatementId,
 ) -> VisitorResult {
     for &local in h[block].locals.clone().iter() {
         recursive_local_as_variable(this, h, local)?;
+    }
     for &stmt in h[block].statements.clone().iter() {
         this.visit_statement(h, stmt)?;
+    }
     Ok(())
+}
 fn recursive_local_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LocalStatementId,
 ) -> VisitorResult {
     match h[stmt].clone() {
         LocalStatement::Channel(stmt) => this.visit_channel_statement(h, stmt.this),
         LocalStatement::Memory(stmt) => this.visit_memory_statement(h, stmt.this),
+    }
+}
 fn recursive_memory_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: MemoryStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].initial)
+}
 fn recursive_labeled_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LabeledStatementId,
 ) -> VisitorResult {
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_if_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: IfStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_statement(h, h[stmt].true_body)?;
     this.visit_statement(h, h[stmt].false_body)
+}
 fn recursive_while_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: WhileStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_synchronous_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: SynchronousStatementId,
 ) -> VisitorResult {
     // TODO: Check where this was used for
     // for &param in h[stmt].parameters.clone().iter() {
     //     recursive_parameter_as_variable(this, h, param)?;
     // }
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_return_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ReturnStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_assert_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: AssertStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_new_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: NewStatementId,
 ) -> VisitorResult {
     recursive_call_expression_as_expression(this, h, h[stmt].expression)
+}
 fn recursive_put_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: PutStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].port)?;
     this.visit_expression(h, h[stmt].message)
+}
 fn recursive_expression_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ExpressionStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ExpressionId,
 ) -> VisitorResult {
     match h[expr].clone() {
         Expression::Assignment(expr) => this.visit_assignment_expression(h, expr.this),
         Expression::Conditional(expr) => this.visit_conditional_expression(h, expr.this),
         Expression::Binary(expr) => this.visit_binary_expression(h, expr.this),
         Expression::Unary(expr) => this.visit_unary_expression(h, expr.this),
         Expression::Indexing(expr) => this.visit_indexing_expression(h, expr.this),
         Expression::Slicing(expr) => this.visit_slicing_expression(h, expr.this),
         Expression::Select(expr) => this.visit_select_expression(h, expr.this),
         Expression::Array(expr) => this.visit_array_expression(h, expr.this),
         Expression::Constant(expr) => this.visit_constant_expression(h, expr.this),
         Expression::Call(expr) => this.visit_call_expression(h, expr.this),
         Expression::Variable(expr) => this.visit_variable_expression(h, expr.this),
+    }
+}
 fn recursive_assignment_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: AssignmentExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_conditional_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ConditionalExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].test)?;
     this.visit_expression(h, h[expr].true_expression)?;
     this.visit_expression(h, h[expr].false_expression)
+}
 fn recursive_binary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: BinaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_unary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: UnaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].expression)
+}
 fn recursive_indexing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: IndexingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     this.visit_expression(h, h[expr].index)
+}
 fn recursive_slicing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: SlicingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     this.visit_expression(h, h[expr].from_index)?;
     this.visit_expression(h, h[expr].to_index)
+}

src/protocol/parser/mod.rs

➞

Show inline comments

 mod depth_visitor;
 mod symbol_table;
 mod type_table;
 mod visitor;
 use depth_visitor::*;
 use symbol_table::SymbolTable;
 use visitor::{Visitor2, ValidityAndLinkerVisitor};
 use type_table::TypeTable;
 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::lexer::*;
 use std::collections::HashMap;
 use crate::protocol::parser::visitor::Ctx;
 use crate::protocol::ast_printer::ASTWriter;
 // TODO: @fixme, pub qualifier
 pub(crate) struct LexedModule {
     pub(crate) source: InputSource,
     module_name: Vec<u8>,
     version: Option<u64>,
     root_id: RootId,
+}
 pub struct Parser {
     pub(crate) heap: Heap,
     pub(crate) modules: Vec<LexedModule>,
     pub(crate) module_lookup: HashMap<Vec<u8>, usize>, // from (optional) module name to `modules` idx
+}
 impl Parser {
     pub fn new() -> Self {
         Parser{
             heap: Heap::new(),
             modules: Vec::new(),
             module_lookup: HashMap::new()
+        }
+    }
     // TODO: @fix, temporary implementation to keep code compilable
     pub fn new_with_source(source: InputSource) -> Result<Self, ParseError2> {
         let mut parser = Parser::new();
         parser.feed(source)?;
         Ok(parser)
+    }
     pub fn feed(&mut self, mut source: InputSource) -> Result<RootId, ParseError2> {
         // Lex the input source
         let mut lex = Lexer::new(&mut source);
         let pd = lex.consume_protocol_description(&mut self.heap)?;
         // Seek the module name and version
         let root = &self.heap[pd];
         let mut module_name_pos = InputPosition::default();
         let mut module_name = Vec::new();
         let mut module_version_pos = InputPosition::default();
         let mut module_version = None;
         for pragma in &root.pragmas {
             match &self.heap[*pragma] {
                 Pragma::Module(module) => {
                     if !module_name.is_empty() {
                         return Err(
                             ParseError2::new_error(&source, module.position, "Double definition of module name in the same file")
                                 .with_postfixed_info(&source, module_name_pos, "Previous definition was here")
+                        )
+                    }
                     module_name_pos = module.position.clone();
                     module_name = module.value.clone();
                 },
                 Pragma::Version(version) => {
                     if module_version.is_some() {
                         return Err(
                             ParseError2::new_error(&source, version.position, "Double definition of module version")
                                 .with_postfixed_info(&source, module_version_pos, "Previous definition was here")
+                        )
+                    }
                     module_version_pos = version.position.clone();
                     module_version = Some(version.version);
                 },
+            }
+        }
         // Add module to list of modules and prevent naming conflicts
         let cur_module_idx = self.modules.len();
         if let Some(prev_module_idx) = self.module_lookup.get(&module_name) {
             // Find `#module` statement in other module again
             let prev_module = &self.modules[*prev_module_idx];
             let prev_module_pos = self.heap[prev_module.root_id].pragmas
                 .iter()
                 .find_map(|p| {
                     match &self.heap[*p] {
                         Pragma::Module(module) => Some(module.position.clone()),
                         _ => None
+                    }
                 })
                 .unwrap_or(InputPosition::default());
             let module_name_msg = if module_name.is_empty() {
                 format!("a nameless module")
             } else {
                 format!("module '{}'", String::from_utf8_lossy(&module_name))
             };
             return Err(
                 ParseError2::new_error(&source, module_name_pos, &format!("Double definition of {} across files", module_name_msg))
                     .with_postfixed_info(&prev_module.source, prev_module_pos, "Other definition was here")
             );
+        }
         self.modules.push(LexedModule{
             source,
             module_name: module_name.clone(),
             version: module_version,
             root_id: pd
         });
         self.module_lookup.insert(module_name, cur_module_idx);
         Ok(pd)
+    }
     pub fn compile(&mut self) {
         // Build module lookup
+    }
     fn resolve_symbols_and_types(&mut self) -> Result<(SymbolTable, TypeTable), ParseError2> {
         // Construct the symbol table to resolve any imports and/or definitions,
         // then use the symbol table to actually annotate all of the imports.
         // If the type table is constructed correctly then all imports MUST be
         // resolvable.
         // TODO: Update once namespaced identifiers are implemented
         let symbol_table = SymbolTable::new(&self.heap, &self.modules)?;
         // Not pretty, but we need to work around rust's borrowing rules, it is
         // totally safe to mutate the contents of an AST element that we are
         // not borrowing anywhere else.
         // TODO: Maybe directly access heap's members to allow borrowing from
         //  mutliple members of Heap? Not pretty though...
         let mut module_index = 0;
         let mut import_index = 0;
         loop {
             if module_index >= self.modules.len() {
                 break;
+            }
             let module_root_id = self.modules[module_index].root_id;
             let import_id = {
                 let root = &self.heap[module_root_id];
                 if import_index >= root.imports.len() {
                     module_index += 1;
                     import_index = 0;
                     continue
+                }
                 root.imports[import_index]
             };
             let import = &mut self.heap[import_id];
             match import {
                 Import::Module(import) => {
                     debug_assert!(import.module_id.is_none(), "module import already resolved");
                     let target_module_id = symbol_table.resolve_module(&import.module_name)
                         .expect("module import is resolved by symbol table");
                     import.module_id = Some(target_module_id)
                 },
                 Import::Symbols(import) => {
                     debug_assert!(import.module_id.is_none(), "module of symbol import already resolved");
                     let target_module_id = symbol_table.resolve_module(&import.module_name)
                         .expect("symbol import's module is resolved by symbol table");
                     import.module_id = Some(target_module_id);
                     for symbol in &mut import.symbols {
                         debug_assert!(symbol.definition_id.is_none(), "symbol import already resolved");
                         let (_, target_definition_id) = symbol_table.resolve_symbol(module_root_id, &symbol.alias)
                             .expect("symbol import is resolved by symbol table")
                             .as_definition()
                             .expect("symbol import does not resolve to namespace symbol");
                         symbol.definition_id = Some(target_definition_id);
+                    }
+                }
+            }
+        }
         // All imports in the AST are now annotated. We now use the symbol table
         // to construct the type table.
         let type_table = TypeTable::new(&symbol_table, &self.heap, &self.modules)?;
         Ok((symbol_table, type_table))
+    }
     // TODO: @fix, temporary impl to keep code compilable
     pub fn parse(&mut self) -> Result<RootId, ParseError2> {
         assert_eq!(self.modules.len(), 1, "Fix meeeee");
         let root_id = self.modules[0].root_id;
         let (mut symbol_table, mut type_table) = self.resolve_symbols_and_types()?;
         // TODO: @cleanup
         let mut ctx = visitor::Ctx{
             heap: &mut self.heap,
             module: &self.modules[0],
             symbols: &mut symbol_table,
             types: &mut type_table,
         };
         let mut visit = ValidityAndLinkerVisitor::new();
         if let Err(err) = visit.visit_module(&mut ctx) {
             println!("ERROR:\n{}", err);
             return Err(err)
+        }
         let mut writer = ASTWriter::new();
         let mut file = std::fs::File::create(std::path::Path::new("ast.txt")).unwrap();
         writer.write_ast(&mut file, &self.heap);
         if let Err((position, message)) = Self::parse_inner(&mut self.heap, root_id) {
             return Err(ParseError2::new_error(&self.modules[0].source, position, &message))
+        }
         Ok(root_id)
+    }
     pub fn parse_inner(h: &mut Heap, pd: RootId) -> VisitorResult {
         // TODO: @cleanup, slowly phasing out old compiler
         NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;
         ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;
         FunctionStatementReturns::new().visit_protocol_description(h, pd)?;
         ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;
         CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;
         BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;
         // NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;
         // ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;
         // FunctionStatementReturns::new().visit_protocol_description(h, pd)?;
         // ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;
         // CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;
         // BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;
         LinkCallExpressions::new().visit_protocol_description(h, pd)?;
         BuildScope::new().visit_protocol_description(h, pd)?;
         ResolveVariables::new().visit_protocol_description(h, pd)?;
         // BuildScope::new().visit_protocol_description(h, pd)?;
         // ResolveVariables::new().visit_protocol_description(h, pd)?;
         LinkStatements::new().visit_protocol_description(h, pd)?;
         // BuildLabels::new().visit_protocol_description(h, pd)?;
         // ResolveLabels::new().visit_protocol_description(h, pd)?;
         AssignableExpressions::new().visit_protocol_description(h, pd)?;
         IndexableExpressions::new().visit_protocol_description(h, pd)?;
         SelectableExpressions::new().visit_protocol_description(h, pd)?;
         Ok(())
+    }
+}
 #[cfg(test)]
 mod tests {
     use std::fs::File;
     use std::io::Read;
     use std::path::Path;
     use super::*;
     // #[test]
     fn positive_tests() {
         for resource in TestFileIter::new("testdata/parser/positive", "pdl") {
             let resource = resource.expect("read testdata filepath");
             // println!(" * running: {}", &resource);
             let path = Path::new(&resource);
             let source = InputSource::from_file(&path).unwrap();
             // println!("DEBUG -- input:\n{}", String::from_utf8_lossy(&source.input));
             let mut parser = Parser::new_with_source(source).expect("parse source");
             match parser.parse() {
                 Ok(_) => {}
                 Err(err) => {
                     println!(" > file: {}", &resource);
                     println!("{}", err);
                     assert!(false);
+                }
+            }
+        }
+    }
     // #[test]
     fn negative_tests() {
         for resource in TestFileIter::new("testdata/parser/negative", "pdl") {
             let resource = resource.expect("read testdata filepath");
             let path = Path::new(&resource);
             let expect = path.with_extension("txt");
             let mut source = InputSource::from_file(&path).unwrap();
             let mut parser = Parser::new_with_source(source).expect("construct parser");
             match parser.parse() {
                 Ok(pd) => {
                     println!("Expected parse error:");
                     let mut cev: Vec<u8> = Vec::new();
                     let mut f = File::open(expect).unwrap();
                     f.read_to_end(&mut cev).unwrap();
                     println!("{}", String::from_utf8_lossy(&cev));
                     assert!(false);
+                }
                 Err(err) => {
                     let expected = format!("{}", err);
                     println!("{}", &expected);
                     let mut cev: Vec<u8> = Vec::new();
                     let mut f = File::open(expect).unwrap();
                     f.read_to_end(&mut cev).unwrap();
                     println!("{}", String::from_utf8_lossy(&cev));
                     assert_eq!(expected.as_bytes(), cev);
+                }
+            }
+        }
+    }
     // #[test]
     fn counterexample_tests() {
         for resource in TestFileIter::new("testdata/parser/counterexamples", "pdl") {
             let resource = resource.expect("read testdata filepath");
             let path = Path::new(&resource);
             let source = InputSource::from_file(&path).unwrap();
             let mut parser = Parser::new_with_source(source).expect("construct parser");
             fn print_header(s: &str) {
                 println!("{}", "=".repeat(80));
                 println!(" > File: {}", s);
                 println!("{}", "=".repeat(80));
+            }
             match parser.parse() {
                 Ok(parsed) => {
                     print_header(&resource);
                     println!("\n  SUCCESS\n\n --- source:\n{}", String::from_utf8_lossy(&parser.modules[0].source.input));
                 },
                 Err(err) => {
                     print_header(&resource);
                     println!(
                         "\n  FAILURE\n\n --- error:\n{}\n --- source:\n{}",
                         err,
                         String::from_utf8_lossy(&parser.modules[0].source.input)
+                    )
+                }
+            }
+        }
+    }
     struct TestFileIter {
         iter: std::fs::ReadDir,
         root: String,
         extension: String
+    }
     impl TestFileIter {
         fn new(root_dir: &str, extension: &str) -> Self {
             let path = Path::new(root_dir);
             assert!(path.is_dir(), "root '{}' is not a directory", root_dir);
             let iter = std::fs::read_dir(path).expect("list dir contents");
             Self {
                 iter,
                 root: root_dir.to_string(),
                 extension: extension.to_string(),
+            }
+        }
+    }
     impl Iterator for TestFileIter {
         type Item = Result<String, String>;
         fn next(&mut self) -> Option<Self::Item> {
             while let Some(entry) = self.iter.next() {
                 if let Err(e) = entry {
                     return Some(Err(format!("failed to read dir entry, because: {}", e)));
+                }
                 let entry = entry.unwrap();
                 let path = entry.path();
                 if !path.is_file() { continue; }
                 let extension = path.extension();
                 if extension.is_none() { continue; }
                 let extension = extension.unwrap().to_string_lossy();
                 if extension != self.extension { continue; }
                 return Some(Ok(path.to_string_lossy().to_string()));
+            }
             None
+        }
+    }
+}

src/protocol/parser/visitor.rs

➞

Show inline comments

@@ @@ -678,540 +678,540 @@ impl Visitor2 for ValidityAndLinkerVisitor { @@
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         if !self.performing_breadth_pass {
             let expr_id = ctx.heap[id].expression;
             self.visit_expr(ctx, expr_id)?;
+        }
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let conditional_expr = &ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_expr(ctx, true_expr_id)?;
         self.visit_expr(ctx, false_expr_id)?;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let binary_expr = &ctx.heap[id];
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         self.visit_expr(ctx, left_expr_id)?;
         self.visit_expr(ctx, right_expr_id)?;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let expr_id = ctx.heap[id].expression;
         self.visit_expr(ctx, expr_id)?;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let indexing_expr = &ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, index_expr_id)?;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         // TODO: Same as the select expression: slicing depends on the type of
         //  the thing that is being sliced.
         let slicing_expr = &ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, from_expr_id)?;
         self.visit_expr(ctx, to_expr_id)?;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         // TODO: Is it true that this always depends on the return value? I
         //  mean: the following should be a valid expression:
         //  int i = some_call_that_returns_a_struct(5, 2).field_of_struct
         //  We could rule out some things (of which we're sure what the type is)
         //  but it seems better to do this later
         let expr_id = ctx.heap[id].subject;
         self.visit_expr(ctx, expr_id)?;
         Ok(())
+    }
     fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let array_expr = &ctx.heap[id];
         for field_expr_id in array_expr.elements.clone() { // TODO: @performance
             self.visit_expr(ctx, field_expr_id)?;
+        }
         Ok(())
+    }
     fn visit_constant_expr(&mut self, _ctx: &mut Ctx, _id: ConstantExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let call_expr = &mut ctx.heap[id];
         match &mut call_expr.method {
             Method::Create => {},
             Method::Fires => {
                 if self.def_type != DefinitionType::Primitive {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
             },
             Method::Get => {
                 if self.def_type != DefinitionType::Primitive {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'get' may only occur in primitive component definitions"
                     ));
+                }
             },
             Method::Symbolic(symbolic) => {
                 // Find symbolic method
                 let symbol = ctx.symbols.resolve_namespaced_symbol(ctx.module.root_id, &symbolic.identifier);
                 if symbol.is_none() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, symbolic.identifier.position,
                         "Could not find definition of function call"
                     ));
+                }
                 let (symbol, iter) = symbol.unwrap();
                 if iter.num_remaining() != 0 {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, symbolic.identifier.position,"Could not find definition of function call")
                             .with_postfixed_info(&ctx.module.source, symbol.position, "Could resolve part of the identifier to this symbol")
                     );
+                }
                 let definition_id = match &symbol.symbol {
                     Symbol::Definition((_, definition_id)) => {
                         let definition = ctx.types.get_definition(definition_id);
                         debug_assert!(definition.is_some(), "Symbol resolved to definition, but not present in type table");
                         let definition = definition.unwrap();
                         match definition {
                             DefinedType::Function(_) => Some(*definition_id),
                             _ => None,
+                        }
                     },
                     Symbol::Namespace(_) => None,
                 };
                 if definition_id.is_none() {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, symbolic.identifier.position, "Could not find definition of function call")
                     );
+                }
                 symbolic.definition = Some(definition_id.unwrap());
+            }
+        }
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let var_expr = &ctx.heap[id];
         println!("DEBUG: Finding variable {}", String::from_utf8_lossy(&var_expr.identifier.value));
         let variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier)?;
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         Ok(())
+    }
+}
 impl ValidityAndLinkerVisitor {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     fn visit_stmt_with_hint(&mut self, ctx: &mut Ctx, id: StatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if let Statement::Block(block_stmt) = &ctx.heap[id] {
             let block_id = block_stmt.this;
             self.visit_block_stmt_with_hint(ctx, block_id, hint)
         } else {
             self.visit_stmt(ctx, id)
+        }
+    }
     fn visit_block_stmt_with_hint(&mut self, ctx: &mut Ctx, id: BlockStatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if self.performing_breadth_pass {
             // Our parent is performing a breadth-pass. We do this simple stuff
             // here
             // Performing a breadth pass, so don't traverse into the statements
             // of the block.
             return Ok(())
+        }
         let body = &mut ctx.heap[id];
         body.parent_scope = self.cur_scope.clone();
         body.relative_pos_in_parent = self.relative_pos_in_block;
             return Ok(())
+        }
         // We may descend into children of this block. However, this is
         // where we first perform a breadth-first pass
         // TODO: This is where crap goes wrong! If we are performing the first
         //  breadth pass then we should take care of the scopes properly!
         self.performing_breadth_pass = true;
         let old_scope = self.cur_scope.replace(match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         });
         let first_statement_index = self.statement_buffer.len();
+        {
             let body = &ctx.heap[id];
             self.statement_buffer.extend_from_slice(&body.statements);
+        }
         let mut stmt_index = first_statement_index;
         while stmt_index < self.statement_buffer.len() {
             self.relative_pos_in_block = (stmt_index - first_statement_index) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_index])?;
             stmt_index += 1;
+        }
         if !self.insert_buffer.is_empty() {
             let body = &mut ctx.heap[id];
             for (pos, stmt) in self.insert_buffer.drain(..) {
                 body.statements.insert(pos as usize, stmt);
+            }
+        }
         // And the depth pass. Because we're not actually visiting any inserted
         // nodes because we're using the statement buffer, we may safely use the
         // relative_pos_in_block counter.
         self.performing_breadth_pass = false;
         stmt_index = first_statement_index;
         while stmt_index < self.statement_buffer.len() {
             self.relative_pos_in_block = (stmt_index - first_statement_index) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_index])?;
             stmt_index += 1;
+        }
         self.cur_scope = old_scope;
         // Pop statement buffer
         debug_assert!(self.insert_buffer.is_empty(), "insert buffer not empty after depth pass");
         self.statement_buffer.truncate(first_statement_index);
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the
     /// `Local` in the AST with its relative position in the block.
     fn checked_local_add(&mut self, ctx: &mut Ctx, relative_pos: u32, id: LocalId) -> Result<(), ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure we do not conflict with any global symbols
+        {
             let ident = &ctx.heap[id].identifier;
             if let Some(symbol) = ctx.symbols.resolve_symbol(ctx.module.root_id, &ident.value) {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, ident.position, "Local variable declaration conflicts with symbol")
                         .with_postfixed_info(&ctx.module.source, symbol.position, "Conflicting symbol is found here")
                 );
+            }
+        }
         let local = &mut ctx.heap[id];
         local.relative_pos_in_block = relative_pos;
         // Make sure we do not shadow any variables in any of the scopes. Note
         // that variables in parent scopes may be declared later
         let local = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         let mut local_relative_pos = self.relative_pos_in_block;
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_local_id in &block.locals {
                 let other_local = &ctx.heap[*other_local_id];
                 // Position check in case another variable with the same name
                 // is defined in a higher-level scope, but later than the scope
                 // in which the current variable resides.
                 if local_relative_pos > other_local.relative_pos_in_block && local.identifier.value == other_local.identifier.value {
                 if local.this != *other_local_id &&
                     local_relative_pos >= other_local.relative_pos_in_block &&
                     local.identifier.value == other_local.identifier.value {
                     // Collision within this scope
                     return Err(
                         ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable")
                             .with_postfixed_info(&ctx.module.source, other_local.position, "Previous variable is found here")
                     );
+                }
+            }
             // Current scope is fine, move to parent scope if any
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if let Scope::Definition(definition_id) = scope {
                 // At outer scope, check parameters of function/component
                 for parameter_id in ctx.heap[*definition_id].parameters() {
                     let parameter = &ctx.heap[*parameter_id];
                     if local.identifier.value == parameter.identifier.value {
                         return Err(
                             ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter")
                                 .with_postfixed_info(&ctx.module.source, parameter.position, "Parameter definition is found here")
                         );
+                    }
+                }
                 break;
+            }
             // If here, then we are dealing with a block-like parent block
             local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
+        }
         // No collisions at all
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.locals.push(id);
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
     fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier) -> Result<VariableId, ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         debug_assert!(identifier.num_namespaces > 0);
         // TODO: Update once globals are possible as well
         if identifier.num_namespaces > 1 {
             todo!("Implement namespaced constant seeking")
+        }
         // TODO: May still refer to an alias of a global symbol using a single
         //  identifier in the namespace.
         // No need to use iterator over namespaces if here
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             println!("DEBUG: Looking at block {}...", scope.);
             debug_assert!(scope.is_block());
             let block = &ctx.heap[scope.to_block()];
             for local_id in &block.locals {
                 let local = &ctx.heap[*local_id];
                 println!("DEBUG: With local {}", String::from_utf8_lossy(&local.identifier.value));
                 if local.relative_pos_in_block < relative_pos && local.identifier.value == identifier.value {
                     return Ok(local_id.upcast());
+                }
+            }
             debug_assert!(block.parent_scope.is_some());
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 // Definition scope, need to check arguments to definition
                 match scope {
                     Scope::Definition(definition_id) => {
                         let definition = &ctx.heap[*definition_id];
                         for parameter_id in definition.parameters() {
                             let parameter = &ctx.heap[*parameter_id];
                             if parameter.identifier.value == identifier.value {
                                 return Ok(parameter_id.upcast());
+                            }
+                        }
                     },
                     _ => unreachable!(),
+                }
                 // Variable could not be found
                 return Err(ParseError2::new_error(
                     &ctx.module.source, identifier.position, "This variable is not declared"
                 ));
             } else {
                 relative_pos = block.relative_pos_in_parent;
+            }
+        }
+    }
     fn checked_label_add(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> Result<(), ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure label is not defined within the current scope or any of the
         // parent scope.
         let label = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_label_id in &block.labels {
                 let other_label = &ctx.heap[*other_label_id];
                 if other_label.label.value == label.label.value {
                     // Collision
                     return Err(
                         ParseError2::new_error(&ctx.module.source, label.position, "Label name conflicts with another label")
                             .with_postfixed_info(&ctx.module.source, other_label.position, "Other label is found here")
                     );
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 break;
+            }
+        }
         // No collisions
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.labels.push(id);
         Ok(())
+    }
     /// Finds a particular labeled statement by its identifier. Once found it
     /// will make sure that the target label does not skip over any variable
     /// declarations within the scope in which the label was found.
     fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let relative_scope_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
             let block = &ctx.heap[scope.to_block()];
             for label_id in &block.labels {
                 let label = &ctx.heap[*label_id];
                 if label.label.value == identifier.value {
                     for local_id in &block.locals {
                         // TODO: Better to do this in control flow analysis, it
                         //  is legal to skip over a variable declaration if it
                         //  is not actually being used. I might be missing
                         //  something here when laying out the bytecode...
                         let local = &ctx.heap[*local_id];
                         if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {
                             return Err(
                                 ParseError2::new_error(&ctx.module.source, identifier.position, "This target label skips over a variable declaration")
                                     .with_postfixed_info(&ctx.module.source, label.position, "Because it jumps to this label")
                                     .with_postfixed_info(&ctx.module.source, local.position, "Which skips over this variable")
                             );
+                        }
+                    }
                     return Ok(*label_id);
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return Err(ParseError2::new_error(&ctx.module.source, identifier.position, "Could not find this label"));
+            }
+        }
+    }
     /// This function will check if the provided while statement ID has a block
     /// statement that is one of our current parents.
     fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
             if while_stmt.body == block.upcast() {
                 return true;
+            }
             let block = &ctx.heap[block];
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return false;
+            }
+        }
+    }
     /// This function should be called while dealing with break/continue
     /// statements. It will try to find the targeted while statement, using the
     /// target label if provided. If a valid target is found then the loop's
     /// ID will be returned, otherwise a parsing error is constructed.
     /// The provided input position should be the position of the break/continue
     /// statement.
     fn resolve_break_or_continue_target(&self, ctx: &Ctx, position: InputPosition, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError2> {
         let target = match label {
             Some(label) => {
                 let target_id = self.find_label(ctx, label)?;
                 // Make sure break target is a while statement
                 let target = &ctx.heap[target_id];
                 if let Statement::While(target_stmt) = &ctx.heap[target.body] {
                     // Even though we have a target while statement, the break might not be
                     // present underneath this particular labeled while statement
                     if !self.has_parent_while_scope(ctx, target_stmt.this) {
                         ParseError2::new_error(&ctx.module.source, label.position, "Break statement is not nested under the target label's while statement")
                             .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here");
+                    }
                     target_stmt.this
                 } else {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, label.position, "Incorrect break target label, it must target a while loop")
                             .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here")
                     );
+                }
             },
             None => {
                 // Use the enclosing while statement, the break must be
                 // nested within that while statement
                 if self.in_while.is_none() {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, position, "Break statement is not nested under a while loop")
                     );
+                }
                 self.in_while.unwrap()
+            }
         };
         // We have a valid target for the break statement. But we need to
         // make sure we will not break out of a synchronous block
+        {
             let target_while = &ctx.heap[target];
             if target_while.in_sync != self.in_sync {
                 // Break is nested under while statement, so can only escape a
                 // sync block if the sync is nested inside the while statement.
                 debug_assert!(self.in_sync.is_some());
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, position, "Break may not escape the surrounding synchronous block")
                         .with_postfixed_info(&ctx.module.source, target_while.position, "The break escapes out of this loop")
                         .with_postfixed_info(&ctx.module.source, sync_stmt.position, "And would therefore escape this synchronous block")
                 );
+            }
+        }
         Ok(target)

0 comments (0 inline, 0 general)