}

impl PartialEq for NamespacedIdentifier {

    fn eq(&self, other: &Self) -> bool {

        return self.value == other.value

    }

}

impl Eq for NamespacedIdentifier{}

// TODO: Just keep ref to NamespacedIdentifier

pub(crate) struct NamespacedIdentifierIter<'a> {

    value: &'a Vec<u8>,

    cur_offset: usize,

    num_returned: u8,

    num_total: u8,

}

impl<'a> NamespacedIdentifierIter<'a> {

    pub(crate) fn num_returned(&self) -> u8 {

        return self.num_returned;

    }

    pub(crate) fn num_remaining(&self) -> u8 {

        return self.num_total - self.num_returned

    }

}

impl<'a> Iterator for NamespacedIdentifierIter<'a> {

    type Item = &'a [u8];

    fn next(&mut self) -> Option<Self::Item> {

        if self.cur_offset >= self.value.len() {

            debug_assert_eq!(self.num_returned, self.num_total);

            None

        } else {

            debug_assert!(self.num_returned < self.num_total);

            let start = self.cur_offset;

            let mut end = start;

            while end < self.value.len() - 1 {

                if self.value[end] == b':' && self.value[end + 1] == b':' {

                    self.cur_offset = end + 2;

                    self.num_returned += 1;

                    return Some(&self.value[start..end]);

                }

                end += 1;

            }

            // If NamespacedIdentifier is constructed properly, then we cannot

            // end with "::" in the value, so

            debug_assert!(end == 0 || (self.value[end - 1] != b':' && self.value[end] != b':'));

/// parsing phase we will only store the identifier of the type. During the

/// 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.

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

pub struct SymbolicParserType {

    // Phase 1: parser

    pub identifier: NamespacedIdentifier,

    /// The user-specified polymorphic arguments. Zero-length implies that the

    /// user did not specify any of them, and they're either not needed or all

    /// need to be inferred. Otherwise the number of polymorphic arguments must

    /// match those of the corresponding definition

    pub poly_args: Vec<ParserTypeId>,

    // Phase 2: validation/linking (for types in function/component bodies) and

    //  type table construction (for embedded types of structs/unions)

    pub variant: Option<SymbolicParserTypeVariant>

}

/// 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>()`

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

pub enum SymbolicParserTypeVariant {

    Definition(DefinitionId),

}

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

pub enum PrimitiveType {

    Input,

    Output,

    Message,

    Boolean,

    Byte,

    Short,

    Int,

    Long,

    Symbolic(PrimitiveSymbolic)

}

// TODO: @cleanup, remove PartialEq implementations

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

pub struct PrimitiveSymbolic {

    // Phase 1: parser

    pub(crate) identifier: NamespacedIdentifier,

    // Phase 2: typing

    pub(crate) definition: Option<DefinitionId>

}

mod depth_visitor;

mod symbol_table;

// mod type_table_old;

mod type_table;

mod type_resolver;

mod visitor;

mod visitor_linker;

use depth_visitor::*;

use symbol_table::SymbolTable;

use visitor::Visitor2;

use visitor_linker::ValidityAndLinkerVisitor;

use type_table::{TypeTable, TypeCtx};

use crate::protocol::ast::*;

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

use crate::protocol::lexer::*;

use std::collections::HashMap;

use crate::protocol::ast_printer::ASTWriter;

// TODO: @fixme, pub qualifier

pub(crate) struct LexedModule {

    pub(crate) source: InputSource,

    module_name: Vec<u8>,

    version: Option<u64>,

    root_id: RootId,

}

pub struct Parser {

    pub(crate) heap: Heap,

// Defined Types

//------------------------------------------------------------------------------

#[derive(Copy, Clone, PartialEq, Eq)]

pub enum TypeClass {

    Enum,

    Union,

    Struct,

    Function,

    Component

}

impl TypeClass {

    pub(crate) fn display_name(&self) -> &'static str {

        match self {

            TypeClass::Enum => "enum",

            TypeClass::Union => "enum",

            TypeClass::Struct => "struct",

            TypeClass::Function => "function",

            TypeClass::Component => "component",

        }

    }

    pub(crate) fn is_data_type(&self) -> bool {

    }

    pub(crate) fn is_proc_type(&self) -> bool {

    }

}

impl std::fmt::Display for TypeClass {

    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {

        write!(f, "{}", self.display_name())

    }

}

/// Struct wrapping around a potentially polymorphic type. If the type does not

/// have any polymorphic arguments then it will not have any monomorphs and

/// `is_polymorph` will be set to `false`. A type with polymorphic arguments

/// only has `is_polymorph` set to `true` if the polymorphic arguments actually

/// appear in the types associated types (function return argument, struct

/// field, enum variant, etc.). Otherwise the polymorphic argument is just a

/// marker and does not influence the bytesize of the type.

pub struct DefinedType {

    pub(crate) ast_definition: DefinitionId,

    pub(crate) definition: DefinedTypeVariant,

    pub(crate) poly_args: Vec<PolyArg>,

    pub(crate) is_polymorph: bool,

    pub(crate) is_pointerlike: bool,

    pub(crate) monomorphs: Vec<u32>, // TODO: ?

}

                        Some(*parser_type_id)

                    },

                    EnumVariantValue::Integer(_) => {

                        debug_assert!(false, "Encountered `Integer` variant after asserting enum is a discriminated union");

                        unreachable!();

                    }

                };

                variants.push(UnionVariant{

                    identifier: variant.identifier.clone(),

                    parser_type,

                    tag_value,

                })

            }

            // Ensure union names and polymorphic args do not conflict

            self.check_identifier_collision(

                ctx, root_id, &variants, |variant| &variant.identifier, "enum variant"

            )?;

            self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;

            let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);

            for variant in &variants {

                if let Some(embedded) = variant.parser_type {

                }

            }

            let is_polymorph = poly_args.iter().any(|arg| arg.is_in_use);

            // Insert base definition in type table

            self.lookup.insert(definition_id, DefinedType {

                ast_definition: definition_id,

                definition: DefinedTypeVariant::Union(UnionType{

                    variants,

                    tag_representation: Self::enum_tag_type(-1, tag_value),

                }),

                poly_args,

                is_polymorph,

                is_pointerlike: false, // TODO: @cyclic_types

                monomorphs: Vec::new()

            });

        } else {

            // Implement as a regular enum

            let mut enum_value = -1;

            let mut min_enum_value = 0;

            let mut max_enum_value = 0;

            let mut variants = Vec::with_capacity(definition.variants.len());

            for variant in &definition.variants {

                enum_value += 1;

            let resolve_result = self.resolve_base_parser_type(ctx, &definition.poly_vars, root_id, field_definition.parser_type)?;

            if !self.ingest_resolve_result(ctx, resolve_result)? {

                return Ok(false)

            }

        }

        // All fields types are resolved, construct base type

        let mut fields = Vec::with_capacity(definition.fields.len());

        for field_definition in &definition.fields {

            fields.push(StructField{

                identifier: field_definition.field.clone(),

                parser_type: field_definition.parser_type,

            })

        }

        // And make sure no conflicts exist in field names and/or polymorphic args

        self.check_identifier_collision(

            ctx, root_id, &fields, |field| &field.identifier, "struct field"

        )?;

        self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;

        // Construct representation of polymorphic arguments

        let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);

        for field in &fields {

        }

        let is_polymorph = poly_args.iter().any(|arg| arg.is_in_use);

        self.lookup.insert(definition_id, DefinedType{

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Struct(StructType{

                fields,

            }),

            poly_args,

            is_polymorph,

            is_pointerlike: false, // TODO: @cyclic

            monomorphs: Vec::new(),

        });

        Ok(true)

    }

    /// Resolves the basic function definition to an entry in the type table. It

    /// will not instantiate any monomorphized instances of polymorphic function

    /// definitions.

    fn resolve_base_function_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {

        debug_assert!(ctx.heap[definition_id].is_function());

        debug_assert!(!self.lookup.contains_key(&definition_id), "base function already resolved");

            )?;

            if !self.ingest_resolve_result(ctx, resolve_result)? {

                return Ok(false)

            }

        }

        // Construct arguments to function

        let mut arguments = Vec::with_capacity(definition.parameters.len());

        for param_id in &definition.parameters {

            let param = &ctx.heap[*param_id];

            arguments.push(FunctionArgument{

                identifier: param.identifier.clone(),

                parser_type: param.parser_type,

            })

        }

        // Check conflict of argument and polyarg identifiers

        self.check_identifier_collision(

            ctx, root_id, &arguments, |arg| &arg.identifier, "function argument"

        )?;

        self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;

        // Construct polymorphic arguments

        let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);

        for argument in &arguments {

        }

        let is_polymorph = poly_args.iter().any(|arg| arg.is_in_use);

        // Construct entry in type table

        self.lookup.insert(definition_id, DefinedType{

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Function(FunctionType{

                return_type,

                arguments,

            }),

            poly_args,

            is_polymorph,

            is_pointerlike: false, // TODO: @cyclic

            monomorphs: Vec::new(),

        });

        Ok(true)

    }

    /// Resolves the basic component definition to an entry in the type table.

    /// It will not instantiate any monomorphized instancees of polymorphic

    /// component definitions.

    fn resolve_base_component_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {

            if !self.ingest_resolve_result(ctx, resolve_result)? {

                return Ok(false)

            }

        }

        // Construct argument types

        let mut arguments = Vec::with_capacity(definition.parameters.len());

        for param_id in &definition.parameters {

            let param = &ctx.heap[*param_id];

            arguments.push(FunctionArgument{

                identifier: param.identifier.clone(),

                parser_type: param.parser_type

            })

        }

        // Check conflict of argument and polyarg identifiers

        self.check_identifier_collision(

            ctx, root_id, &arguments, |arg| &arg.identifier, "component argument"

        )?;

        self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;

        // Construct polymorphic arguments

        let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);

        for argument in &arguments {

        }

        let is_polymorph = poly_args.iter().any(|v| v.is_in_use);

        // Construct entry in type table

        self.lookup.insert(definition_id, DefinedType{

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Component(ComponentType{

                variant: component_variant,

                arguments,

            }),

            poly_args,

            is_polymorph,

            is_pointerlike: false, // TODO: @cyclic

            monomorphs: Vec::new(),

        });

        Ok(true)

    }

    /// Takes a ResolveResult and returns `true` if the caller can happily

    /// continue resolving its current type, or `false` if the caller must break

    /// resolving the current type and exit to the outer resolving loop. In the

    /// latter case the `result` value was `ResolveResult::Unresolved`, implying

        return Ok(resolve_result.unwrap())

    }

    fn create_initial_poly_args(&self, poly_args: &[Identifier]) -> Vec<PolyArg> {

        poly_args

            .iter()

            .map(|v| PolyArg{ identifier: v.clone(), is_in_use: false })

            .collect()

    }

    /// This function modifies the passed `poly_args` by checking the embedded

    /// type tree. This should be called after `resolve_base_parser_type` is

    /// called on each node in this tree: we assume that each symbolic type was

    /// resolved to either a polymorphic arg or a definition.

    ///

    /// This function will also make sure that if the embedded type has

    /// polymorphic variables itself, that the number of polymorphic variables

    /// matches the number of arguments in the associated definition.

    ///

    /// Finally, for all embedded types (which includes function/component 

    /// arguments and return types) in type definitions we will modify the AST

    /// when the embedded type is a polymorphic variable or points to another

    /// user-defined type.

    fn check_and_resolve_embedded_type_and_modify_poly_args(

    ) -> Result<(), ParseError2> {

        use ParserTypeVariant as PTV;

        self.parser_type_iter.clear();

        self.parser_type_iter.push_back(embedded_type_id);

        'type_loop: while let Some(embedded_type_id) = self.parser_type_iter.pop_back() {

            let embedded_type = &mut ctx.heap[embedded_type_id];

            match &mut embedded_type.variant {

                PTV::Message | PTV::Bool | 

                PTV::Byte | PTV::Short | PTV::Int | PTV::Long |

                PTV::String => {

                    // Builtins, no modification/iteration required

                },

                PTV::IntegerLiteral | PTV::Inferred => {

                    // TODO: @hack Allowed for now so we can continue testing 

                    //  the parser/lexer

                    // debug_assert!(false, "encountered illegal parser type during ParserType/PolyArg modification");

                    // unreachable!();

                },

                PTV::Array(subtype_id) |

                PTV::Input(subtype_id) |

                PTV::Output(subtype_id) => {

                    // Outer type is fixed, but inner type might be symbolix

                    self.parser_type_iter.push_back(*subtype_id);

                },

                PTV::Symbolic(symbolic) => {

                    for (poly_arg_idx, poly_arg) in poly_args.iter_mut().enumerate() {

                        if poly_arg.identifier.value == symbolic.identifier.value {

                            poly_arg.is_in_use = true;

                            // TODO: If we allow higher-kinded types in the future,

                            //  then we can't continue here, but must resolve the

                            //  polyargs as well

                            debug_assert!(symbolic.poly_args.is_empty(), "got polymorphic arguments to a polymorphic variable");

                            debug_assert!(symbolic.variant.is_none(), "symbolic parser type's variant already resolved");

                            continue 'type_loop;

                        }

                    }

                    // Must match a definition

                    let symbol = ctx.symbols.resolve_namespaced_symbol(root_id, &symbolic.identifier);

                    debug_assert!(symbol.is_some(), "could not resolve symbolic parser type when determining poly args");

                    let (symbol, ident_iter) = symbol.unwrap();

                    debug_assert_eq!(ident_iter.num_remaining(), 0, "no exact symbol match when determining poly args");

                    let (_root_id, definition_id) = symbol.as_definition().unwrap();

                    // Must be a struct, enum, or union

                    let defined_type = self.lookup.get(&definition_id).unwrap();

                    if cfg!(debug_assertions) {

                        let type_class = defined_type.definition.type_class();

                        debug_assert!(

                            type_class == TypeClass::Struct || type_class == TypeClass::Enum || type_class == TypeClass::Union,

                            "embedded type's class is not struct, enum or union"

                        );

                    }

                    if symbolic.poly_args.len() != defined_type.poly_args.len() {

                        // Mismatch in number of polymorphic arguments. This is 

                        // not allowed in type definitions (no inference is 

use crate::protocol::ast::*;

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

use super::visitor::{

    STMT_BUFFER_INIT_CAPACITY,

    EXPR_BUFFER_INIT_CAPACITY,

    TYPE_BUFFER_INIT_CAPACITY,

    Ctx, 

    Visitor2, 

    VisitorResult

};

#[derive(PartialEq, Eq)]

enum DefinitionType {

    None,

    Primitive(ComponentId),

    Composite(ComponentId),

    Function(FunctionId)

}

impl DefinitionType {

    fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }

    fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }

    fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }

}

/// This particular visitor will go through the entire AST in a recursive manner

/// and check if all statements and expressions are legal (e.g. no "return"

/// statements in component definitions), and will link certain AST nodes to

/// their appropriate targets (e.g. goto statements, or function calls).

///

/// This visitor will not perform control-flow analysis (e.g. making sure that

/// each function actually returns) and will also not perform type checking. So

/// the linking of function calls and component instantiations will be checked

/// and linked to the appropriate definitions, but the return types and/or

        Ok(())

    }

    //--------------------------------------------------------------------------

    // ParserType visitors

    //--------------------------------------------------------------------------

    fn visit_parser_type(&mut self, ctx: &mut Ctx, id: ParserTypeId) -> VisitorResult {

        // We visit a particular type rooted in a non-ParserType node in the

        // AST. Within this function we set up a buffer to visit all nested

        // ParserType nodes.

        // The goal is to link symbolic ParserType instances to the appropriate

        // definition or symbolic type. Alternatively to throw an error if we

        // cannot resolve the ParserType to either of these (polymorphic) types.

        use ParserTypeVariant as PTV;

        debug_assert!(!self.performing_breadth_pass);

        let init_num_types = self.parser_type_buffer.len();

        self.parser_type_buffer.push(id);

        'resolve_loop: while self.parser_type_buffer.len() > init_num_types {

            let parser_type_id = self.parser_type_buffer.pop().unwrap();

            let parser_type = &ctx.heap[parser_type_id];

                PTV::Message | PTV::Bool |

                PTV::Byte | PTV::Short | PTV::Int | PTV::Long |

                PTV::String |

                PTV::IntegerLiteral | PTV::Inferred => {

                    // Builtin types or types that do not require recursion

                    continue 'resolve_loop;

                },

                PTV::Array(subtype_id) |

                PTV::Input(subtype_id) |

                PTV::Output(subtype_id) => {

                    // Requires recursing

                    self.parser_type_buffer.push(*subtype_id);

                    continue 'resolve_loop;

                },

                PTV::Symbolic(symbolic) => {

                    // Retrieve poly_vars from function/component definition to

                    // match against.

                        DefinitionType::None => unreachable!(),

                    };

                    for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {

                        if symbolic.identifier.value == poly_var.value {

                        }

                            }

                        }

                    }

                }

        Ok(())

    }

}

enum FindOfTypeResult {

    // Identifier was exactly matched, type matched as well

    Found(DefinitionId),

    // Identifier was matched, but the type differs from the expected one

    TypeMismatch(&'static str),

    // Identifier could not be found

    NotFound,

}

impl ValidityAndLinkerVisitor {

    //--------------------------------------------------------------------------

    // Special traversal

    //--------------------------------------------------------------------------

    /// Will visit a statement with a hint about its wrapping statement. This is

    /// used to distinguish block statements with a wrapping synchronous

    /// statement from normal block statements.

    fn visit_stmt_with_hint(&mut self, ctx: &mut Ctx, id: StatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {

        if let Statement::Block(block_stmt) = &ctx.heap[id] {