/// Used in conjunction with the `ConnectorId` type to create identifiers for ports and components

pub type U32Suffix = u32;

/// Generalization of a port/component identifier

#[repr(C)]

pub struct Id {

    pub(crate) connector_id: ConnectorId,

}

/// Identifier of a component in a session

pub struct ComponentId(Id); // PUB because it can be returned by errors

/// Identifier of a port in a session

#[repr(transparent)]

pub struct PortId(Id);

/// A safely aliasable heap-allocated payload of message bytes

#[derive(Default, Eq, PartialEq, Clone, Ord, PartialOrd)]

pub struct Payload(Arc<Vec<u8>>);

/// "Orientation" of a port, determining whether they can send or receive messages with `put` and `get` respectively.

#[repr(C)]

pub enum Polarity {

    Putter, // output port (from the perspective of the component)

    Getter, // input port (from the perspective of the component)

}

/// "Orientation" of a transport-layer network endpoint, dictating how it's connection procedure should

/// be conducted. Corresponds with connect() / accept() familiar to TCP socket programming.

use core::hash::Hash;

use core::marker::PhantomData;

pub struct Id<T> {

    pub(crate) index: u32,

    _phantom: PhantomData<T>,

    }

}

pub(crate) struct Arena<T> {

    store: Vec<T>,

}

macro_rules! define_new_ast_id {

    // Variant where we just defined the new type, without any indexing

    ($name:ident, $parent:ty) => {

        pub struct $name (pub(crate) $parent);

        impl $name {

define_new_ast_id!(VariableExpressionId, ExpressionId, index(VariableExpression, Expression::Variable, expressions), alloc(alloc_variable_expression));

// TODO: @cleanup - pub qualifiers can be removed once done

pub struct Heap {

    // Root arena, contains the entry point for different modules. Each root

    // contains lists of IDs that correspond to the other arenas.

    }

}

pub struct Root {

    pub this: RootId,

    // Phase 1: parser

    }

}

pub enum Pragma {

    Version(PragmaVersion),

    Module(PragmaModule)

}

pub struct PragmaVersion {

    pub this: PragmaId,

    // Phase 1: parser

    pub version: u64,

}

pub struct PragmaModule {

    pub this: PragmaId,

    // Phase 1: parser

    pub value: Vec<u8>,

}

pub struct PragmaOld {

    pub this: PragmaId,

    // Phase 1: parser

    }

}

pub enum Import {

    Module(ImportModule),

    Symbols(ImportSymbols)

    }

}

pub struct ImportModule {

    pub this: ImportId,

    // Phase 1: parser

    pub module_id: Option<RootId>,

}

pub struct AliasedSymbol {

    // Phase 1: parser

    pub position: InputPosition,

    pub definition_id: Option<DefinitionId>,

}

pub struct ImportSymbols {

    pub this: ImportId,

    // Phase 1: parser

    pub symbols: Vec<AliasedSymbol>,

}

pub struct Identifier {

    pub position: InputPosition,

    pub value: Vec<u8>

    }

}

pub enum NamespacedIdentifierPart {

    // Regular identifier

    Identifier{start: u16, end: u16},

/// implementation we can only have valid namespaced identifier that contain one

/// set of polymorphic arguments at the appropriate position.

/// TODO: @tokens Reimplement/rename once we have a tokenizer

pub struct NamespacedIdentifier {

    pub position: InputPosition,

    pub value: Vec<u8>, // Full name as it resides in the input source

}

/// TODO: @types Remove the Message -> Byte hack at some point...

pub enum ParserTypeVariant {

    // Basic builtin

    Message,

/// linker/validator phase of the compilation process. These types may be

/// (partially) inferred or represent literals (e.g. a integer whose bytesize is

/// not yet determined).

pub struct ParserType {

    pub this: ParserTypeId,

    pub pos: InputPosition,

/// validation phase we will determine whether it refers to a user-defined type,

/// or a polymorphic argument. After the validation phase it may still be the

/// case that the resulting `variant` will not pass the typechecker.

pub struct SymbolicParserType {

    // Phase 1: parser

    pub identifier: NamespacedIdentifier,

/// Specifies whether the symbolic type points to an actual user-defined type,

/// or whether it points to a polymorphic argument within the definition (e.g.

/// a defined variable `T var` within a function `int func<T>()`

pub enum SymbolicParserTypeVariant {

    Definition(DefinitionId),

    // TODO: figure out if I need the DefinitionId here

/// ConcreteType is the representation of a type after resolving symbolic types

/// and performing type inference

pub enum ConcreteTypePart {

    // Markers for the use of polymorphic types within a procedure's body that

    // refer to polymorphic variables on the procedure's definition. Different

    Instance(DefinitionId, usize),

}

pub struct ConcreteType {

    pub(crate) parts: Vec<ConcreteTypePart>

}

}

// TODO: Remove at some point

pub enum PrimitiveType {

    Unassigned,

    Input,

    Long,

}

pub struct Type {

    pub primitive: PrimitiveType,

    pub array: bool,

    }

}

pub enum Field {

    Length,

    Symbolic(FieldSymbolic),

    }

}

pub struct FieldSymbolic {

    // Phase 1: Parser

    pub(crate) identifier: Identifier,

    pub(crate) field_idx: usize,

}

pub enum Scope {

    Definition(DefinitionId),

    Regular(BlockStatementId),

    }

}

pub enum Variable {

    Parameter(Parameter),

    Local(Local),

/// TODO: Remove distinction between parameter/local and add an enum to indicate

///     the distinction between the two

pub struct Parameter {

    pub this: ParameterId,

    // Phase 1: parser

    }

}

pub struct Local {

    pub this: LocalId,

    // Phase 1: parser

    }

}

pub enum Definition {

    Struct(StructDefinition),

    Enum(EnumDefinition),

    }

}

pub struct StructFieldDefinition {

    pub position: InputPosition,

    pub field: Identifier,

    pub parser_type: ParserTypeId,

}

pub struct StructDefinition {

    pub this: StructId,

    // Phase 1: parser

    pub fields: Vec<StructFieldDefinition>

}

pub enum EnumVariantValue {

    None,

    Integer(i64),

}

pub struct EnumVariantDefinition {

    pub position: InputPosition,

    pub identifier: Identifier,

    pub value: EnumVariantValue,

}

pub struct EnumDefinition {

    pub this: EnumId,

    // Phase 1: parser

    pub variants: Vec<EnumVariantDefinition>,

}

pub enum UnionVariantValue {

    None,

    Embedded(Vec<ParserTypeId>),

}

pub struct UnionVariantDefinition {

    pub position: InputPosition,

    pub identifier: Identifier,

    pub value: UnionVariantValue,

}

pub struct UnionDefinition {

    pub this: UnionId,

    // Phase 1: parser

    pub variants: Vec<UnionVariantDefinition>,

}

pub enum ComponentVariant {

    Primitive,

    Composite,

}

pub struct Component {

    pub this: ComponentId,

    // Phase 1: parser

    }

}

pub struct Function {

    pub this: FunctionId,

    // Phase 1: parser

    }

}

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

/// point of view of the component. So an output port is something that a

/// component uses to send data over (i.e. it is the "input end" of the

/// channel), and vice versa.

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 ExpressionStatement {

    pub this: ExpressionStatementId,

    // Phase 1: parser

    }

}

pub enum ExpressionParent {

    None, // only set during initial parsing

    If(IfStatementId),

    Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)

}

pub enum Expression {

    Assignment(AssignmentExpression),

    Binding(BindingExpression),

    }

}

pub enum AssignmentOperator {

    Set,

    Multiplied,

    BitwiseOred,

}

pub struct AssignmentExpression {

    pub this: AssignmentExpressionId,

    // Phase 1: parser

    }

}

pub struct BindingExpression {

    pub this: BindingExpressionId,

    // Phase 1: parser

    pub concrete_type: ConcreteType,

}

pub struct ConditionalExpression {

    pub this: ConditionalExpressionId,

    // Phase 1: parser

    }

}

pub enum BinaryOperator {

    Concatenate,

    LogicalOr,

    Remainder,

}

pub struct BinaryExpression {

    pub this: BinaryExpressionId,

    // Phase 1: parser

    }

}

pub enum UnaryOperation {

    Positive,

    Negative,

    PostDecrement,

}

pub struct UnaryExpression {

    pub this: UnaryExpressionId,

    // Phase 1: parser

    }

}

pub struct IndexingExpression {

    pub this: IndexingExpressionId,

    // Phase 1: parser

    }

}

pub struct SlicingExpression {

    pub this: SlicingExpressionId,

    // Phase 1: parser

    }

}

pub struct SelectExpression {

    pub this: SelectExpressionId,

    // Phase 1: parser

    }

}

pub struct ArrayExpression {

    pub this: ArrayExpressionId,

    // Phase 1: parser

//  that accept embedded values (although the polymorphic arguments are placed

//  differently). To prevent double work we parse as CallExpression, and during

//  validation we may transform the expression into a union literal.

pub struct CallExpression {

    pub this: CallExpressionId,

    // Phase 1: parser

    }

}

pub enum Method {

    Get,

    Put,

    Symbolic(MethodSymbolic)

}

pub struct MethodSymbolic {

    pub(crate) identifier: NamespacedIdentifier,

    pub(crate) definition: Option<DefinitionId>

}

pub struct LiteralExpression {

    pub this: LiteralExpressionId,

    // Phase 1: parser

type LiteralCharacter = Vec<u8>;

type LiteralInteger = i64; // TODO: @int_literal

pub enum Literal {

    Null, // message

    True,

    }

}

pub struct LiteralStructField {

    // Phase 1: parser

    pub(crate) identifier: Identifier,

    pub(crate) field_idx: usize, // in struct definition

}

pub struct LiteralStruct {

    // Phase 1: parser

    pub(crate) identifier: NamespacedIdentifier,

//  accept embedded values. To prevent double work for now we parse as a 

//  LiteralEnum, and during validation we may transform the expression into a 

//  union literal.

pub struct LiteralEnum {

    // Phase 1: parser

    pub(crate) identifier: NamespacedIdentifier,

    pub(crate) variant_idx: usize, // as present in the type table

}

pub struct LiteralUnion {

    // Phase 1: parser

    pub(crate) identifier: NamespacedIdentifier,

    pub(crate) variant_idx: usize, // as present in type table

}

pub struct VariableExpression {

    pub this: VariableExpressionId,

    // Phase 1: parser

    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool;

}

pub enum Value {

    Unassigned,

    Input(InputValue),

    }

}

pub struct InputValue(pub PortId);

impl Display for InputValue {

    }

}

pub struct OutputValue(pub PortId);

impl Display for OutputValue {

    }

}

pub struct MessageValue(pub Option<Payload>);

impl Display for MessageValue {

    }

}

pub struct BooleanValue(bool);

impl Display for BooleanValue {

    }

}

pub struct ByteValue(i8);

impl Display for ByteValue {

    }

}

pub struct ShortValue(i16);

impl Display for ShortValue {

    }

}