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

pub struct Identifier {

    pub position: InputPosition,

    pub value: Vec<u8>

}

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

pub struct NamespacedIdentifier {

    pub position: InputPosition,

    pub num_namespaces: u8,

    pub value: Vec<u8>,

}

impl PartialEq for NamespacedIdentifier {

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

        return self.value == other.value

    }

}

// TODO: Just keep ref to NamespacedIdentifier

pub(crate) struct NamespacedIdentifierIter<'a> {

    value: &'a Vec<u8>,

    cur_offset: usize,

    num_returned: u8,

    False,

    Character(LiteralCharacter),

    Integer(LiteralInteger),

    Struct(LiteralStruct),

}

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

pub struct LiteralStructField {

    // Phase 1: parser

    pub(crate) identifier: Identifier,

    pub(crate) value: ExpressionId,

    // Phase 2: linker

    fn parent_scope(&self, _h: &Heap) -> Option<Scope> {

        None

    }

    fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {

        for &parameter_id in self.parameters().iter() {

            let parameter = &h[parameter_id];

                return Some(parameter_id.0);

            }

        }

        None

    }

}

    fn parent_scope(&self, _h: &Heap) -> Option<Scope> {

        self.parent_scope.clone()

    }

    fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {

        for local_id in self.locals.iter() {

            let local = &h[*local_id];

                return Some(local_id.0);

            }

        }

        None

    }

}

                let val = self.kv(indent2).with_s_key("Value");

                match &expr.value {

                    Literal::Null => { val.with_s_val("null"); },

                    Literal::True => { val.with_s_val("true"); },

                    Literal::False => { val.with_s_val("false"); },

                }

                self.kv(indent2).with_s_key("Parent")

                    .with_custom_val(|v| write_expression_parent(v, &expr.parent));

                self.kv(indent2).with_s_key("ConcreteType")

                    .with_custom_val(|v| write_concrete_type(v, heap, def_id, &expr.concrete_type));

                        self.kv(indent3).with_s_key("Name").with_ascii_val(&symbolic.identifier.value);

                        self.kv(indent3).with_s_key("Definition")

                            .with_opt_disp_val(symbolic.definition.as_ref().map(|v| &v.index));

                    }

                }

                // Arguments

                self.kv(indent2).with_s_key("Arguments");

                for arg_id in &expr.arguments {

                    self.write_expr(heap, *arg_id, indent3);

                }

                    Value::Int(IntValue(val as i32))

                } else {

                    Value::Long(LongValue(val))

                }

            }

            Literal::Character(_data) => unimplemented!(),

        }

    }

    fn set(&mut self, index: &Value, value: &Value) -> Option<Value> {

        // The index must be of integer type, and non-negative

        let the_index: usize;

        match index {

            had_comma = self.source.next() == Some(b',');

            if had_comma {

                self.source.consume();

                if self.consume_whitespace(false).is_err() { return false; }

            }

        }

    }

    fn consume_ident(&mut self) -> Result<Vec<u8>, ParseError2> {

        if !self.has_identifier() {

            return Err(self.error_at_pos("Expected identifier"));

        }

        let mut result = Vec::new();

    /// input position will stay where it is. If no polymorphic variables are

    /// present then an empty vector will be returned.

    fn consume_polymorphic_vars(&mut self, h: &mut Heap) -> Result<Vec<Identifier>, ParseError2> {

        let backup_pos = self.source.pos();

        match self.consume_comma_separated(

            h, b'<', b'>', "Expected the end of the polymorphic variable list",

        )? {

            Some(poly_vars) => Ok(poly_vars),

            None => {

                self.source.seek(backup_pos);

                Ok(vec!())

            }

            self.consume_whitespace(false)?;

            let next = self.source.next();

            if Some(b'{') == next {

                let symbols = match self.consume_comma_separated(

                    h, b'{', b'}', "Expected end of import list",

                        // Symbol name

                        let position = lexer.source.pos();

                        let name = lexer.consume_ident()?;

                        lexer.consume_whitespace(false)?;

                        // Symbol alias

    fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {

        recursive_statement(self, h, stmt)

    }

    fn visit_local_statement(&mut self, h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {

        recursive_local_statement(self, h, stmt)

    }

        Ok(())

    }

    fn visit_channel_statement(

        &mut self,

        _h: &mut Heap,

        _stmt: ChannelStatementId,

            ResolveLabels::check_duplicate_impl(h, h[block].parent_block(h), stmt)?;

            // For the current block, check for a duplicate.

            for &other_stmt in h[block].labels.iter() {

                if other_stmt == stmt {

                    continue;

                } else {

                        return Err((h[stmt].position, "Duplicate label".to_string()));

                    }

                }

            }

        }

        Ok(())

        id: &Identifier,

    ) -> Option<LabeledStatementId> {

        if let Some(block) = block {

            // It does not matter in what order we find the labels.

            // If there are duplicates: that is checked elsewhere.

            for &stmt in h[block].labels.iter() {

                    return Some(stmt);

                }

            }

            if let Some(stmt) = ResolveLabels::find_target(h, h[block].parent_block(h), id) {

                return Some(stmt);

            }

        debug_log!("Array expr ({} elements): {}", expr_elements.len(), upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

        // All elements should have an equal type

        let progress = self.apply_equal_n_constraint(ctx, upcast_id, &expr_elements)?;

        for (progress_arg, arg_id) in progress.iter().zip(expr_elements.iter()) {

            if *progress_arg {

                self.queue_expr(*arg_id);

            }

        }

        // And the output should be an array of the element types

        let mut expr_progress = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;

        Ok(())

    }

    fn progress_constant_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError2> {

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        };

        let progress = self.apply_forced_constraint(ctx, upcast_id, template)?;

        if progress { self.queue_expr_parent(ctx, upcast_id); }

        Ok(())

            // Let a linked port know that our type has updated

            if let Some(linked_id) = var_data.linked_var {

                // Only perform one-way inference to prevent updating our type, this

                // would lead to an inconsistency

                let var_type: *mut _ = &mut var_data.var_type;

                debug_assert!(

                    unsafe{&*var_type}.parts[0] == InferenceTypePart::Input ||

                    unsafe{&*var_type}.parts[0] == InferenceTypePart::Output

                );

                debug_assert!(

            }

            Method::Symbolic(symbolic) => {

                let definition = &ctx.heap[symbolic.definition.unwrap()];

                match definition {

                    Definition::Component(definition) => {

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

                        for param_id in definition.parameters.clone() {

                            let param = &ctx.heap[param_id];

                            let param_parser_type_id = param.parser_type;

                            parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));

                        }

                        (parameter_types, InferenceType::new(false, true, vec![InferenceTypePart::Void]))

                    },

                    Definition::Function(definition) => {

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

                        for param_id in definition.parameters.clone() {

                            let param = &ctx.heap[param_id];

                            let param_parser_type_id = param.parser_type;

                            parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));

                        }

            poly_vars,

            embedded: embedded_types,

            returned: return_type

        });

    }

    /// Determines the initial InferenceType from the provided ParserType. This

    /// may be called with two kinds of intentions:

    /// 1. To resolve a ParserType within the body of a function, or on

    ///     polymorphic arguments to calls/instantiations within that body. This

    ///     means that the polymorphic variables are known and can be replaced

    ///     with the monomorph we're instantiating.

                // don't care about monomorphs yet.

                PTV::Symbolic(symbolic) => {

                    // Check if the symbolic type is one of the definition's

                    // polymorphic arguments. If so then we can halt the

                    // execution

                    for (poly_arg_idx, poly_arg) in poly_vars.iter().enumerate() {

                            set_resolve_result(ResolveResult::PolyArg(poly_arg_idx));

                            continue 'resolve_loop;

                        }

                    }

                    // Lookup the definition in the symbol table

                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() {

                            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");

        &self, ctx: &TypeCtx, root_id: RootId, items: &[T], getter: F, item_name: &'static str

    ) -> Result<(), ParseError2> {

        for (item_idx, item) in items.iter().enumerate() {

            let item_ident = getter(item);

            for other_item in &items[0..item_idx] {

                let other_item_ident = getter(other_item);

                    let module_source = &ctx.modules[root_id.index as usize].source;

                    return Err(ParseError2::new_error(

                        module_source, item_ident.position, &format!("This {} is defined more than once", item_name)

                    ).with_postfixed_info(

                        module_source, other_item_ident.position, &format!("The other {} is defined here", item_name)

                    ));

        &self, ctx: &TypeCtx, root_id: RootId, poly_args: &[Identifier]

    ) -> Result<(), ParseError2> {

        // Make sure polymorphic arguments are unique and none of the

        // identifiers conflict with any imported scopes

        for (arg_idx, poly_arg) in poly_args.iter().enumerate() {

            for other_poly_arg in &poly_args[..arg_idx] {

                    let module_source = &ctx.modules[root_id.index as usize].source;

                    return Err(ParseError2::new_error(

                        module_source, poly_arg.position,

                        "This polymorphic argument is defined more than once"

                    ).with_postfixed_info(

                        module_source, other_poly_arg.position,

                for field in &mut literal.fields {

                    // Find field in the struct definition

                    field.field_idx = FIELD_NOT_FOUND_SENTINEL;

                    for (def_field_idx, def_field) in definition.fields.iter().enumerate() {

                        if field.identifier == def_field.identifier {

                            field.field_idx = def_field_idx;

                            break;

                        }

                    }

                    // Check if not found

                    if field.field_idx == FIELD_NOT_FOUND_SENTINEL {

                        return Err(ParseError2::new_error(

                            &format!(

                                "This field does not exist on the struct '{}'",

                                &String::from_utf8_lossy(&literal.identifier.value),

                            )

                        ));

                    }

                    // Check if specified more than once

                    if specified[field.field_idx] {

                        return Err(ParseError2::new_error(

                            "This field is specified more than once"

                        ));

                    }

                    specified[field.field_idx] = true;

                }

                    return Err(ParseError2::new_error(

                        &ctx.module.source, literal.identifier.position,

                        &format!("Not all fields are specified, [{}] are missing", not_specified)

                    ));

                }

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

                for expr_idx in old_num_exprs..new_num_exprs {

                    let expr_id = self.expression_buffer[expr_idx];

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

                }

                self.expression_buffer.truncate(old_num_exprs);

            }

        }

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

                    ));

                }

                num_definition_args = 2;

            }

            Method::Symbolic(symbolic) => {

                    // Expect to find a component

                } else {

                    // Expect to find a function

                };

                let definition = self.find_symbol_of_type(

                    &ctx.module.source, ctx.module.root_id, &ctx.symbols, &ctx.types,

                    &symbolic.identifier, expected_type

                )?;

                symbolic.definition = Some(definition.ast_definition);

                    DefinedTypeVariant::Function(definition) => {

                        num_definition_args = definition.arguments.len();

                    },

                    DefinedTypeVariant::Component(definition) => {

                        num_definition_args = definition.arguments.len();

                    }

                        DefinitionType::Composite(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                        DefinitionType::Function(id) => (id.upcast(), &ctx.heap[id].poly_vars),

                    };

                    let mut symbolic_variant = None;

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

                            // Type refers to a polymorphic variable.

                            // TODO: @hkt Maybe allow higher-kinded types?

                            if !symbolic.poly_args.is_empty() {

                                return Err(ParseError2::new_error(

                                    &ctx.module.source, symbolic.identifier.position,

                                    "Polymorphic arguments to a polymorphic variable (higher-kinded types) are not allowed (yet)"

                        (symbolic.identifier.position, symbolic_variant, 0)

                    } else {

                        // Must be a user-defined type, otherwise an error

                        let found_type = find_type_definition(

                            &ctx.symbols, &ctx.types, ctx.module.root_id, &symbolic.identifier

                        ).as_parse_error(&ctx.module.source)?;

                        // TODO: @function_ptrs: Allow function pointers at some

                        //  point in the future

                        if found_type.definition.type_class().is_proc_type() {

                            return Err(ParseError2::new_error(

                                &ctx.module.source, symbolic.identifier.position,

                let other_local = &ctx.heap[*other_local_id];

                // Position check in case another variable with the same name

                // is defined in a higher-level scope, but later than the scope

                // in which the current variable resides.

                if local.this != *other_local_id &&

                    local_relative_pos >= other_local.relative_pos_in_block &&

                    // Collision within this scope

                    return Err(

                        ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable")

                            .with_postfixed_info(&ctx.module.source, other_local.position, "Previous variable is found here")

                    );

                }

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

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

            if let Scope::Definition(definition_id) = scope {

                // At outer scope, check parameters of function/component

                for parameter_id in ctx.heap[*definition_id].parameters() {

                    let parameter = &ctx.heap[*parameter_id];

                        return Err(

                            ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter")

                                .with_postfixed_info(&ctx.module.source, parameter.position, "Parameter definition is found here")

                        );

                    }

                }

            debug_assert!(scope.is_block());

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

            for local_id in &block.locals {

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

                    return Ok(local_id.upcast());

                }

            }

            debug_assert!(block.parent_scope.is_some());

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

                // Definition scope, need to check arguments to definition

                match scope {

                    Scope::Definition(definition_id) => {

                        let definition = &ctx.heap[*definition_id];

                        for parameter_id in definition.parameters() {

                            let parameter = &ctx.heap[*parameter_id];

                                return Ok(parameter_id.upcast());

                            }

                        }

                    },

                    _ => unreachable!(),

                }

        loop {

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

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

            for other_label_id in &block.labels {

                let other_label = &ctx.heap[*other_label_id];

                    // Collision

                    return Err(

                        ParseError2::new_error(&ctx.module.source, label.position, "Label name conflicts with another label")

                            .with_postfixed_info(&ctx.module.source, other_label.position, "Other label is found here")

                    );

                }

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

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

            }

        }

        Ok(target)

    }

    fn visit_call_poly_args(&mut self, ctx: &mut Ctx, call_id: CallExpressionId) -> VisitorResult {

        let call_expr = &ctx.heap[call_id];

        // Determine the polyarg signature

        let num_expected_poly_args = match &call_expr.method {

            Method::Create => {

            ));

        }

    }

    fn visit_literal_poly_args(&mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId) -> VisitorResult {

        let literal_expr = &ctx.heap[lit_id];

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

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

                // Not really an error, but a programmer error as we're likely

                // doing work twice

                debug_assert!(false, "called visit_literal_poly_args on a non-polymorphic literal");

                unreachable!();

                    Definition::Struct(definition) => definition.poly_vars.len(),

                    _ => {

                        debug_assert!(false, "expected struct literal while visiting literal poly args");

                        unreachable!();

                    }

                };

            }

        };

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

                    }));

                }

            }

        }

    }

}