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

Changeset - 47afdfbed351

Parent rev.

Child rev.

[Not reviewed]

0 4 0

Christopher Esterhuyse - 5 years ago 2020-06-18 18:10:35
christopher.esterhuyse@gmail.com

protocols are now serializable

4 files changed with 116 insertions and 113 deletions:

src/protocol/arena.rs

src/protocol/ast.rs

112

111

src/protocol/inputsource.rs

src/protocol/mod.rs

0 comments (0 inline, 0 general)

src/protocol/arena.rs

➞

Show inline comments

@@ @@ -21,12 +21,13 @@ impl<T> Eq for Id<T> {} @@
 impl<T> Hash for Id<T> {
     fn hash<H: std::hash::Hasher>(&self, h: &mut H) {
         self.index.hash(h);
+    }
+}
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct Arena<T> {
     store: Vec<T>,
+}
 impl<T> Arena<T> {
     pub fn new() -> Self {
         Self { store: vec![] }

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -3,411 +3,412 @@ use std::fmt::{Debug, Display, Formatter}; @@
 use std::ops::{Index, IndexMut};
 use super::arena::{Arena, Id};
 use crate::protocol::inputsource::*;
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct RootId(Id<Root>);
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct PragmaId(Id<Pragma>);
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ImportId(Id<Import>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 pub struct IdentifierId(Id<Identifier>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 pub struct SourceIdentifierId(IdentifierId);
 impl SourceIdentifierId {
     pub fn upcast(self) -> IdentifierId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 pub struct ExternalIdentifierId(IdentifierId);
 impl ExternalIdentifierId {
     pub fn upcast(self) -> IdentifierId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct TypeAnnotationId(Id<TypeAnnotation>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct VariableId(Id<Variable>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 pub struct ParameterId(VariableId);
 impl ParameterId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 pub struct LocalId(VariableId);
 impl LocalId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DefinitionId(Id<Definition>);
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ComponentId(DefinitionId);
 impl ComponentId {
     pub fn upcast(self) -> DefinitionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct FunctionId(DefinitionId);
 impl FunctionId {
     pub fn upcast(self) -> DefinitionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct CompositeId(ComponentId);
 impl CompositeId {
     pub fn upcast(self) -> ComponentId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct PrimitiveId(ComponentId);
 impl PrimitiveId {
     pub fn upcast(self) -> ComponentId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct StatementId(Id<Statement>);
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct BlockStatementId(StatementId);
 impl BlockStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct LocalStatementId(StatementId);
 impl LocalStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct MemoryStatementId(LocalStatementId);
 impl MemoryStatementId {
     pub fn upcast(self) -> LocalStatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ChannelStatementId(LocalStatementId);
 impl ChannelStatementId {
     pub fn upcast(self) -> LocalStatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct SkipStatementId(StatementId);
 impl SkipStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct LabeledStatementId(StatementId);
 impl LabeledStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct IfStatementId(StatementId);
 impl IfStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct EndIfStatementId(StatementId);
 impl EndIfStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct WhileStatementId(StatementId);
 impl WhileStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct EndWhileStatementId(StatementId);
 impl EndWhileStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct BreakStatementId(StatementId);
 impl BreakStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ContinueStatementId(StatementId);
 impl ContinueStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct SynchronousStatementId(StatementId);
 impl SynchronousStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct EndSynchronousStatementId(StatementId);
 impl EndSynchronousStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ReturnStatementId(StatementId);
 impl ReturnStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct AssertStatementId(StatementId);
 impl AssertStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct GotoStatementId(StatementId);
 impl GotoStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct NewStatementId(StatementId);
 impl NewStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct PutStatementId(StatementId);
 impl PutStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ExpressionStatementId(StatementId);
 impl ExpressionStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ExpressionId(Id<Expression>);
 #[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, serde::Serialize)]
 pub struct AssignmentExpressionId(ExpressionId);
 impl AssignmentExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ConditionalExpressionId(ExpressionId);
 impl ConditionalExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct BinaryExpressionId(ExpressionId);
 impl BinaryExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct UnaryExpressionId(ExpressionId);
 impl UnaryExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct IndexingExpressionId(ExpressionId);
 impl IndexingExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct SlicingExpressionId(ExpressionId);
 impl SlicingExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct SelectExpressionId(ExpressionId);
 impl SelectExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ArrayExpressionId(ExpressionId);
 impl ArrayExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ConstantExpressionId(ExpressionId);
 impl ConstantExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct CallExpressionId(ExpressionId);
 impl CallExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct VariableExpressionId(ExpressionId);
 impl VariableExpressionId {
     pub fn upcast(self) -> ExpressionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct DeclarationId(Id<Declaration>);
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct DefinedDeclarationId(DeclarationId);
 impl DefinedDeclarationId {
     pub fn upcast(self) -> DeclarationId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct ImportedDeclarationId(DeclarationId);
 impl ImportedDeclarationId {
     pub fn upcast(self) -> DeclarationId {
         self.0
+    }
+}
 #[derive(serde::Serialize)]
 pub struct Heap {
     // Phase 0: allocation
     protocol_descriptions: Arena<Root>,
     pragmas: Arena<Pragma>,
     imports: Arena<Import>,
     identifiers: Arena<Identifier>,
@@ @@ -1196,13 +1197,13 @@ impl Index<DeclarationId> for Heap { @@
     type Output = Declaration;
     fn index(&self, index: DeclarationId) -> &Self::Output {
         &self.declarations[index.0]
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Root {
     pub this: RootId,
     // Phase 1: parser
     pub position: InputPosition,
     pub pragmas: Vec<PragmaId>,
     pub imports: Vec<ImportId>,
@@ @@ -1241,13 +1242,13 @@ impl Root { @@
 impl SyntaxElement for Root {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Pragma {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
@@ @@ -1255,13 +1256,13 @@ pub struct Pragma { @@
 impl SyntaxElement for Pragma {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Import {
     pub this: ImportId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
@@ @@ -1269,13 +1270,13 @@ pub struct Import { @@
 impl SyntaxElement for Import {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Identifier {
     External(ExternalIdentifier),
     Source(SourceIdentifier),
+}
 impl Identifier {
@@ @@ -1321,13 +1322,13 @@ impl PartialEq<Identifier> for Identifier { @@
 impl PartialEq<SourceIdentifier> for Identifier {
     fn eq(&self, rhs: &SourceIdentifier) -> bool {
         self.ident() == rhs.ident()
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ExternalIdentifier {
     pub this: ExternalIdentifierId,
     // Phase 1: parser
     pub value: Vec<u8>,
+}
@@ @@ -1341,13 +1342,13 @@ impl Display for ExternalIdentifier { @@
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // A source identifier is in ASCII range.
         write!(f, "{}", String::from_utf8_lossy(&self.value))
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct SourceIdentifier {
     pub this: SourceIdentifierId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
@@ @@ -1382,26 +1383,26 @@ impl PartialEq<SourceIdentifier> for SourceIdentifier { @@
         self.ident() == rhs.ident()
+    }
+}
 type TypeData = Vec<u8>;
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 pub enum PrimitiveType {
     Input,
     Output,
     Message,
     Boolean,
     Byte,
     Short,
     Int,
     Long,
     Symbolic(TypeData),
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
+}
 #[allow(dead_code)]
@@ @@ -1462,13 +1463,13 @@ impl Display for Type { @@
         } else {
             Ok(())
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct TypeAnnotation {
     pub this: TypeAnnotationId,
     // Phase 1: parser
     pub position: InputPosition,
     pub the_type: Type,
+}
@@ @@ -1479,30 +1480,30 @@ impl SyntaxElement for TypeAnnotation { @@
+    }
+}
 type CharacterData = Vec<u8>;
 type IntegerData = Vec<u8>;
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Constant {
     Null, // message
     True,
     False,
     Character(CharacterData),
     Integer(IntegerData),
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Method {
     Get,
     Fires,
     Create,
     Symbolic(SourceIdentifierId),
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Field {
     Length,
     Symbolic(SourceIdentifierId),
+}
 impl Field {
     pub fn is_length(&self) -> bool {
@@ @@ -1510,13 +1511,13 @@ impl Field { @@
             Field::Length => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, serde::Serialize)]
 pub enum Scope {
     Definition(DefinitionId),
     Block(BlockStatementId),
     Synchronous(SynchronousStatementId),
+}
@@ @@ -1548,13 +1549,13 @@ impl VariableScope for Scope { @@
             Scope::Block(stmt) => h[*stmt].get_variable(h, id),
             Scope::Synchronous(stmt) => h[*stmt].get_variable(h, id),
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Variable {
     Parameter(Parameter),
     Local(Local),
+}
 impl Variable {
@@ @@ -1596,13 +1597,13 @@ impl SyntaxElement for Variable { @@
             Variable::Parameter(decl) => decl.position(),
             Variable::Local(decl) => decl.position(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Parameter {
     pub this: ParameterId,
     // Phase 1: parser
     pub position: InputPosition,
     pub type_annotation: TypeAnnotationId,
     pub identifier: SourceIdentifierId,
@@ @@ -1611,13 +1612,13 @@ pub struct Parameter { @@
 impl SyntaxElement for Parameter {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Local {
     pub this: LocalId,
     // Phase 1: parser
     pub position: InputPosition,
     pub type_annotation: TypeAnnotationId,
     pub identifier: SourceIdentifierId,
@@ @@ -1625,13 +1626,13 @@ pub struct Local { @@
 impl SyntaxElement for Local {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Definition {
     Component(Component),
     Function(Function),
+}
 impl Definition {
@@ @@ -1699,13 +1700,13 @@ impl VariableScope for Definition { @@
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Component {
     Composite(Composite),
     Primitive(Primitive),
+}
 impl Component {
@@ @@ -1753,13 +1754,13 @@ impl SyntaxElement for Component { @@
             Component::Composite(def) => def.position(),
             Component::Primitive(def) => def.position(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Composite {
     pub this: CompositeId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: SourceIdentifierId,
     pub parameters: Vec<ParameterId>,
@@ @@ -1769,13 +1770,13 @@ pub struct Composite { @@
 impl SyntaxElement for Composite {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Primitive {
     pub this: PrimitiveId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: SourceIdentifierId,
     pub parameters: Vec<ParameterId>,
@@ @@ -1785,13 +1786,13 @@ pub struct Primitive { @@
 impl SyntaxElement for Primitive {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Function {
     pub this: FunctionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub return_type: TypeAnnotationId,
     pub identifier: SourceIdentifierId,
@@ @@ -1802,13 +1803,13 @@ pub struct Function { @@
 impl SyntaxElement for Function {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Declaration {
     Defined(DefinedDeclaration),
     Imported(ImportedDeclaration),
+}
 impl Declaration {
@@ @@ -1832,29 +1833,29 @@ impl Declaration { @@
             Declaration::Defined(result) => result,
             _ => panic!("Unable to cast `Declaration` to `DefinedDeclaration`"),
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct DefinedDeclaration {
     pub this: DefinedDeclarationId,
     // Phase 2: linker
     pub definition: DefinitionId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ImportedDeclaration {
     pub this: ImportedDeclarationId,
     // Phase 2: linker
     pub import: ImportId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Signature {
     Component(ComponentSignature),
     Function(FunctionSignature),
+}
 impl Signature {
@@ @@ -1895,26 +1896,26 @@ impl Signature { @@
             Signature::Component(_) => false,
             Signature::Function(_) => true,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ComponentSignature {
     pub identifier: IdentifierId,
     pub arity: Vec<Type>,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct FunctionSignature {
     pub return_type: Type,
     pub identifier: IdentifierId,
     pub arity: Vec<Type>,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Statement {
     Block(BlockStatement),
     Local(LocalStatement),
     Skip(SkipStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
@@ @@ -2145,13 +2146,13 @@ impl SyntaxElement for Statement { @@
             Statement::Put(stmt) => stmt.position(),
             Statement::Expression(stmt) => stmt.position(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub statements: Vec<StatementId>,
     // Phase 2: linker
@@ @@ -2206,13 +2207,13 @@ impl VariableScope for BlockStatement { @@
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
@@ @@ -2248,13 +2249,13 @@ impl SyntaxElement for LocalStatement { @@
             LocalStatement::Memory(stmt) => stmt.position(),
             LocalStatement::Channel(stmt) => stmt.position(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct MemoryStatement {
     pub this: MemoryStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub variable: LocalId,
     pub initial: ExpressionId,
@@ @@ -2265,13 +2266,13 @@ pub struct MemoryStatement { @@
 impl SyntaxElement for MemoryStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ChannelStatement {
     pub this: ChannelStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub from: LocalId, // output
     pub to: LocalId,   // input
@@ @@ -2282,13 +2283,13 @@ pub struct ChannelStatement { @@
 impl SyntaxElement for ChannelStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct SkipStatement {
     pub this: SkipStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     // Phase 2: linker
     pub next: Option<StatementId>,
@@ @@ -2297,13 +2298,13 @@ pub struct SkipStatement { @@
 impl SyntaxElement for SkipStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct LabeledStatement {
     pub this: LabeledStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: SourceIdentifierId,
     pub body: StatementId,
@@ @@ -2314,13 +2315,13 @@ pub struct LabeledStatement { @@
 impl SyntaxElement for LabeledStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub test: ExpressionId,
     pub true_body: StatementId,
@@ @@ -2330,13 +2331,13 @@ pub struct IfStatement { @@
 impl SyntaxElement for IfStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     // Phase 2: linker
     pub position: InputPosition, // of corresponding if statement
     pub next: Option<StatementId>,
+}
@@ @@ -2344,13 +2345,13 @@ pub struct EndIfStatement { @@
 impl SyntaxElement for EndIfStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub test: ExpressionId,
     pub body: StatementId,
@@ @@ -2362,13 +2363,13 @@ pub struct WhileStatement { @@
 impl SyntaxElement for WhileStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     // Phase 2: linker
     pub position: InputPosition, // of corresponding while
     pub next: Option<StatementId>,
+}
@@ @@ -2376,13 +2377,13 @@ pub struct EndWhileStatement { @@
 impl SyntaxElement for EndWhileStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: Option<SourceIdentifierId>,
     // Phase 2: linker
@@ @@ -2392,13 +2393,13 @@ pub struct BreakStatement { @@
 impl SyntaxElement for BreakStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: Option<SourceIdentifierId>,
     // Phase 2: linker
@@ @@ -2408,13 +2409,13 @@ pub struct ContinueStatement { @@
 impl SyntaxElement for ContinueStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
@@ @@ -2439,13 +2440,13 @@ impl VariableScope for SynchronousStatement { @@
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     // Phase 2: linker
     pub position: InputPosition, // of corresponding sync statement
     pub next: Option<StatementId>,
+}
@@ @@ -2453,13 +2454,13 @@ pub struct EndSynchronousStatement { @@
 impl SyntaxElement for EndSynchronousStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
+}
@@ @@ -2467,13 +2468,13 @@ pub struct ReturnStatement { @@
 impl SyntaxElement for ReturnStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct AssertStatement {
     pub this: AssertStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
     // Phase 2: linker
@@ @@ -2483,13 +2484,13 @@ pub struct AssertStatement { @@
 impl SyntaxElement for AssertStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: SourceIdentifierId,
     // Phase 2: linker
@@ @@ -2499,13 +2500,13 @@ pub struct GotoStatement { @@
 impl SyntaxElement for GotoStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: CallExpressionId,
     // Phase 2: linker
@@ @@ -2515,13 +2516,13 @@ pub struct NewStatement { @@
 impl SyntaxElement for NewStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct PutStatement {
     pub this: PutStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub port: ExpressionId,
     pub message: ExpressionId,
@@ @@ -2532,13 +2533,13 @@ pub struct PutStatement { @@
 impl SyntaxElement for PutStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
     // Phase 2: linker
@@ @@ -2548,13 +2549,13 @@ pub struct ExpressionStatement { @@
 impl SyntaxElement for ExpressionStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
@@ @@ -2662,13 +2663,13 @@ impl SyntaxElement for Expression { @@
             Expression::Call(expr) => expr.position(),
             Expression::Variable(expr) => expr.position(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum AssignmentOperator {
     Set,
     Multiplied,
     Divided,
     Remained,
     Added,
@@ @@ -2677,13 +2678,13 @@ pub enum AssignmentOperator { @@
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
@@ @@ -2693,13 +2694,13 @@ pub struct AssignmentExpression { @@
 impl SyntaxElement for AssignmentExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
@@ @@ -2709,13 +2710,13 @@ pub struct ConditionalExpression { @@
 impl SyntaxElement for ConditionalExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
     LogicalAnd,
     BitwiseOr,
     BitwiseXor,
@@ @@ -2732,13 +2733,13 @@ pub enum BinaryOperator { @@
     Subtract,
     Multiply,
     Divide,
     Remainder,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub left: ExpressionId,
     pub operation: BinaryOperator,
@@ @@ -2748,25 +2749,25 @@ pub struct BinaryExpression { @@
 impl SyntaxElement for BinaryExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 pub enum UnaryOperation {
     Positive,
     Negative,
     BitwiseNot,
     LogicalNot,
     PreIncrement,
     PreDecrement,
     PostIncrement,
     PostDecrement,
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub operation: UnaryOperation,
     pub expression: ExpressionId,
@@ @@ -2775,13 +2776,13 @@ pub struct UnaryExpression { @@
 impl SyntaxElement for UnaryExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub subject: ExpressionId,
     pub index: ExpressionId,
@@ @@ -2790,13 +2791,13 @@ pub struct IndexingExpression { @@
 impl SyntaxElement for IndexingExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub subject: ExpressionId,
     pub from_index: ExpressionId,
@@ @@ -2806,13 +2807,13 @@ pub struct SlicingExpression { @@
 impl SyntaxElement for SlicingExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub subject: ExpressionId,
     pub field: Field,
@@ @@ -2821,13 +2822,13 @@ pub struct SelectExpression { @@
 impl SyntaxElement for SelectExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ArrayExpression {
     pub this: ArrayExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub elements: Vec<ExpressionId>,
+}
@@ @@ -2835,13 +2836,13 @@ pub struct ArrayExpression { @@
 impl SyntaxElement for ArrayExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
@@ @@ -2852,13 +2853,13 @@ pub struct CallExpression { @@
 impl SyntaxElement for CallExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ConstantExpression {
     pub this: ConstantExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Constant,
+}
@@ @@ -2866,13 +2867,13 @@ pub struct ConstantExpression { @@
 impl SyntaxElement for ConstantExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct VariableExpression {
     pub this: VariableExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: SourceIdentifierId,
     // Phase 2: linker

src/protocol/inputsource.rs

➞

Show inline comments

@@ @@ -2,13 +2,13 @@ use std::fmt; @@
 use std::fs::File;
 use std::io;
 use std::path::Path;
 use backtrace::Backtrace;
 #[derive(Clone)]
+#[derive(Clone, serde::Serialize)]
 pub struct InputSource {
     filename: String,
     input: Vec<u8>,
     line: usize,
     column: usize,
     offset: usize,
@@ @@ -117,13 +117,13 @@ impl InputSource { @@
 impl fmt::Display for InputSource {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.pos().fmt(f)
+    }
+}
 #[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, serde::Serialize)]
 pub struct InputPosition {
     line: usize,
     column: usize,
     offset: usize,
+}

src/protocol/mod.rs

➞

Show inline comments

@@ @@ -9,12 +9,13 @@ mod parser; @@
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 #[derive(serde::Serialize)]
 pub struct ProtocolDescriptionImpl {
     heap: Heap,
     source: InputSource,
     root: RootId,
+}

0 comments (0 inline, 0 general)