parent: Scope::Definition(DefinitionId::new_invalid()),

            nested: Vec::new(),

        }

    }

}

pub enum VariableKind {

    Parameter,      // in parameter list of function/component

    Local,          // declared in function/component body

    Binding,        // may be bound to in a binding expression (determined in validator/linker)

}

                                    unique_id_in_definition: -1,

                                }).upcast()

                            }

                        }

                    },

                    _ => {

                        return Err(ParseError::new_error_str_at_span(

                            &module.source, parser_type.elements[0].full_span,

                            "unexpected type in expression, note that casting expressions are not yet implemented"

                        ))

                    }

                }

                    }).upcast()

                } else if ident_text == KW_LET {

                    // Binding expression

                    let keyword_span = iter.next_span();

                    iter.consume();

                    consume_token(&module.source, iter, TokenKind::Equal)?;

                    ctx.heap.alloc_binding_expression(|this| BindingExpression{

                        this,

                        span: keyword_span,

                        bound_to,

                        bound_from,

            for _ in 0..num_embedded {

                elements.push(ParserTypeElement { full_span: array_span, variant: ParserTypeVariant::Inferred });

            }

        }

        for _ in 0..first_angle_depth {

        }

        return Ok(ParserType{ elements });

    };

    // We have a polymorphic specification. So we start by pushing the item onto

    VisitorResult

};

const VOID_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Void ];

const MESSAGE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Message, InferenceTypePart::UInt8 ];

const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];

const CHARACTER_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Character ];

const STRING_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::String ];

const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];

const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];

const ARRAY_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Array, InferenceTypePart::Unknown ];

const SLICE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Slice, InferenceTypePart::Unknown ];

    Marker(u32),

    // Completely unknown type, needs to be inferred

    Unknown,

    // Partially known type, may be inferred to to be the appropriate related 

    // type.

    // IndexLike,      // index into array/slice

    NumberLike,     // any kind of integer/float

    IntegerLike,    // any kind of integer

    ArrayLike,      // array or slice. Note that this must have a subtype

    PortLike,       // input or output port

    // Special types that cannot be instantiated by the user

    Void, // For builtin functions that do not return anything

    // Concrete types without subtypes

    Bool,

    UInt8,

    UInt16,

    UInt32,

    UInt64,

    SInt8,

    /// Checks if the type is concrete, markers are interpreted as concrete

    /// types.

    fn is_concrete(&self) -> bool {

        use InferenceTypePart as ITP;

        match self {

            _ => true

        }

    }

    fn is_concrete_number(&self) -> bool {

        use InferenceTypePart as ITP;

    fn may_be_inferred_from(&self, arg: &InferenceTypePart) -> bool {

        use InferenceTypePart as ITP;

        (*self == ITP::IntegerLike && arg.is_concrete_integer()) ||

        (*self == ITP::NumberLike && (arg.is_concrete_number() || *arg == ITP::IntegerLike)) ||

        (*self == ITP::ArrayLike && arg.is_concrete_msg_array_or_slice()) ||

    }

    /// Returns the change in "iteration depth" when traversing this particular

    /// part. The iteration depth is used to traverse the tree in a linear 

    /// fashion. It is basically `number_of_subtypes - 1`

    fn depth_change(&self) -> i32 {

        use InferenceTypePart as ITP;

        match &self {

            ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |

            ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |

            ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 |

            ITP::Character | ITP::String => {

                -1

            },

            ITP::Marker(_) |

            let converted_part = match part {

                ITP::Marker(_) => {

                    // Markers are removed when writing to the concrete type.

                    idx += 1;

                    continue;

                },

                    // Should not happen if type inferencing works correctly: we

                    // should have returned a programmer-readable error or have

                    // inferred all types.

                    unreachable!("attempted to convert inference type part {:?} into concrete type", part);

                },

                ITP::Void => CTP::Void,

                ITP::Message => CTP::Message,

                ITP::Bool => CTP::Bool,

                ITP::UInt8 => CTP::UInt8,

                ITP::UInt16 => CTP::UInt16,

                ITP::UInt32 => CTP::UInt32,

                ITP::UInt64 => CTP::UInt64,

                ITP::SInt8 => CTP::SInt8,

                if debug_log_enabled!() {

                    buffer.push_str(&format!("{{Marker:{}}}", *_marker_idx));

                }

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

            },

            ITP::Unknown => buffer.push_str("?"),

            ITP::NumberLike => buffer.push_str("numberlike"),

            ITP::IntegerLike => buffer.push_str("integerlike"),

            ITP::ArrayLike => {

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push_str("[?]");

            },

            ITP::PortLike => {

                buffer.push_str("portlike<");

                idx = Self::write_display_name(buffer, heap, parts, idx + 1);

                buffer.push('>');

            }

            ITP::Void => buffer.push_str("void"),

            ITP::Bool => buffer.push_str(KW_TYPE_BOOL_STR),

            ITP::UInt8 => buffer.push_str(KW_TYPE_UINT8_STR),

            ITP::UInt16 => buffer.push_str(KW_TYPE_UINT16_STR),

            ITP::UInt32 => buffer.push_str(KW_TYPE_UINT32_STR),

            ITP::UInt64 => buffer.push_str(KW_TYPE_UINT64_STR),

            ITP::SInt8 => buffer.push_str(KW_TYPE_SINT8_STR),

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

        let upcast_id = id.upcast();

        self.insert_initial_expr_inference_type(ctx, upcast_id)?;

        let var_expr = &ctx.heap[id];

        debug_assert!(var_expr.declaration.is_some());

        self.progress_variable_expr(ctx, id)

    }

}

impl PassTyping {

        if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }

        Ok(())

    }

    fn progress_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> Result<(), ParseError> {

    }

    fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError> {

        // Note: test expression type is already enforced

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

                // If they're all arraylike, then we want the subtype to match

                let (subtype_expr, subtype_arg1, subtype_arg2) =

                    self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 1)?;

                (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)

            },

                // Forced boolean on all

                let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;

                let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &BOOL_TEMPLATE)?;

                let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &BOOL_TEMPLATE)?;

                (progress_expr, progress_arg1, progress_arg2)

    ) -> Result<(), ParseError> {

        use ExpressionParent as EP;

        use InferenceTypePart as ITP;

        let expr = &ctx.heap[expr_id];

        let inference_type = match expr.parent() {

                // Should have been set by linker

            EP::ExpressionStmt(_) =>

                // Determined during type inference

                InferenceType::new(false, false, vec![ITP::Unknown]),

            EP::Expression(parent_id, idx_in_parent) => {

                // If we are the test expression of a conditional expression,

                // then we must resolve to a boolean

            },

        }

        // Visit the children themselves

        self.in_binding_expr_lhs = true;

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

        self.in_binding_expr_lhs = false;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 1);

        self.expr_parent = old_expr_parent;

        self.in_binding_expr = BindingExpressionId::new_invalid();

        Ok(())

    }

        Ok(())

    }

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

        let var_expr = &ctx.heap[id];

        let variable_id = match self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier) {

            Ok(variable_id) => {

                // Regular variable

                variable_id

            },

            Err(()) => {

                // Couldn't find variable, but if we're in a binding expression,

                // then this may be the thing we're binding to.

                if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, var_expr.identifier.span, "unresolved variable"

                    ));

                }

                // This is a binding variable, but it may only appear in very

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

                }

            }

            scope = &block.scope_node.parent;

            if !scope.is_block() {

use super::*;

#[test]

fn test_correct_binding() {

}

impl<'a> FunctionTester<'a> {

    fn new(ctx: TestCtx<'a>, def: &'a FunctionDefinition) -> Self {

        Self{ ctx, def }

    }

    pub(crate) fn for_variable<F: Fn(VariableTester)>(self, name: &str, f: F) -> Self {

            self.ctx.heap, self.def.body.upcast(),

            &|stmt| {

                            return true;

                        }

                    }

                }

                false

            }

        );

        assert!(

            self.ctx.test_name, name, self.assert_postfix()

        );

            self.ctx.heap, self.def.body.upcast(),

            &|expr| {

                    }

                }

                false

            }

        );

        assert!(

            self.ctx.test_name, name, self.assert_postfix()

        );

        // Construct tester and pass to tester function

        let tester = VariableTester::new(

        );

        f(tester);

        self

    }

    /// Finds a specific expression within a function. There are two matchers:

}

pub(crate) struct VariableTester<'a> {

    ctx: TestCtx<'a>,

    definition_id: DefinitionId,

    variable: &'a Variable,

}

impl<'a> VariableTester<'a> {

    fn new(

    ) -> Self {

    }

    pub(crate) fn assert_parser_type(self, expected: &str) -> Self {

        let mut serialized = String::new();

        serialize_parser_type(&mut serialized, self.ctx.heap, &self.variable.parser_type);

        self

    }

    pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {

        // Lookup concrete type in type table

        let mono_data = self.ctx.types.get_procedure_expression_data(&self.definition_id, 0);

        // Serialize and check

        let mut serialized = String::new();

        serialize_concrete_type(&mut serialized, self.ctx.heap, self.definition_id, concrete_type);

        assert_eq!(