}

}

pub struct Arena<T> {

    store: Vec<T>,

}

use crate::protocol::inputsource::*;

pub struct RootId(Id<Root>);

pub struct PragmaId(Id<Pragma>);

pub struct ImportId(Id<Import>);

pub struct IdentifierId(Id<Identifier>);

pub struct SourceIdentifierId(IdentifierId);

impl SourceIdentifierId {

    }

}

pub struct ExternalIdentifierId(IdentifierId);

impl ExternalIdentifierId {

    }

}

pub struct TypeAnnotationId(Id<TypeAnnotation>);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]

pub struct VariableId(Id<Variable>);

pub struct ParameterId(VariableId);

impl ParameterId {

    }

}

pub struct LocalId(VariableId);

impl LocalId {

#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]

pub struct DefinitionId(Id<Definition>);

pub struct ComponentId(DefinitionId);

impl ComponentId {

    }

}

pub struct FunctionId(DefinitionId);

impl FunctionId {

    }

}

pub struct CompositeId(ComponentId);

impl CompositeId {

    }

}

pub struct PrimitiveId(ComponentId);

impl PrimitiveId {

#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]

pub struct StatementId(Id<Statement>);

pub struct BlockStatementId(StatementId);

impl BlockStatementId {

    }

}

pub struct LocalStatementId(StatementId);

impl LocalStatementId {

    }

}

pub struct MemoryStatementId(LocalStatementId);

impl MemoryStatementId {

    }

}

pub struct ChannelStatementId(LocalStatementId);

impl ChannelStatementId {

    }

}

pub struct SkipStatementId(StatementId);

impl SkipStatementId {

    }

}

pub struct LabeledStatementId(StatementId);

impl LabeledStatementId {

    }

}

pub struct IfStatementId(StatementId);

impl IfStatementId {

    }

}

pub struct EndIfStatementId(StatementId);

impl EndIfStatementId {

    }

}

pub struct WhileStatementId(StatementId);

impl WhileStatementId {

    }

}

pub struct EndWhileStatementId(StatementId);

impl EndWhileStatementId {

    }

}

pub struct BreakStatementId(StatementId);

impl BreakStatementId {

    }

}

pub struct ContinueStatementId(StatementId);

impl ContinueStatementId {

    }

}

pub struct SynchronousStatementId(StatementId);

impl SynchronousStatementId {

    }

}

pub struct EndSynchronousStatementId(StatementId);

impl EndSynchronousStatementId {

    }

}

pub struct ReturnStatementId(StatementId);

impl ReturnStatementId {

    }

}

pub struct AssertStatementId(StatementId);

impl AssertStatementId {

    }

}

pub struct GotoStatementId(StatementId);

impl GotoStatementId {

    }

}

pub struct NewStatementId(StatementId);

impl NewStatementId {

    }

}

pub struct PutStatementId(StatementId);

impl PutStatementId {

    }

}

pub struct ExpressionStatementId(StatementId);

impl ExpressionStatementId {

    }

}

pub struct ExpressionId(Id<Expression>);

pub struct AssignmentExpressionId(ExpressionId);

impl AssignmentExpressionId {

    }

}

pub struct ConditionalExpressionId(ExpressionId);

impl ConditionalExpressionId {

    }

}

pub struct BinaryExpressionId(ExpressionId);

impl BinaryExpressionId {

    }

}

pub struct UnaryExpressionId(ExpressionId);

impl UnaryExpressionId {

    }

}

pub struct IndexingExpressionId(ExpressionId);

impl IndexingExpressionId {

    }

}

pub struct SlicingExpressionId(ExpressionId);

impl SlicingExpressionId {

    }

}

pub struct SelectExpressionId(ExpressionId);

impl SelectExpressionId {

    }

}

pub struct ArrayExpressionId(ExpressionId);

impl ArrayExpressionId {

    }

}

pub struct ConstantExpressionId(ExpressionId);

impl ConstantExpressionId {

    }

}

pub struct CallExpressionId(ExpressionId);

impl CallExpressionId {

    }

}

pub struct VariableExpressionId(ExpressionId);

impl VariableExpressionId {

    }

}

pub struct DeclarationId(Id<Declaration>);

pub struct DefinedDeclarationId(DeclarationId);

impl DefinedDeclarationId {

    }

}

pub struct ImportedDeclarationId(DeclarationId);

impl ImportedDeclarationId {

    }

}

pub struct Heap {

    // Phase 0: allocation

    protocol_descriptions: Arena<Root>,

    }

}

pub struct Root {

    pub this: RootId,

    // Phase 1: parser

    }

}

pub struct Pragma {

    pub this: PragmaId,

    // Phase 1: parser

    }

}

pub struct Import {

    pub this: ImportId,

    // Phase 1: parser

    }

}

pub enum Identifier {

    External(ExternalIdentifier),

    Source(SourceIdentifier),

    }

}

pub struct ExternalIdentifier {

    pub this: ExternalIdentifierId,

    // Phase 1: parser

    }

}

pub struct SourceIdentifier {

    pub this: SourceIdentifierId,

    // Phase 1: parser

type TypeData = Vec<u8>;

pub enum PrimitiveType {

    Input,

    Output,

    Symbolic(TypeData),

}

pub struct Type {

    pub primitive: PrimitiveType,

    pub array: bool,

    }

}

pub struct TypeAnnotation {

    pub this: TypeAnnotationId,

    // Phase 1: parser

type CharacterData = Vec<u8>;

type IntegerData = Vec<u8>;

pub enum Constant {

    Null, // message

    True,

    Integer(IntegerData),

}

pub enum Method {

    Get,

    Fires,

    Symbolic(SourceIdentifierId),

}

pub enum Field {

    Length,

    Symbolic(SourceIdentifierId),

    }

}

pub enum Scope {

    Definition(DefinitionId),

    Block(BlockStatementId),

    }

}

pub enum Variable {

    Parameter(Parameter),

    Local(Local),

    }

}

pub struct Parameter {

    pub this: ParameterId,

    // Phase 1: parser

    }

}

pub struct Local {

    pub this: LocalId,

    // Phase 1: parser

    }

}

pub enum Definition {

    Component(Component),

    Function(Function),

    }

}

pub enum Component {

    Composite(Composite),

    Primitive(Primitive),

    }

}

pub struct Composite {

    pub this: CompositeId,

    // Phase 1: parser

    }

}

pub struct Primitive {

    pub this: PrimitiveId,

    // Phase 1: parser

    }

}

pub struct Function {

    pub this: FunctionId,

    // Phase 1: parser

    }

}

pub enum Declaration {

    Defined(DefinedDeclaration),

    Imported(ImportedDeclaration),

    }

}

pub struct DefinedDeclaration {

    pub this: DefinedDeclarationId,

    // Phase 2: linker

    pub signature: Signature,

}

pub struct ImportedDeclaration {

    pub this: ImportedDeclarationId,

    // Phase 2: linker

    pub signature: Signature,

}

pub enum Signature {

    Component(ComponentSignature),

    Function(FunctionSignature),

    }

}

pub struct ComponentSignature {

    pub identifier: IdentifierId,

    pub arity: Vec<Type>,

}

pub struct FunctionSignature {

    pub return_type: Type,

    pub identifier: IdentifierId,

    pub arity: Vec<Type>,

}

pub enum Statement {

    Block(BlockStatement),

    Local(LocalStatement),

    }

}

pub struct BlockStatement {

    pub this: BlockStatementId,

    // Phase 1: parser

    }

}

pub enum LocalStatement {

    Memory(MemoryStatement),

    Channel(ChannelStatement),

    }

}

pub struct MemoryStatement {

    pub this: MemoryStatementId,

    // Phase 1: parser

    }

}

pub struct ChannelStatement {

    pub this: ChannelStatementId,

    // Phase 1: parser

    }

}

pub struct SkipStatement {

    pub this: SkipStatementId,

    // Phase 1: parser

    }

}

pub struct LabeledStatement {

    pub this: LabeledStatementId,

    // Phase 1: parser

    }

}

pub struct IfStatement {

    pub this: IfStatementId,

    // Phase 1: parser

    }

}

pub struct EndIfStatement {

    pub this: EndIfStatementId,

    // Phase 2: linker

    }

}

pub struct WhileStatement {

    pub this: WhileStatementId,

    // Phase 1: parser

    }

}

pub struct EndWhileStatement {

    pub this: EndWhileStatementId,

    // Phase 2: linker

    }

}

pub struct BreakStatement {

    pub this: BreakStatementId,

    // Phase 1: parser

    }

}

pub struct ContinueStatement {

    pub this: ContinueStatementId,

    // Phase 1: parser

    }

}

pub struct SynchronousStatement {

    pub this: SynchronousStatementId,

    // Phase 1: parser

    }

}

pub struct EndSynchronousStatement {

    pub this: EndSynchronousStatementId,

    // Phase 2: linker

    }

}

pub struct ReturnStatement {

    pub this: ReturnStatementId,

    // Phase 1: parser

    }

}

pub struct AssertStatement {

    pub this: AssertStatementId,

    // Phase 1: parser

    }

}

pub struct GotoStatement {

    pub this: GotoStatementId,

    // Phase 1: parser

    }

}

pub struct NewStatement {

    pub this: NewStatementId,

    // Phase 1: parser

    }

}

pub struct PutStatement {

    pub this: PutStatementId,

    // Phase 1: parser

    }

}

pub struct ExpressionStatement {

    pub this: ExpressionStatementId,

    // Phase 1: parser

    }

}

pub enum Expression {

    Assignment(AssignmentExpression),

    Conditional(ConditionalExpression),

    }

}

pub enum AssignmentOperator {

    Set,

    Multiplied,

    BitwiseOred,

}

pub struct AssignmentExpression {

    pub this: AssignmentExpressionId,

    // Phase 1: parser

    }

}

pub struct ConditionalExpression {

    pub this: ConditionalExpressionId,

    // Phase 1: parser

    }

}

pub enum BinaryOperator {

    Concatenate,

    LogicalOr,

    Remainder,

}