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

Changeset - 1f0d50fa632f

Parent rev.

Child rev.

[Not reviewed]

0 5 0

MH - 4 years ago 2021-03-07 15:51:23
henger@cwi.nl

first pass on arena/index refactoring

5 files changed with 183 insertions and 181 deletions:

src/protocol/ast.rs

112

110

src/protocol/ast_printer.rs

src/protocol/parser/symbol_table.rs

src/protocol/parser/type_table.rs

src/protocol/parser/visitor_linker.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -5,18 +5,22 @@ 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::*;
 /// Helper macro that defines a type alias for a AST element ID. In this case
 /// only used to alias the `Id<T>` types.
 macro_rules! define_aliased_ast_id {
     ($name:ident, $parent:ty) => {
         type $name = $parent;
+        pub type $name = $parent;
+    }
+}
 /// Helper macro that defines a subtype for a particular variant of an AST
 /// element ID.
 macro_rules! define_new_ast_id {
     ($name:ident, $parent:ty) => {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
         pub struct $name (pub(crate) $parent);
         impl $name {
@@ @@ -74,13 +78,13 @@ define_new_ast_id!(SlicingExpressionId, ExpressionId); @@
 define_new_ast_id!(SelectExpressionId, ExpressionId);
 define_new_ast_id!(ArrayExpressionId, ExpressionId);
 define_new_ast_id!(ConstantExpressionId, ExpressionId);
 define_new_ast_id!(CallExpressionId, ExpressionId);
 define_new_ast_id!(VariableExpressionId, ExpressionId);
-define_new_ast_id!(DeclarationId, ExpressionId); // TODO: @cleanup
+define_aliased_ast_id!(DeclarationId, Id<Declaration>); // TODO: @cleanup
 define_new_ast_id!(DefinedDeclarationId, DeclarationId);
 define_new_ast_id!(ImportedDeclarationId, DeclarationId);
 // TODO: @cleanup - pub qualifiers can be removed once done
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct Heap {
@@ @@ -329,520 +333,518 @@ impl Heap { @@
+        )
+    }
     pub fn alloc_synchronous_statement(
         &mut self,
         f: impl FnOnce(SynchronousStatementId) -> SynchronousStatement,
     ) -> SynchronousStatementId {
         SynchronousStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::Synchronous(f(SynchronousStatementId(StatementId(id))))
         })))
         SynchronousStatementId(self.statements.alloc_with_id(|id| {
             Statement::Synchronous(f(SynchronousStatementId(id)))
         }))
+    }
     pub fn alloc_end_synchronous_statement(
         &mut self,
         f: impl FnOnce(EndSynchronousStatementId) -> EndSynchronousStatement,
     ) -> EndSynchronousStatementId {
         EndSynchronousStatementId(StatementId(self.statements.alloc_with_id(|id| {
             Statement::EndSynchronous(f(EndSynchronousStatementId(StatementId(id))))
         })))
         EndSynchronousStatementId(self.statements.alloc_with_id(|id| {
             Statement::EndSynchronous(f(EndSynchronousStatementId(id)))
         }))
+    }
     pub fn alloc_return_statement(
         &mut self,
         f: impl FnOnce(ReturnStatementId) -> ReturnStatement,
     ) -> ReturnStatementId {
-        ReturnStatementId(StatementId(
         ReturnStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Return(f(ReturnStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Return(f(ReturnStatementId(id)))),
+        )
+    }
     pub fn alloc_assert_statement(
         &mut self,
         f: impl FnOnce(AssertStatementId) -> AssertStatement,
     ) -> AssertStatementId {
-        AssertStatementId(StatementId(
         AssertStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Assert(f(AssertStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Assert(f(AssertStatementId(id)))),
+        )
+    }
     pub fn alloc_goto_statement(
         &mut self,
         f: impl FnOnce(GotoStatementId) -> GotoStatement,
     ) -> GotoStatementId {
-        GotoStatementId(StatementId(
         GotoStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Goto(f(GotoStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Goto(f(GotoStatementId(id)))),
+        )
+    }
     pub fn alloc_new_statement(
         &mut self,
         f: impl FnOnce(NewStatementId) -> NewStatement,
     ) -> NewStatementId {
         NewStatementId(StatementId(
             self.statements.alloc_with_id(|id| Statement::New(f(NewStatementId(StatementId(id))))),
         ))
         NewStatementId(
             self.statements.alloc_with_id(|id| Statement::New(f(NewStatementId(id)))),
+        )
+    }
     pub fn alloc_put_statement(
         &mut self,
         f: impl FnOnce(PutStatementId) -> PutStatement,
     ) -> PutStatementId {
         PutStatementId(StatementId(
             self.statements.alloc_with_id(|id| Statement::Put(f(PutStatementId(StatementId(id))))),
         ))
         PutStatementId(
             self.statements.alloc_with_id(|id| Statement::Put(f(PutStatementId(id)))),
+        )
+    }
     pub fn alloc_labeled_statement(
         &mut self,
         f: impl FnOnce(LabeledStatementId) -> LabeledStatement,
     ) -> LabeledStatementId {
-        LabeledStatementId(StatementId(
         LabeledStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Labeled(f(LabeledStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Labeled(f(LabeledStatementId(id)))),
+        )
+    }
     pub fn alloc_expression_statement(
         &mut self,
         f: impl FnOnce(ExpressionStatementId) -> ExpressionStatement,
     ) -> ExpressionStatementId {
-        ExpressionStatementId(StatementId(
         ExpressionStatementId(
             self.statements.alloc_with_id(|id| {
-                Statement::Expression(f(ExpressionStatementId(StatementId(id))))
                 Statement::Expression(f(ExpressionStatementId(id)))
             }),
-        ))
+        )
+    }
     pub fn alloc_struct_definition(&mut self, f: impl FnOnce(StructId) -> StructDefinition) -> StructId {
         StructId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Struct(f(StructId(DefinitionId(id))))
         })))
         StructId(self.definitions.alloc_with_id(|id| {
             Definition::Struct(f(StructId(id)))
         }))
+    }
     pub fn alloc_enum_definition(&mut self, f: impl FnOnce(EnumId) -> EnumDefinition) -> EnumId {
         EnumId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Enum(f(EnumId(DefinitionId(id))))
         })))
         EnumId(self.definitions.alloc_with_id(|id| {
             Definition::Enum(f(EnumId(id)))
         }))
+    }
     pub fn alloc_component(&mut self, f: impl FnOnce(ComponentId) -> Component) -> ComponentId {
         ComponentId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Component(f(ComponentId(
                 DefinitionId(id),
             )))
         })))
         ComponentId(self.definitions.alloc_with_id(|id| {
             Definition::Component(f(ComponentId(id)))
         }))
+    }
     pub fn alloc_function(&mut self, f: impl FnOnce(FunctionId) -> Function) -> FunctionId {
-        FunctionId(DefinitionId(
         FunctionId(
             self.definitions
                 .alloc_with_id(|id| Definition::Function(f(FunctionId(DefinitionId(id))))),
         ))
                 .alloc_with_id(|id| Definition::Function(f(FunctionId(id)))),
+        )
+    }
     pub fn alloc_pragma(&mut self, f: impl FnOnce(PragmaId) -> Pragma) -> PragmaId {
-        PragmaId(self.pragmas.alloc_with_id(|id| f(PragmaId(id))))
         self.pragmas.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_import(&mut self, f: impl FnOnce(ImportId) -> Import) -> ImportId {
-        ImportId(self.imports.alloc_with_id(|id| f(ImportId(id))))
         self.imports.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_protocol_description(&mut self, f: impl FnOnce(RootId) -> Root) -> RootId {
-        RootId(self.protocol_descriptions.alloc_with_id(|id| f(RootId(id))))
         self.protocol_descriptions.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_imported_declaration(
         &mut self,
         f: impl FnOnce(ImportedDeclarationId) -> ImportedDeclaration,
     ) -> ImportedDeclarationId {
         ImportedDeclarationId(DeclarationId(self.declarations.alloc_with_id(|id| {
             Declaration::Imported(f(ImportedDeclarationId(DeclarationId(id))))
         })))
         ImportedDeclarationId(self.declarations.alloc_with_id(|id| {
             Declaration::Imported(f(ImportedDeclarationId(id)))
         }))
+    }
     pub fn alloc_defined_declaration(
         &mut self,
         f: impl FnOnce(DefinedDeclarationId) -> DefinedDeclaration,
     ) -> DefinedDeclarationId {
-        DefinedDeclarationId(DeclarationId(
         DefinedDeclarationId(
             self.declarations.alloc_with_id(|id| {
-                Declaration::Defined(f(DefinedDeclarationId(DeclarationId(id))))
                 Declaration::Defined(f(DefinedDeclarationId(id)))
             }),
-        ))
+        )
+    }
+}
 impl Index<RootId> for Heap {
     type Output = Root;
     fn index(&self, index: RootId) -> &Self::Output {
-        &self.protocol_descriptions[index.0]
         &self.protocol_descriptions[index]
+    }
+}
 impl IndexMut<RootId> for Heap {
     fn index_mut(&mut self, index: RootId) -> &mut Self::Output {
-        &mut self.protocol_descriptions[index.0]
         &mut self.protocol_descriptions[index]
+    }
+}
 impl Index<PragmaId> for Heap {
     type Output = Pragma;
     fn index(&self, index: PragmaId) -> &Self::Output {
-        &self.pragmas[index.0]
         &self.pragmas[index]
+    }
+}
 impl Index<ImportId> for Heap {
     type Output = Import;
     fn index(&self, index: ImportId) -> &Self::Output {
-        &self.imports[index.0]
         &self.imports[index]
+    }
+}
 impl IndexMut<ImportId> for Heap {
     fn index_mut(&mut self, index: ImportId) -> &mut Self::Output {
-        &mut self.imports[index.0]
         &mut self.imports[index]
+    }
+}
 impl Index<TypeAnnotationId> for Heap {
     type Output = TypeAnnotation;
     fn index(&self, index: TypeAnnotationId) -> &Self::Output {
-        &self.type_annotations[index.0]
         &self.type_annotations[index]
+    }
+}
 impl Index<VariableId> for Heap {
     type Output = Variable;
     fn index(&self, index: VariableId) -> &Self::Output {
-        &self.variables[index.0]
         &self.variables[index]
+    }
+}
 impl Index<ParameterId> for Heap {
     type Output = Parameter;
     fn index(&self, index: ParameterId) -> &Self::Output {
-        &self.variables[(index.0).0].as_parameter()
         &self.variables[index.0].as_parameter()
+    }
+}
 impl Index<LocalId> for Heap {
     type Output = Local;
     fn index(&self, index: LocalId) -> &Self::Output {
-        &self.variables[(index.0).0].as_local()
         &self.variables[index.0].as_local()
+    }
+}
 impl IndexMut<LocalId> for Heap {
     fn index_mut(&mut self, index: LocalId) -> &mut Self::Output {
-        self.variables[index.0.0].as_local_mut()
         self.variables[index.0].as_local_mut()
+    }
+}
 impl Index<DefinitionId> for Heap {
     type Output = Definition;
     fn index(&self, index: DefinitionId) -> &Self::Output {
-        &self.definitions[index.0]
         &self.definitions[index]
+    }
+}
 impl Index<ComponentId> for Heap {
     type Output = Component;
     fn index(&self, index: ComponentId) -> &Self::Output {
-        &self.definitions[(index.0).0].as_component()
         &self.definitions[index.0].as_component()
+    }
+}
 impl Index<FunctionId> for Heap {
     type Output = Function;
     fn index(&self, index: FunctionId) -> &Self::Output {
-        &self.definitions[(index.0).0].as_function()
         &self.definitions[index.0].as_function()
+    }
+}
 impl Index<StatementId> for Heap {
     type Output = Statement;
     fn index(&self, index: StatementId) -> &Self::Output {
-        &self.statements[index.0]
         &self.statements[index]
+    }
+}
 impl IndexMut<StatementId> for Heap {
     fn index_mut(&mut self, index: StatementId) -> &mut Self::Output {
-        &mut self.statements[index.0]
         &mut self.statements[index]
+    }
+}
 impl Index<BlockStatementId> for Heap {
     type Output = BlockStatement;
     fn index(&self, index: BlockStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_block()
         &self.statements[index.0].as_block()
+    }
+}
 impl IndexMut<BlockStatementId> for Heap {
     fn index_mut(&mut self, index: BlockStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_block_mut()
         (&mut self.statements[index.0]).as_block_mut()
+    }
+}
 impl Index<LocalStatementId> for Heap {
     type Output = LocalStatement;
     fn index(&self, index: LocalStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_local()
         &self.statements[index.0].as_local()
+    }
+}
 impl Index<MemoryStatementId> for Heap {
     type Output = MemoryStatement;
     fn index(&self, index: MemoryStatementId) -> &Self::Output {
-        &self.statements[((index.0).0).0].as_memory()
         &self.statements[index.0.0].as_memory()
+    }
+}
 impl Index<ChannelStatementId> for Heap {
     type Output = ChannelStatement;
     fn index(&self, index: ChannelStatementId) -> &Self::Output {
-        &self.statements[((index.0).0).0].as_channel()
         &self.statements[index.0.0].as_channel()
+    }
+}
 impl Index<SkipStatementId> for Heap {
     type Output = SkipStatement;
     fn index(&self, index: SkipStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_skip()
         &self.statements[index.0].as_skip()
+    }
+}
 impl Index<LabeledStatementId> for Heap {
     type Output = LabeledStatement;
     fn index(&self, index: LabeledStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_labeled()
         &self.statements[index.0].as_labeled()
+    }
+}
 impl IndexMut<LabeledStatementId> for Heap {
     fn index_mut(&mut self, index: LabeledStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_labeled_mut()
         (&mut self.statements[index.0]).as_labeled_mut()
+    }
+}
 impl Index<IfStatementId> for Heap {
     type Output = IfStatement;
     fn index(&self, index: IfStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_if()
         &self.statements[index.0].as_if()
+    }
+}
 impl IndexMut<IfStatementId> for Heap {
     fn index_mut(&mut self, index: IfStatementId) -> &mut Self::Output {
-        self.statements[(index.0).0].as_if_mut()
         self.statements[index.0].as_if_mut()
+    }
+}
 impl Index<EndIfStatementId> for Heap {
     type Output = EndIfStatement;
     fn index(&self, index: EndIfStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_end_if()
         &self.statements[index.0].as_end_if()
+    }
+}
 impl Index<WhileStatementId> for Heap {
     type Output = WhileStatement;
     fn index(&self, index: WhileStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_while()
         &self.statements[index.0].as_while()
+    }
+}
 impl IndexMut<WhileStatementId> for Heap {
     fn index_mut(&mut self, index: WhileStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_while_mut()
         (&mut self.statements[index.0]).as_while_mut()
+    }
+}
 impl Index<BreakStatementId> for Heap {
     type Output = BreakStatement;
     fn index(&self, index: BreakStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_break()
         &self.statements[index.0].as_break()
+    }
+}
 impl IndexMut<BreakStatementId> for Heap {
     fn index_mut(&mut self, index: BreakStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_break_mut()
         (&mut self.statements[index.0]).as_break_mut()
+    }
+}
 impl Index<ContinueStatementId> for Heap {
     type Output = ContinueStatement;
     fn index(&self, index: ContinueStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_continue()
         &self.statements[index.0].as_continue()
+    }
+}
 impl IndexMut<ContinueStatementId> for Heap {
     fn index_mut(&mut self, index: ContinueStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_continue_mut()
         (&mut self.statements[index.0]).as_continue_mut()
+    }
+}
 impl Index<SynchronousStatementId> for Heap {
     type Output = SynchronousStatement;
     fn index(&self, index: SynchronousStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_synchronous()
         &self.statements[index.0].as_synchronous()
+    }
+}
 impl IndexMut<SynchronousStatementId> for Heap {
     fn index_mut(&mut self, index: SynchronousStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_synchronous_mut()
         (&mut self.statements[index.0]).as_synchronous_mut()
+    }
+}
 impl Index<EndSynchronousStatementId> for Heap {
     type Output = EndSynchronousStatement;
     fn index(&self, index: EndSynchronousStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_end_synchronous()
         &self.statements[index.0].as_end_synchronous()
+    }
+}
 impl Index<ReturnStatementId> for Heap {
     type Output = ReturnStatement;
     fn index(&self, index: ReturnStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_return()
         &self.statements[index.0].as_return()
+    }
+}
 impl Index<AssertStatementId> for Heap {
     type Output = AssertStatement;
     fn index(&self, index: AssertStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_assert()
         &self.statements[index.0].as_assert()
+    }
+}
 impl Index<GotoStatementId> for Heap {
     type Output = GotoStatement;
     fn index(&self, index: GotoStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_goto()
         &self.statements[index.0].as_goto()
+    }
+}
 impl IndexMut<GotoStatementId> for Heap {
     fn index_mut(&mut self, index: GotoStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_goto_mut()
         (&mut self.statements[index.0]).as_goto_mut()
+    }
+}
 impl Index<NewStatementId> for Heap {
     type Output = NewStatement;
     fn index(&self, index: NewStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_new()
         &self.statements[index.0].as_new()
+    }
+}
 impl Index<PutStatementId> for Heap {
     type Output = PutStatement;
     fn index(&self, index: PutStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_put()
         &self.statements[index.0].as_put()
+    }
+}
 impl Index<ExpressionStatementId> for Heap {
     type Output = ExpressionStatement;
     fn index(&self, index: ExpressionStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_expression()
         &self.statements[index.0].as_expression()
+    }
+}
 impl Index<ExpressionId> for Heap {
     type Output = Expression;
     fn index(&self, index: ExpressionId) -> &Self::Output {
-        &self.expressions[index.0]
         &self.expressions[index]
+    }
+}
 impl Index<AssignmentExpressionId> for Heap {
     type Output = AssignmentExpression;
     fn index(&self, index: AssignmentExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_assignment()
         &self.expressions[index.0].as_assignment()
+    }
+}
 impl Index<ConditionalExpressionId> for Heap {
     type Output = ConditionalExpression;
     fn index(&self, index: ConditionalExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_conditional()
         &self.expressions[index.0].as_conditional()
+    }
+}
 impl Index<BinaryExpressionId> for Heap {
     type Output = BinaryExpression;
     fn index(&self, index: BinaryExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_binary()
         &self.expressions[index.0].as_binary()
+    }
+}
 impl Index<UnaryExpressionId> for Heap {
     type Output = UnaryExpression;
     fn index(&self, index: UnaryExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_unary()
         &self.expressions[index.0].as_unary()
+    }
+}
 impl Index<IndexingExpressionId> for Heap {
     type Output = IndexingExpression;
     fn index(&self, index: IndexingExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_indexing()
         &self.expressions[index.0].as_indexing()
+    }
+}
 impl Index<SlicingExpressionId> for Heap {
     type Output = SlicingExpression;
     fn index(&self, index: SlicingExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_slicing()
         &self.expressions[index.0].as_slicing()
+    }
+}
 impl Index<SelectExpressionId> for Heap {
     type Output = SelectExpression;
     fn index(&self, index: SelectExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_select()
         &self.expressions[index.0].as_select()
+    }
+}
 impl Index<ArrayExpressionId> for Heap {
     type Output = ArrayExpression;
     fn index(&self, index: ArrayExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_array()
         &self.expressions[index.0].as_array()
+    }
+}
 impl Index<ConstantExpressionId> for Heap {
     type Output = ConstantExpression;
     fn index(&self, index: ConstantExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_constant()
         &self.expressions[index.0].as_constant()
+    }
+}
 impl Index<CallExpressionId> for Heap {
     type Output = CallExpression;
     fn index(&self, index: CallExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_call()
         &self.expressions[index.0].as_call()
+    }
+}
 impl IndexMut<CallExpressionId> for Heap {
     fn index_mut(&mut self, index: CallExpressionId) -> &mut Self::Output {
-        (&mut self.expressions[(index.0).0]).as_call_mut()
         (&mut self.expressions[index.0]).as_call_mut()
+    }
+}
 impl Index<VariableExpressionId> for Heap {
     type Output = VariableExpression;
     fn index(&self, index: VariableExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_variable()
         &self.expressions[index.0].as_variable()
+    }
+}
 impl IndexMut<VariableExpressionId> for Heap {
     fn index_mut(&mut self, index: VariableExpressionId) -> &mut Self::Output {
-        (&mut self.expressions[(index.0).0]).as_variable_mut()
         (&mut self.expressions[index.0]).as_variable_mut()
+    }
+}
 impl Index<DeclarationId> for Heap {
     type Output = Declaration;
     fn index(&self, index: DeclarationId) -> &Self::Output {
-        &self.declarations[index.0]
         &self.declarations[index]
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Root {
     pub this: RootId,
@@ @@ -1164,13 +1166,13 @@ impl Display for Type { @@
             PrimitiveType::Symbolic(data) => {
                 // Type data is in ASCII range.
                 if let Some(id) = &data.definition {
                     write!(
                         f, "Symbolic({}, id: {})",
                         String::from_utf8_lossy(&data.identifier.value),
-                        id.0.index
                         id.index
                     )?;
                 } else {
                     write!(
                         f, "Symbolic({}, id: Unresolved)",
                         String::from_utf8_lossy(&data.identifier.value)
                     )?;

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -188,13 +188,13 @@ impl ASTWriter { @@
     //--------------------------------------------------------------------------
     // Top-level module writing
     //--------------------------------------------------------------------------
     fn write_module(&mut self, heap: &Heap, root_id: RootId) {
-        self.kv(0).with_id(PREFIX_ROOT_ID, root_id.0.index)
         self.kv(0).with_id(PREFIX_ROOT_ID, root_id.index)
             .with_s_key("Module");
         let root = &heap[root_id];
         self.kv(1).with_s_key("Pragmas");
         for pragma_id in &root.pragmas {
             self.write_pragma(heap, *pragma_id, 2);
@@ @@ -211,56 +211,56 @@ impl ASTWriter { @@
+        }
+    }
     fn write_pragma(&mut self, heap: &Heap, pragma_id: PragmaId, indent: usize) {
         match &heap[pragma_id] {
             Pragma::Version(pragma) => {
-                self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.0.index)
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaVersion")
                     .with_disp_val(&pragma.version);
             },
             Pragma::Module(pragma) => {
-                self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.0.index)
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaModule")
                     .with_ascii_val(&pragma.value);
+            }
+        }
+    }
     fn write_import(&mut self, heap: &Heap, import_id: ImportId, indent: usize) {
         let import = &heap[import_id];
         let indent2 = indent + 1;
         match import {
             Import::Module(import) => {
-                self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.0.index)
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportModule");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);
                 self.kv(indent2).with_s_key("Alias").with_ascii_val(&import.alias);
                 self.kv(indent2).with_s_key("Target")
-                    .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
             },
             Import::Symbols(import) => {
-                self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.0.index)
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportSymbol");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);
                 self.kv(indent2).with_s_key("Target")
-                    .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Symbols");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for symbol in &import.symbols {
                     self.kv(indent3).with_s_key("AliasedSymbol");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&symbol.name);
                     self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias);
                     self.kv(indent4).with_s_key("Definition")
-                        .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.0.index));
                         .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));
+                }
+            }
+        }
+    }
     //--------------------------------------------------------------------------
@@ @@ -274,22 +274,22 @@ impl ASTWriter { @@
         match &heap[def_id] {
             Definition::Struct(_) => todo!("implement Definition::Struct"),
             Definition::Enum(_) => todo!("implement Definition::Enum"),
             Definition::Function(_) => todo!("implement Definition::Function"),
             Definition::Component(def) => {
-                self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)
                     .with_s_key("DefinitionComponent");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);
                 self.kv(indent2).with_s_key("Parameters");
                 for param_id in &def.parameters {
                     let param = &heap[*param_id];
-                    self.kv(indent3).with_id(PREFIX_PARAMETER_ID, param_id.0.0.index)
                     self.kv(indent3).with_id(PREFIX_PARAMETER_ID, param_id.0.index)
                         .with_s_key("Parameter");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&param.identifier.value);
                     self.kv(indent4).with_s_key("Type").with_custom_val(|w| write_type(w, &heap[param.type_annotation]));
+                }
@@ @@ -303,243 +303,243 @@ impl ASTWriter { @@
         let stmt = &heap[stmt_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match stmt {
             Statement::Block(stmt) => {
-                self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Block");
                 for stmt_id in &stmt.statements {
                     self.write_stmt(heap, *stmt_id, indent2);
+                }
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Channel(stmt) => {
-                        self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.0.index)
                         self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalChannel");
                         self.kv(indent2).with_s_key("From");
                         self.write_local(heap, stmt.from, indent3);
                         self.kv(indent2).with_s_key("To");
                         self.write_local(heap, stmt.to, indent3);
                         self.kv(indent2).with_s_key("Next")
-                            .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                             .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
                     },
                     LocalStatement::Memory(stmt) => {
-                        self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.0.index)
                         self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalMemory");
                         self.kv(indent2).with_s_key("Variable");
                         self.write_local(heap, stmt.variable, indent3);
                         self.kv(indent2).with_s_key("initial");
                         self.write_expr(heap, stmt.initial, indent3);
                         self.kv(indent2).with_s_key("Next")
-                            .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                             .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
+                    }
+                }
             },
             Statement::Skip(stmt) => {
-                self.kv(indent).with_id(PREFIX_SKIP_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_SKIP_STMT_ID, stmt.this.0.index)
                     .with_s_key("Skip");
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Labeled(stmt) => {
-                self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.index)
                     .with_s_key("Labeled");
                 self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
                 self.kv(indent2).with_s_key("Statement");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::If(stmt) => {
-                self.kv(indent).with_id(PREFIX_IF_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_IF_STMT_ID, stmt.this.0.index)
                     .with_s_key("If");
                 self.kv(indent2).with_s_key("EndIf")
-                    .with_opt_disp_val(stmt.end_if.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.end_if.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("TrueBody");
                 self.write_stmt(heap, stmt.true_body, indent3);
                 self.kv(indent2).with_s_key("FalseBody");
                 self.write_stmt(heap, stmt.false_body, indent3);
             },
             Statement::EndIf(stmt) => {
-                self.kv(indent).with_id(PREFIX_ENDIF_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_ENDIF_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndIf");
-                self.kv(indent2).with_s_key("StartIf").with_disp_val(&stmt.start_if.0.0.index);
                 self.kv(indent2).with_s_key("StartIf").with_disp_val(&stmt.start_if.0.index);
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::While(stmt) => {
-                self.kv(indent).with_id(PREFIX_WHILE_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_WHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("While");
                 self.kv(indent2).with_s_key("EndWhile")
-                    .with_opt_disp_val(stmt.end_while.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.end_while.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("InSync")
-                    .with_opt_disp_val(stmt.in_sync.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.in_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndWhile(stmt) => {
-                self.kv(indent).with_id(PREFIX_ENDWHILE_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_ENDWHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndWhile");
-                self.kv(indent2).with_s_key("StartWhile").with_disp_val(&stmt.start_while.0.0.index);
                 self.kv(indent2).with_s_key("StartWhile").with_disp_val(&stmt.start_while.0.index);
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Break(stmt) => {
-                self.kv(indent).with_id(PREFIX_BREAK_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_BREAK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Break");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
                 self.kv(indent2).with_s_key("Target")
-                    .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Continue(stmt) => {
-                self.kv(indent).with_id(PREFIX_CONTINUE_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_CONTINUE_STMT_ID, stmt.this.0.index)
                     .with_s_key("Continue");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
                 self.kv(indent2).with_s_key("Target")
-                    .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Synchronous(stmt) => {
-                self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("Synchronous");
                 self.kv(indent2).with_s_key("EndSync")
-                    .with_opt_disp_val(stmt.end_sync.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.end_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndSynchronous(stmt) => {
-                self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSynchronous");
-                self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.0.index);
                 self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.index);
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Return(stmt) => {
-                self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
             },
             Statement::Assert(stmt) => {
-                self.kv(indent).with_id(PREFIX_ASSERT_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_ASSERT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Assert");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Goto(stmt) => {
-                self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
                 self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
                 self.kv(indent2).with_s_key("Target")
-                    .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::New(stmt) => {
-                self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.index)
                     .with_s_key("New");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression.upcast(), indent3);
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Put(stmt) => {
-                self.kv(indent).with_id(PREFIX_PUT_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_PUT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Put");
                 self.kv(indent2).with_s_key("Port");
                 self.write_expr(heap, stmt.port, indent3);
                 self.kv(indent2).with_s_key("Message");
                 self.write_expr(heap, stmt.message, indent3);
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Expression(stmt) => {
-                self.kv(indent).with_id(PREFIX_EXPR_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_EXPR_STMT_ID, stmt.this.0.index)
                     .with_s_key("ExpressionStatement");
                 self.write_expr(heap, stmt.expression, indent2);
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
+            }
+        }
+    }
     fn write_expr(&mut self, heap: &Heap, expr_id: ExpressionId, indent: usize) {
         let expr = &heap[expr_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match expr {
             Expression::Assignment(expr) => {
-                self.kv(indent).with_id(PREFIX_ASSIGNMENT_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_ASSIGNMENT_EXPR_ID, expr.this.0.index)
                     .with_s_key("AssignmentExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
             },
             Expression::Conditional(expr) => {
-                self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConditionalExpr");
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, expr.test, indent3);
                 self.kv(indent2).with_s_key("TrueExpression");
                 self.write_expr(heap, expr.true_expression, indent3);
                 self.kv(indent2).with_s_key("FalseExpression");
                 self.write_expr(heap, expr.false_expression, indent3);
             },
             Expression::Binary(expr) => {
-                self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BinaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
             },
             Expression::Unary(expr) => {
-                self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("UnaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Argument");
                 self.write_expr(heap, expr.expression, indent3);
             },
             Expression::Indexing(expr) => {
-                self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.index)
                     .with_s_key("IndexingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Index");
                 self.write_expr(heap, expr.index, indent3);
             },
             Expression::Slicing(expr) => {
-                self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.index)
                     .with_s_key("SlicingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("FromIndex");
                 self.write_expr(heap, expr.from_index, indent3);
                 self.kv(indent2).with_s_key("ToIndex");
                 self.write_expr(heap, expr.to_index, indent3);
             },
             Expression::Select(expr) => {
-                self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.index)
                     .with_s_key("SelectExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 match &expr.field {
                     Field::Length => {
@@ @@ -548,71 +548,71 @@ impl ASTWriter { @@
                     Field::Symbolic(field) => {
                         self.kv(indent2).with_s_key("Field").with_ascii_val(&field.value);
+                    }
+                }
             },
             Expression::Array(expr) => {
-                self.kv(indent).with_id(PREFIX_ARRAY_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_ARRAY_EXPR_ID, expr.this.0.index)
                     .with_s_key("ArrayExpr");
                 self.kv(indent2).with_s_key("Elements");
                 for expr_id in &expr.elements {
                     self.write_expr(heap, *expr_id, indent3);
+                }
             },
             Expression::Constant(expr) => {
-                self.kv(indent).with_id(PREFIX_CONST_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_CONST_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConstantExpr");
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Constant::Null => { val.with_s_val("null"); },
                     Constant::True => { val.with_s_val("true"); },
                     Constant::False => { val.with_s_val("false"); },
                     Constant::Character(char) => { val.with_ascii_val(char); },
                     Constant::Integer(int) => { val.with_disp_val(int); },
+                }
             },
             Expression::Call(expr) => {
-                self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 // Method
                 let method = self.kv(indent2).with_s_key("Method");
                 match &expr.method {
                     Method::Get => { method.with_s_val("get"); },
                     Method::Fires => { method.with_s_val("fires"); },
                     Method::Create => { method.with_s_val("create"); },
                     Method::Symbolic(symbolic) => {
                         method.with_s_val("symbolic");
                         self.kv(indent3).with_s_key("Name").with_ascii_val(&symbolic.identifier.value);
                         self.kv(indent3).with_s_key("Definition")
-                            .with_opt_disp_val(symbolic.definition.as_ref().map(|v| &v.0.index));
                             .with_opt_disp_val(symbolic.definition.as_ref().map(|v| &v.index));
+                    }
+                }
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
             },
             Expression::Variable(expr) => {
-                self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&expr.identifier.value);
                 self.kv(indent2).with_s_key("Definition")
-                    .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
+            }
+        }
+    }
     fn write_local(&mut self, heap: &Heap, local_id: LocalId, indent: usize) {
         let local = &heap[local_id];
         let indent2 = indent + 1;
-        self.kv(indent).with_id(PREFIX_LOCAL_ID, local_id.0.0.index)
         self.kv(indent).with_id(PREFIX_LOCAL_ID, local_id.0.index)
             .with_s_key("Local");
         self.kv(indent2).with_s_key("Name").with_ascii_val(&local.identifier.value);
         self.kv(indent2).with_s_key("Type")
             .with_custom_val(|w| write_type(w, &heap[local.type_annotation]));
+    }
@@ @@ -648,13 +648,13 @@ fn write_type(target: &mut String, t: &TypeAnnotation) { @@
         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_option(&mut temp, symbolic.definition.map(|v| v.index));
             write!(target, "Symbolic(name: {}, target: {})", String::from_utf8_lossy(&symbolic.identifier.value), &temp)
+        }
     };
     if t.the_type.array {
         target.push_str("[]");

src/protocol/parser/symbol_table.rs

➞

Show inline comments

@@ @@ -74,13 +74,13 @@ pub(crate) struct SymbolTable { @@
 impl SymbolTable {
     pub(crate) fn new(heap: &Heap, modules: &[LexedModule]) -> Result<Self, ParseError2> {
         // Sanity check
         if cfg!(debug_assertions) {
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(
-                    index, module.root_id.0.index as usize,
                     index, module.root_id.index as usize,
                     "module RootId does not correspond to LexedModule index"
+                )
+            }
+        }
         // Preparation: create a lookup from module name to root id. This does
@@ @@ -202,13 +202,13 @@ impl SymbolTable { @@
                                     return Err(
                                         ParseError2::new_error(
                                             &module.source, import.position,
                                             &format!("Imported symbol '{}' is already defined", String::from_utf8_lossy(&identifier.value))
+                                        )
                                         .with_postfixed_info(
-                                            &modules[target_root_id.0.index as usize].source,
                                             &modules[target_root_id.index as usize].source,
                                             definition.position(),
                                             "The imported symbol is defined here"
+                                        )
                                         .with_postfixed_info(
                                             &module.source, previous_position, "And is previously defined here"
+                                        )

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -128,13 +128,13 @@ enum LookupResult { @@
 impl TypeTable {
     pub(crate) fn new(
         symbols: &SymbolTable, heap: &Heap, modules: &[LexedModule]
     ) -> Result<TypeTable, ParseError2> {
         if cfg!(debug_assertions) {
             for (index, module) in modules.iter().enumerate() {
-                debug_assert_eq!(index, module.root_id.0.index as usize)
                 debug_assert_eq!(index, module.root_id.index as usize)
+            }
+        }
         // Estimate total number of definitions we will encounter
         let num_definitions = heap.definitions.len();
         let mut table = TypeTable{
@@ @@ -185,13 +185,13 @@ impl TypeTable { @@
                             break;
+                        }
+                    }
                     if is_cyclic {
                         let mut error = ParseError2::new_error(
-                            &all_modules[new_root_id.0.index as usize].source,
                             &all_modules[new_root_id.index as usize].source,
                             heap[new_definition_id].position(),
                             "Evaluating this definition results in a a cyclic dependency"
                         );
                         for (index, breadcrumb) in breadcrumbs.iter().enumerate() {
                             match breadcrumb {
                                 Breadcrumb::Linear((root_index, definition_index)) => {
@@ @@ -202,13 +202,13 @@ impl TypeTable { @@
                                         "The cycle started with this definition"
+                                    )
                                 },
                                 Breadcrumb::Jumping((root_id, definition_id)) => {
                                     debug_assert!(index > 0);
                                     error = error.with_postfixed_info(
-                                        &all_modules[root_id.0.index as usize].source,
                                         &all_modules[root_id.index as usize].source,
                                         heap[*definition_id].position(),
                                         "Which depends on this definition"
+                                    )
+                                }
+                            }
+                        }
@@ @@ -248,13 +248,13 @@ impl TypeTable { @@
                         let module = &modules[*module_index];
                         let root = &heap[module.root_id];
                         let definition_id = root.definitions[*definition_index];
                         (module, definition_id)
                     },
                     Breadcrumb::Jumping((root_id, definition_id)) => {
-                        let module = &modules[root_id.0.index as usize];
                         let module = &modules[root_id.index as usize];
                         debug_assert_eq!(module.root_id, *root_id);
                         (module, *definition_id)
+                    }
                 };
                 let definition = &heap[definition_id];

src/protocol/parser/visitor_linker.rs

➞

Show inline comments

@@ @@ -695,13 +695,13 @@ impl ValidityAndLinkerVisitor { @@
         // Set parent scope and relative position in the parent scope. Remember
         // these values to set them back to the old values when we're done with
         // the traversal of the block's statements.
         let body = &mut ctx.heap[id];
         body.parent_scope = self.cur_scope.clone();
-        println!("DEBUG: Assigning relative {} to block {}", self.relative_pos_in_block, id.0.0.index);
         println!("DEBUG: Assigning relative {} to block {}", self.relative_pos_in_block, id.0.index);
         body.relative_pos_in_parent = self.relative_pos_in_block;
         let old_scope = self.cur_scope.replace(match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         });

0 comments (0 inline, 0 general)