pub(crate) poly_args: Vec<PolyArg>,

    pub(crate) is_polymorph: bool,

    pub(crate) is_pointerlike: bool,

    // TODO: @optimize

    pub(crate) monomorphs: Vec<Vec<ConcreteType>>,

}

impl DefinedType {

    fn add_monomorph(&mut self, types: Vec<ConcreteType>) {

        debug_assert!(!self.has_monomorph(&types), "monomorph already exists");

        self.monomorphs.push(types);

    }

    fn has_monomorph(&self, types: &Vec<ConcreteType>) -> bool {

        debug_assert_eq!(self.poly_args.len(), types.len(), "mismatch in number of polymorphic types");

        for monomorph in &self.monomorphs {

            if monomorph == types { return true; }

        }

        return false;

    }

}

pub enum DefinedTypeVariant {

    Enum(EnumType),

    Union(UnionType),

    Struct(StructType),

    Function(FunctionType),

    Component(ComponentType)

}

pub struct PolyArg {

    identifier: Identifier,

    /// Whether the polymorphic argument is used directly in the definition of

    /// the type (not including bodies of function/component types)

    is_in_use: bool,

}

impl DefinedTypeVariant {

    pub(crate) fn type_class(&self) -> TypeClass {

        match self {

            DefinedTypeVariant::Enum(_) => TypeClass::Enum,

            DefinedTypeVariant::Union(_) => TypeClass::Union,

            DefinedTypeVariant::Struct(_) => TypeClass::Struct,

            DefinedTypeVariant::Function(_) => TypeClass::Function,

            DefinedTypeVariant::Component(_) => TypeClass::Component

        }

    }

}

/// `EnumType` is the classical C/C++ enum type. It has various variants with

/// an assigned integer value. The integer values may be user-defined,

/// compiler-defined, or a mix of the two. If a user assigns the same enum

/// value multiple times, we assume the user is an expert and we consider both

/// variants to be equal to one another.

pub struct EnumType {

    variants: Vec<EnumVariant>,

    representation: PrimitiveType,

}

// TODO: Also support maximum u64 value

pub struct EnumVariant {

    identifier: Identifier,

    value: i64,

}

/// `UnionType` is the algebraic datatype (or sum type, or discriminated union).

/// A value is an element of the union, identified by its tag, and may contain

/// a single subtype.

pub struct UnionType {

    variants: Vec<UnionVariant>,

    tag_representation: PrimitiveType

}

pub struct UnionVariant {

    identifier: Identifier,

    parser_type: Option<ParserTypeId>,

    tag_value: i64,

}

pub struct StructType {

}

pub struct StructField {

}

pub struct FunctionType {

    pub return_type: ParserTypeId,

    pub arguments: Vec<FunctionArgument>

}

pub struct ComponentType {

    pub variant: ComponentVariant,

    pub arguments: Vec<FunctionArgument>

}

pub struct FunctionArgument {

    identifier: Identifier,

    parser_type: ParserTypeId,

}

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

// Type table

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

// TODO: @cleanup Do I really need this, doesn't make the code that much cleaner

struct TypeIterator {

    breadcrumbs: Vec<(RootId, DefinitionId)>

}

impl TypeIterator {

    fn new() -> Self {

        Self{ breadcrumbs: Vec::with_capacity(32) }

    }

    fn reset(&mut self, root_id: RootId, definition_id: DefinitionId) {

        self.breadcrumbs.clear();

        self.breadcrumbs.push((root_id, definition_id))

    }

    fn push(&mut self, root_id: RootId, definition_id: DefinitionId) {

        self.breadcrumbs.push((root_id, definition_id));

    }

    fn contains(&self, root_id: RootId, definition_id: DefinitionId) -> bool {

        for (stored_root_id, stored_definition_id) in self.breadcrumbs.iter() {

            if *stored_root_id == root_id && *stored_definition_id == definition_id { return true; }

        }

        return false

    }

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

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

use crate::protocol::parser::{

    symbol_table::*, 

    type_table::*,

    utils::*,

};

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

/// arguments will not be checked for validity.

///

/// The visitor visits each statement in a block in a breadth-first manner

/// first. We are thereby sure that we have found all variables/labels in a

/// particular block. In this phase nodes may queue statements for insertion

/// (e.g. the insertion of an `EndIf` statement for a particular `If`

/// statement). These will be inserted after visiting every node, after which

/// the visitor recurses into each statement in a block.

///

/// Because of this scheme expressions will not be visited in the breadth-first

/// pass.

pub(crate) struct ValidityAndLinkerVisitor {

    /// `in_sync` is `Some(id)` if the visitor is visiting the children of a

    /// synchronous statement. A single value is sufficient as nested

    /// synchronous statements are not allowed

    in_sync: Option<SynchronousStatementId>,

    /// `in_while` contains the last encountered `While` statement. This is used

    /// to resolve unlabeled `Continue`/`Break` statements.

    in_while: Option<WhileStatementId>,

    // Traversal state: current scope (which can be used to find the parent

    // scope), the definition variant we are considering, and whether the

    // visitor is performing breadthwise block statement traversal.

    cur_scope: Option<Scope>,

    def_type: DefinitionType,

        Ok(())

    }

    fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let select_expr = &mut ctx.heap[id];

        let expr_id = select_expr.subject;

        let old_expr_parent = self.expr_parent;

        select_expr.parent = old_expr_parent;

        self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);

        self.visit_expr(ctx, expr_id)?;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let upcast_id = id.upcast();

        let array_expr = &mut ctx.heap[id];

        let old_num_exprs = self.expression_buffer.len();

        self.expression_buffer.extend(&array_expr.elements);

        let new_num_exprs = self.expression_buffer.len();

        let old_expr_parent = self.expr_parent;

        array_expr.parent = old_expr_parent;

        for field_expr_idx in old_num_exprs..new_num_exprs {

            let field_expr_id = self.expression_buffer[field_expr_idx];

            self.expr_parent = ExpressionParent::Expression(upcast_id, field_expr_idx as u32);

            self.visit_expr(ctx, field_expr_id)?;

        }

        self.expression_buffer.truncate(old_num_exprs);

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let constant_expr = &mut ctx.heap[id];

        let old_expr_parent = self.expr_parent;

        constant_expr.parent = old_expr_parent;

        match &mut constant_expr.value {

            Literal::Null | Literal::True | Literal::False |

            Literal::Character(_) | Literal::Integer(_) => {

                // Just the parent has to be set, done above

            },

            Literal::Struct(literal) => {

                // Need to traverse fields expressions in struct

                let old_num_exprs = self.expression_buffer.len();

                self.expression_buffer.extend(literal.fields.iter().map(|v| v.value));

                let new_num_exprs = self.expression_buffer.len();

                self.expression_buffer.truncate(old_num_exprs);

            }

        }

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let call_expr = &mut ctx.heap[id];

        let num_expr_args = call_expr.arguments.len();

        // Resolve the method to the appropriate definition and check the

        // legality of the particular method call.

        // TODO: @cleanup Unify in some kind of signature call, see similar

        //  cleanup comments with this `match` format.

        let num_definition_args;

        match &mut call_expr.method {

            Method::Create => {

                num_definition_args = 1;

            },

            Method::Fires => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                        "A call to 'fires' may only occur in primitive component definitions"

                    ));

                }

                if self.in_sync.is_none() {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                        "A call to 'fires' may only occur inside synchronous blocks"

                    ));

                }

                num_definition_args = 1;

            },

            Method::Get => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                        "A call to 'get' may only occur in primitive component definitions"

                    ));

                }

                if self.in_sync.is_none() {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                        "A call to 'get' may only occur inside synchronous blocks"

                    ));

                }

                num_definition_args = 1;

            },

            Method::Put => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                        "A call to 'put' may only occur in primitive component definitions"

                    ));

                }

                if self.in_sync.is_none() {

                    return Err(ParseError2::new_error(

                        &ctx.module.source, call_expr.position,

                        "A call to 'put' may only occur inside synchronous blocks"

                    ));

                }

                num_definition_args = 2;

            }

            Method::Symbolic(symbolic) => {

                // Find symbolic method

                let (verb, expected_type) = if let ExpressionParent::New(_) = self.expr_parent {

                    // Expect to find a component

                    ("instantiated", TypeClass::Component)

                } else {

                    // Expect to find a function

                    ("called", TypeClass::Function)

                };

                    &symbolic.identifier, expected_type

                    DefinedTypeVariant::Function(definition) => {

                        num_definition_args = definition.arguments.len();

                    },

                    DefinedTypeVariant::Component(definition) => {

                        num_definition_args = definition.arguments.len();

                    }

                    _ => unreachable!(),

                }

            }

        }

        // Check the poly args and the number of variables in the call

        // expression

        self.visit_call_poly_args(ctx, id)?;

        let call_expr = &mut ctx.heap[id];

        if num_expr_args != num_definition_args {

            return Err(ParseError2::new_error(

                &ctx.module.source, call_expr.position,

                &format!(

                    "This call expects {} arguments, but {} were provided",

                    num_definition_args, num_expr_args

                )

            ));

        }

        // Recurse into all of the arguments and set the expression's parent

        let upcast_id = id.upcast();

        let old_num_exprs = self.expression_buffer.len();

        self.expression_buffer.extend(&call_expr.arguments);

        let new_num_exprs = self.expression_buffer.len();

        let old_expr_parent = self.expr_parent;

        call_expr.parent = old_expr_parent;

        for arg_expr_idx in old_num_exprs..new_num_exprs {

            let arg_expr_id = self.expression_buffer[arg_expr_idx];

            self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);

            self.visit_expr(ctx, arg_expr_id)?;

        }

        self.expression_buffer.truncate(old_num_exprs);

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {

        debug_assert!(!self.performing_breadth_pass);

        let var_expr = &ctx.heap[id];

        let variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier)?;

        let var_expr = &mut ctx.heap[id];

        var_expr.declaration = Some(variable_id);

        var_expr.parent = self.expr_parent;

        Ok(())

    }

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

    // ParserType visitors

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

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

        let old_num_types = self.parser_type_buffer.len();

        match self.visit_parser_type_without_buffer_cleanup(ctx, id) {

            Ok(_) => {

                debug_assert_eq!(self.parser_type_buffer.len(), old_num_types);

                Ok(())

            },

            Err(err) => {

                self.parser_type_buffer.truncate(old_num_types);

                Err(err)

            }

        }

    }

}

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

            let block_id = block_stmt.this;

            self.visit_block_stmt_with_hint(ctx, block_id, hint)

        } else {

            self.visit_stmt(ctx, id)

        }

    }

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

        if self.performing_breadth_pass {

            // Performing a breadth pass, so don't traverse into the statements

            // of the block.

            return Ok(())

        }

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

        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),

        });

        let old_relative_pos = self.relative_pos_in_block;

        // Copy statement IDs into buffer

        let old_num_stmts = self.statement_buffer.len();

        {

            let body = &ctx.heap[id];

            self.statement_buffer.extend_from_slice(&body.statements);

        }

        let new_num_stmts = self.statement_buffer.len();

        // Perform the breadth-first pass. Its main purpose is to find labeled

        // statements such that we can find the `goto`-targets immediately when

        // performing the depth pass

    }

    /// Finds a particular labeled statement by its identifier. Once found it

    /// will make sure that the target label does not skip over any variable

    /// declarations within the scope in which the label was found.

    fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError2> {

        debug_assert!(self.cur_scope.is_some());

        let mut scope = self.cur_scope.as_ref().unwrap();

        loop {

            debug_assert!(scope.is_block(), "scope is not a block");

            let relative_scope_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;

            let block = &ctx.heap[scope.to_block()];

            for label_id in &block.labels {

                let label = &ctx.heap[*label_id];

                if label.label.value == identifier.value {

                    for local_id in &block.locals {

                        // TODO: Better to do this in control flow analysis, it

                        //  is legal to skip over a variable declaration if it

                        //  is not actually being used. I might be missing

                        //  something here when laying out the bytecode...

                        let local = &ctx.heap[*local_id];

                        if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {

                            return Err(

                                ParseError2::new_error(&ctx.module.source, identifier.position, "This target label skips over a variable declaration")

                                    .with_postfixed_info(&ctx.module.source, label.position, "Because it jumps to this label")

                                    .with_postfixed_info(&ctx.module.source, local.position, "Which skips over this variable")

                            );

                        }

                    }

                    return Ok(*label_id);

                }

            }

            debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");

            scope = block.parent_scope.as_ref().unwrap();

            if !scope.is_block() {

                return Err(ParseError2::new_error(&ctx.module.source, identifier.position, "Could not find this label"));

            }

        }

    }

    /// Finds a particular symbol in the symbol table which must correspond to

    /// a definition of a particular type.

    // Note: root_id, symbols and types passed in explicitly to prevent

    //  borrowing errors

        identifier: &NamespacedIdentifier, expected_type_class: TypeClass

        // Find symbol associated with identifier

        }

    }

    /// This function will check if the provided while statement ID has a block

    /// statement that is one of our current parents.

    fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {

        debug_assert!(self.cur_scope.is_some());

        let mut scope = self.cur_scope.as_ref().unwrap();

        let while_stmt = &ctx.heap[id];

        loop {

            debug_assert!(scope.is_block());

            let block = scope.to_block();

            if while_stmt.body == block.upcast() {

                return true;

            }

            let block = &ctx.heap[block];

            debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");

            scope = block.parent_scope.as_ref().unwrap();

            if !scope.is_block() {

                return false;

            }

        }

    }

    /// This function should be called while dealing with break/continue

    /// statements. It will try to find the targeted while statement, using the

    /// target label if provided. If a valid target is found then the loop's

    /// ID will be returned, otherwise a parsing error is constructed.

    /// The provided input position should be the position of the break/continue

    /// statement.

    fn resolve_break_or_continue_target(&self, ctx: &Ctx, position: InputPosition, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError2> {

        let target = match label {

            Some(label) => {

                let target_id = self.find_label(ctx, label)?;

                // Make sure break target is a while statement

                let target = &ctx.heap[target_id];

                if let Statement::While(target_stmt) = &ctx.heap[target.body] {

                    // Even though we have a target while statement, the break might not be

                    // present underneath this particular labeled while statement

                    if !self.has_parent_while_scope(ctx, target_stmt.this) {

                        ParseError2::new_error(&ctx.module.source, label.position, "Break statement is not nested under the target label's while statement")

                            .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here");

                    }

                    target_stmt.this

                } else {

                    return Err(

                    }

                }

            }

        };

        // We allow zero polyargs to imply all args are inferred. Otherwise the

        // number of arguments must be equal

        if call_expr.poly_args.is_empty() {

            if num_expected_poly_args != 0 {

                // Infer all polyargs

                // TODO: @cleanup Not nice to use method position as implicitly

                //  inferred parser type pos.

                let pos = call_expr.position();

                for _ in 0..num_expected_poly_args {

                    self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType {

                        this,

                        pos,

                        variant: ParserTypeVariant::Inferred,

                    }));

                }

                let call_expr = &mut ctx.heap[call_id];

                call_expr.poly_args.reserve(num_expected_poly_args);

                for _ in 0..num_expected_poly_args {

                    call_expr.poly_args.push(self.parser_type_buffer.pop().unwrap());

                }

            }

            Ok(())

        } else if call_expr.poly_args.len() == num_expected_poly_args {

            // Number of args is not 0, so parse all the specified ParserTypes

            let old_num_types = self.parser_type_buffer.len();

            self.parser_type_buffer.extend(&call_expr.poly_args);

            while self.parser_type_buffer.len() > old_num_types {

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

                self.visit_parser_type(ctx, parser_type_id)?;

            }

            self.parser_type_buffer.truncate(old_num_types);

            Ok(())

        } else {

            return Err(ParseError2::new_error(

                &ctx.module.source, call_expr.position,

                &format!(

                    "Expected {} polymorphic arguments (or none, to infer them), but {} were specified",

                    num_expected_poly_args, call_expr.poly_args.len()

                )

            ));

        }

    }

}