let field_span = field.identifier.span;

                        let literal = ctx.heap[id].value.as_struct();

                        let ast_definition = &ctx.heap[literal.definition];

                        return Err(ParseError::new_error_at_span(

                            &ctx.module.source, field_span, format!(

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

                                ast_definition.identifier().value.as_str()

                            )

                        ));

                    }

                    field.field_idx = field_idx.unwrap();

                    // Check if specified more than once

                    if specified[field.field_idx] {

                        return Err(ParseError::new_error_str_at_span(

                            &ctx.module.source, field.identifier.span,

                            "This field is specified more than once"

                        ));

                    }

                    specified[field.field_idx] = true;

                }

                if !specified.iter().all(|v| *v) {

                    // Some fields were not specified

                    let mut not_specified = String::new();

                    let mut num_not_specified = 0;

                    for (def_field_idx, is_specified) in specified.iter().enumerate() {

                        if !is_specified {

                            if !not_specified.is_empty() { not_specified.push_str(", ") }

                            let field_ident = &struct_definition.fields[def_field_idx].identifier;

                            not_specified.push_str(field_ident.value.as_str());

                            num_not_specified += 1;

                        }

                    }

                    debug_assert!(num_not_specified > 0);

                    let msg = if num_not_specified == 1 {

                        format!("not all fields are specified, '{}' is missing", not_specified)

                    } else {

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

                    };

                    return Err(ParseError::new_error_at_span(

                        &ctx.module.source, literal.parser_type.full_span, msg

                    ));

                }

                // Need to traverse fields expressions in struct and evaluate

                // the poly args

                let mut expr_section = self.expression_buffer.start_section();

                for field in &literal.fields {

                    expr_section.push(field.value);

                }

                for expr_idx in 0..expr_section.len() {

                    let expr_id = expr_section[expr_idx];

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

                    self.visit_expr(ctx, expr_id)?;

                }

                expr_section.forget();

            },

            Literal::Enum(literal) => {

                // Make sure the variant exists

                let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();

                let enum_definition = type_definition.definition.as_enum();

                let variant_idx = enum_definition.variants.iter().position(|v| {

                    v.identifier == literal.variant

                });

                if variant_idx.is_none() {

                    let literal = ctx.heap[id].value.as_enum();

                    let ast_definition = ctx.heap[literal.definition].as_enum();

                    return Err(ParseError::new_error_at_span(

                        &ctx.module.source, literal.parser_type.full_span, format!(

                            "the variant '{}' does not exist on the enum '{}'",

                            literal.variant.value.as_str(), ast_definition.identifier.value.as_str()

                        )

                    ));

                }

                literal.variant_idx = variant_idx.unwrap();

            },

            Literal::Union(literal) => {

                // Make sure the variant exists

                let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();

                let union_definition = type_definition.definition.as_union();

                let variant_idx = union_definition.variants.iter().position(|v| {

                    v.identifier == literal.variant

                });

                if variant_idx.is_none() {

                    let literal = ctx.heap[id].value.as_union();

                    let ast_definition = ctx.heap[literal.definition].as_union();

                    return Err(ParseError::new_error_at_span(

                        &ctx.module.source, literal.parser_type.full_span, format!(

                            "the variant '{}' does not exist on the union '{}'",

                            literal.variant.value.as_str(), ast_definition.identifier.value.as_str()

                        )

                    ));

                }

                literal.variant_idx = variant_idx.unwrap();

                // Make sure the number of specified values matches the expected

                // number of embedded values in the union variant.

                let union_variant = &union_definition.variants[literal.variant_idx];

                if union_variant.embedded.len() != literal.values.len() {

                    let literal = ctx.heap[id].value.as_union();

                    let ast_definition = ctx.heap[literal.definition].as_union();

                    return Err(ParseError::new_error_at_span(

                        &ctx.module.source, literal.parser_type.full_span, format!(

                            "The variant '{}' of union '{}' expects {} embedded values, but {} were specified",

                            literal.variant.value.as_str(), ast_definition.identifier.value.as_str(),

                            union_variant.embedded.len(), literal.values.len()

                        ),

                    ))

                }

                // Traverse embedded values of union (if any) and evaluate the

                // polymorphic arguments

                let upcast_id = id.upcast();

                let mut expr_section = self.expression_buffer.start_section();

                for value in &literal.values {

                    expr_section.push(*value);

                }

                for expr_idx in 0..expr_section.len() {

                    let expr_id = expr_section[expr_idx];

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

                    self.visit_expr(ctx, expr_id)?;

                }

                expr_section.forget();

            },

            Literal::Array(literal) => {

                // Visit all expressions in the array

                let upcast_id = id.upcast();

                let expr_section = self.expression_buffer.start_section_initialized(literal);

                for expr_idx in 0..expr_section.len() {

                    let expr_id = expr_section[expr_idx];

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

                    self.visit_expr(ctx, expr_id)?;

                }

                expr_section.forget();

            }

        }

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {

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

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module.source, span, "cannot assign to the result from a cast expression"

            ))

        }

        let upcast_id = id.upcast();

        let old_expr_parent = self.expr_parent;

        cast_expr.parent = old_expr_parent;

        cast_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        // Recurse into the thing that we're casting

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

        let subject_id = cast_expr.subject;

        self.visit_expr(ctx, subject_id)?;

        self.expr_parent = old_expr_parent;

        Ok(())

    }

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

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

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module.source, span, "cannot assign to the result from a call expression"

            ))

        }

        // Check whether the method is allowed to be called within the code's

        // context (in sync, definition type, etc.)

        let mut expected_wrapping_new_stmt = false;

        match &mut call_expr.method {

            Method::Get => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

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

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

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

                    ));

                }

            },

            Method::Put => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

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

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

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

                    ));

                }

            },

            Method::Fires => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

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

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

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

                    ));

                }

            },

            Method::Create => {},

            Method::Length => {},

            Method::Assert => {

                if self.def_type.is_function() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

                        "assert statement may only occur in components"

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, call_expr.func_span,

                        "assert statements may only occur inside synchronous blocks"

                    ));

                }

            },

            Method::UserFunction => {},

            Method::UserComponent => {

                expected_wrapping_new_stmt = true;

            },

        }

        if expected_wrapping_new_stmt {

            if !self.expr_parent.is_new() {

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module.source, call_expr.func_span,

                    "cannot call a component, it can only be instantiated by using 'new'"

                ));

            }

        } else {

            if self.expr_parent.is_new() {

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module.source, call_expr.func_span,

                    "only components can be instantiated, this is a function"

                ));

            }

        }

        // Check the number of arguments

        let call_definition = ctx.types.get_base_definition(&call_expr.definition).unwrap();

        let num_expected_args = match &call_definition.definition {

            DefinedTypeVariant::Function(definition) => definition.arguments.len(),

            DefinedTypeVariant::Component(definition) => definition.arguments.len(),

            v => unreachable!("encountered {} type in call expression", v.type_class()),

        };

        let num_provided_args = call_expr.arguments.len();

        if num_provided_args != num_expected_args {

            let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };

            return Err(ParseError::new_error_at_span(

                &ctx.module.source, call_expr.full_span, format!(

                    "expected {} {}, but {} were provided",

                    num_expected_args, argument_text, num_provided_args

                )

            ));

        }

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

        let upcast_id = id.upcast();

        let section = self.expression_buffer.start_section_initialized(&call_expr.arguments);

        let old_expr_parent = self.expr_parent;

        call_expr.parent = old_expr_parent;

        call_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        for arg_expr_idx in 0..section.len() {

            let arg_expr_id = section[arg_expr_idx];

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

            self.visit_expr(ctx, arg_expr_id)?;

        }

        section.forget();

        self.expr_parent = old_expr_parent;

        Ok(())

    }

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

        let var_expr = &ctx.heap[id];

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

            Ok(variable_id) => {

                // Regular variable

                (variable_id, false)

            },

            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

                // specific locations.

                let is_valid_binding = match self.expr_parent {

                    ExpressionParent::Expression(expr_id, idx) => {

                        match &ctx.heap[expr_id] {

                            Expression::Binding(_binding_expr) => {

                                // Nested binding is disallowed, and because of

                                // the check above we know we're directly at the

                                // LHS of the binding expression

                                debug_assert_eq!(_binding_expr.this, self.in_binding_expr);

                                debug_assert_eq!(idx, 0);

                                true

                            }

                            Expression::Literal(lit_expr) => {

                                // Only struct, unions and arrays can have

                                // subexpressions, so we're always fine

                                if cfg!(debug_assertions) {

                                    match lit_expr.value {

                                        Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) => {},

                                        _ => unreachable!(),

                                    }

                                }

                                true

                            },

                            _ => false,

                        }

                    },

                    _ => {

                        false

                    }

                };

                if !is_valid_binding {

                    let binding_expr = &ctx.heap[self.in_binding_expr];

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module.source, var_expr.identifier.span,

                        "illegal location for binding variable: binding variables may only be nested under a binding expression, or a struct, union or array literal"

                    ).with_info_at_span(

                        &ctx.module.source, binding_expr.operator_span, format!(

                            "'{}' was interpreted as a binding variable because the variable is not declared and it is nested under this binding expression",

                            var_expr.identifier.value.as_str()

                        )

                    ));

                }

                // By now we know that this is a valid binding expression. Given

                // that a binding expression must be nested under an if/while

                // statement, we now add the variable to the (implicit) block

                // statement following the if/while statement.

                let bound_identifier = var_expr.identifier.clone();

                let bound_variable_id = ctx.heap.alloc_variable(|this| Variable{

                    this,

                    kind: VariableKind::Binding,

                    parser_type: ParserType{

                        elements: vec![ParserTypeElement{

                            element_span: bound_identifier.span,

                            variant: ParserTypeVariant::Inferred

                        }],

                        full_span: bound_identifier.span

                    },

                    identifier: bound_identifier,

                    relative_pos_in_block: 0,

                    unique_id_in_scope: -1,

                });

                let body_stmt_id = match &ctx.heap[self.in_test_expr] {

                    Statement::If(stmt) => stmt.true_body,

                    Statement::While(stmt) => stmt.body,

                    _ => unreachable!(),

                };

                let body_scope = Scope::Regular(body_stmt_id);

                self.checked_at_single_scope_add_local(ctx, body_scope, 0, bound_variable_id)?;

                (bound_variable_id, true)

            }

        };

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

        var_expr.declaration = Some(variable_id);

        var_expr.used_as_binding_target = is_binding_target;

        var_expr.parent = self.expr_parent;

        var_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        Ok(())

    }

}

impl PassValidationLinking {

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

    // Special traversal

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

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

        // 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 old_scope = self.cur_scope.clone();

        let new_scope = match hint {

            Some(sync_id) => Scope::Synchronous((sync_id, id)),

            None => Scope::Regular(id),

        };

        match old_scope {

            Scope::Definition(_def_id) => {

                // Don't do anything. Block is implicitly a child of a

                // definition scope.

                if cfg!(debug_assertions) {

                    match &ctx.heap[_def_id] {

                        Definition::Function(proc_def) => debug_assert_eq!(proc_def.body, id),

                        Definition::Component(proc_def) => debug_assert_eq!(proc_def.body, id),

                        _ => unreachable!(),

                    }

                }

            },

            Scope::Regular(block_id) | Scope::Synchronous((_, block_id)) => {

                let parent_block = &mut ctx.heap[block_id];

                parent_block.scope_node.nested.push(new_scope);

            }

        }

        self.cur_scope = new_scope;

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

        body.scope_node.parent = old_scope;

        body.relative_pos_in_parent = self.relative_pos_in_block;

        let end_block_id = body.end_block;

        let old_relative_pos = self.relative_pos_in_block;

        // Copy statement IDs into buffer

        let statement_section = self.statement_buffer.start_section_initialized(&body.statements);

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

    );

    Tester::new_single_source_expect_ok(

        "explicit single polymorph",

        "

        enum Foo<T>{ A }

        func bar() -> Foo<s32> { return Foo::A; }

        "

    );

    Tester::new_single_source_expect_ok(

        "explicit multi-polymorph",

        "

        enum Foo<A, B>{ A, B }

        func bar() -> Foo<s8, s32> { return Foo::B; }

        "

    );

}

#[test]

fn test_incorrect_enum_instance() {

    Tester::new_single_source_expect_err(

        "variant name reuse",

        "

        enum Foo { A, A }

        func bar() -> Foo { return Foo::A; }

        "

    ).error(|e| { e

        .assert_num(2)

        .assert_occurs_at(0, "A }")

        .assert_msg_has(0, "defined more than once")

        .assert_occurs_at(1, "A, ")

        .assert_msg_has(1, "other enum variant is defined here");

    });

    Tester::new_single_source_expect_err(

        "undefined variant",

        "

        enum Foo { A }

        func bar() -> Foo { return Foo::B; }

        "

    ).error(|e| { e

        .assert_num(1)

        .assert_msg_has(0, "variant 'B' does not exist on the enum 'Foo'");

    });

}

#[test]

fn test_correct_union_instance() {

    Tester::new_single_source_expect_ok(

        "single tag",

        "

        union Foo { A }

        func bar() -> Foo { return Foo::A; }

        "

    );

    Tester::new_single_source_expect_ok(

        "multiple tags",

        "

        union Foo { A, B }

        func bar() -> Foo { return Foo::B; }

        "

    );

    Tester::new_single_source_expect_ok(

        "single embedded",

        "

        union Foo { A(s32) }

        func bar() -> Foo { return Foo::A(5); }

        "

    );

    Tester::new_single_source_expect_ok(

        "multiple embedded",

        "

        union Foo { A(s32), B(s8) }

        func bar() -> Foo { return Foo::B(2); }

        "

    );

    Tester::new_single_source_expect_ok(

        "multiple values in embedded",

        "

        union Foo { A(s32, s8) }

        func bar() -> Foo { return Foo::A(0, 2); }

        "

    );

    Tester::new_single_source_expect_ok(

        "mixed tag/embedded",

        "

        union OptionInt { None, Some(s32) }

        func bar() -> OptionInt { return OptionInt::Some(3); }

        "

    );

    Tester::new_single_source_expect_ok(

        "single polymorphic var",

        "

        union Option<T> { None, Some(T) }

        func bar() -> Option<s32> { return Option::Some(3); }"

    );

    Tester::new_single_source_expect_ok(

        "multiple polymorphic vars",

        "

        union Result<T, E> { Ok(T), Err(E), }

        func bar() -> Result<s32, s8> { return Result::Ok(3); }

        "

    );

    Tester::new_single_source_expect_ok(

        "multiple polymorphic in one variant",

        "

        union MaybePair<T1, T2>{ None, Some(T1, T2) }

        func bar() -> MaybePair<s8, s32> { return MaybePair::Some(1, 2); }

        "

    );

}

#[test]

fn test_incorrect_union_instance() {

    Tester::new_single_source_expect_err(

        "tag-variant name reuse",

        "

        union Foo{ A, A }

        "

    ).error(|e| { e

        .assert_num(2)

        .assert_occurs_at(0, "A }")

        .assert_msg_has(0, "union variant is defined more than once")

        .assert_occurs_at(1, "A, ")

        .assert_msg_has(1, "other union variant");

    });

    Tester::new_single_source_expect_err(

        "embedded-variant name reuse",

        "

        union Foo{ A(s32), A(s8) }

        "

    ).error(|e| { e 

        .assert_num(2)

        .assert_occurs_at(0, "A(s8)")

        .assert_msg_has(0, "union variant is defined more than once")

        .assert_occurs_at(1, "A(s32)")

        .assert_msg_has(1, "other union variant");

    });

    Tester::new_single_source_expect_err(

        "undefined variant",

        "

        union Silly{ Thing(s8) }

        func bar() -> Silly { return Silly::Undefined(5); }

        "

    ).error(|e| { e

        .assert_msg_has(0, "variant 'Undefined' does not exist on the union 'Silly'");

    });

    Tester::new_single_source_expect_err(

        "using tag instead of embedded",

        "

        union Foo{ A(s32) }

        func bar() -> Foo { return Foo::A; }

        "

    ).error(|e| { e

        .assert_msg_has(0, "variant 'A' of union 'Foo' expects 1 embedded values, but 0 were");

    });

    Tester::new_single_source_expect_err(

        "using embedded instead of tag",

        "

        union Foo{ A }

        func bar() -> Foo { return Foo::A(3); }

        "

    ).error(|e| { e 

        .assert_msg_has(0, "The variant 'A' of union 'Foo' expects 0");

    });

    Tester::new_single_source_expect_err(

        "wrong embedded value",

        "

        union Foo{ A(s32) }

        func bar() -> Foo { return Foo::A(false); }

        "

    ).error(|e| { e

        .assert_occurs_at(0, "Foo::A")

        .assert_msg_has(0, "failed to fully resolve")

        .assert_occurs_at(1, "false")

        .assert_msg_has(1, "has been resolved to 's32'")

        .assert_msg_has(1, "has been resolved to 'bool'");

    });

}