impl PartialEq for Identifier {

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

        return self.value == other.value

    }

}

    }

}

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

pub enum NamespacedIdentifierPart {

    // Regular identifier

/// we allow each identifier to be followed by polymorphic arguments during the 

/// parsing phase (e.g. Foo<A,B>::Bar<C,D>::Qux). But in our current language 

/// implementation we can only have valid namespaced identifier that contain one

/// set of polymorphic arguments at the appropriate position.

/// TODO: @tokens Reimplement/rename once we have a tokenizer

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

    pub position: InputPosition,

    pub value: Vec<u8>, // Full name as it resides in the input source

    pub poly_args: Vec<ParserTypeId>, // All poly args littered throughout the namespaced identifier

    pub parts: Vec<NamespacedIdentifierPart>, // Indices into value/poly_args

}

    /// Returns the identifier value without any of the specific polymorphic

    /// arguments.

    pub fn strip_poly_args(&self) -> Vec<u8> {

        debug_assert!(!self.parts.is_empty() && self.parts[0].is_identifier());

        let mut result = Vec::with_capacity(self.value.len());

        }

        result

    }

    /// Returns an iterator of the elements in the namespaced identifier

            identifier: self,

            element_idx: 0

        }

    }

    pub fn get_poly_args(&self) -> Option<&[ParserTypeId]> {

    }

}

/// Iterator over elements of the namespaced identifier. The element index will

/// only ever be at the start of an identifier element.

#[derive(Debug)]

    element_idx: usize,

}

    type Item = (&'a [u8], Option<&'a [ParserTypeId]>);

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

        match self.get(self.element_idx) {

            Some((ident, poly)) => {

                self.element_idx += 1;

                if poly.is_some() {

            },

            None => None

        }

    }

}

    /// Returns number of parts iterated over, may not correspond to number of

    /// times one called `next()` because returning an identifier with 

    /// polymorphic arguments increments the internal counter by 2.

    pub fn num_returned(&self) -> usize {

        return self.element_idx;

    }

            None => None,

            Some(idx) => self.get(idx)

        }

    }

}

/// TODO: @types Remove the Message -> Byte hack at some point...

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

pub enum ParserTypeVariant {

    // Basic builtin

    Message,

    Bool,

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

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

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

    pub poly_args2: Vec<ParserTypeId>, // taken from identifier or inferred

    pub variant: Option<SymbolicParserTypeVariant>

}

    Message,

    Boolean,

    Byte,

    Short,

    Int,

    Long,

}

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

pub struct Type {

    pub primitive: PrimitiveType,

    pub array: bool,

}

            PrimitiveType::Int => {

                write!(f, "int")?;

            }

            PrimitiveType::Long => {

                write!(f, "long")?;

            }

        }

        if self.array {

            write!(f, "[]")

        } else {

            Ok(())

        }

    pub(crate) field_idx: usize, // in struct definition

}

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

pub struct LiteralStruct {

    // Phase 1: parser

    pub(crate) fields: Vec<LiteralStructField>,

    // Phase 2: linker

    pub(crate) poly_args2: Vec<ParserTypeId>, // taken from identifier

    pub(crate) definition: Option<DefinitionId>

}

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

pub struct LiteralEnum {

    // Phase 1: parser

    // Phase 2: linker

    pub(crate) definition: Option<DefinitionId>,

    pub(crate) variant_idx: usize,

}

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

pub enum Method {

    Create,

    Symbolic(MethodSymbolic)

}

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

pub struct MethodSymbolic {

    pub(crate) definition: Option<DefinitionId>

}

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

pub enum Field {

    Length,

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

pub struct VariableExpression {

    pub this: VariableExpressionId,

    // Phase 1: parser

    pub position: InputPosition,

    // Phase 2: linker

    pub declaration: Option<VariableId>,

    pub parent: ExpressionParent,

    // Phase 3: type checking

    pub concrete_type: ConcreteType,

}

        x - b'A' + b'a'

    } else {

        x

    }

}

    let identifier_len = identifier.value.len();

    debug_assert!(identifier_len < u16::max_value() as usize);

        position: identifier.position,

        value: identifier.value,

        poly_args: Vec::new(),

        parts: vec![

            NamespacedIdentifierPart::Identifier{start: 0, end: identifier_len as u16}

        ],

        if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {

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

        }

        self.consume_ident()?;

        Ok(())

    }

        if self.has_reserved() {

            return Err(self.error_at_pos("Encountered reserved keyword"));

        }

        // Consumes a part of the namespaced identifier, returns a boolean

        // indicating whether polymorphic arguments were specified.

        // TODO: Continue here: if we fail to properly parse the polymorphic

        //  arguments, assume we have reached the end of the namespaced 

        //  identifier and are instead dealing with a less-than operator. Ugly?

        //  Yes. Needs tokenizer? Yes. 

        fn consume_part(

            backup_pos: &mut InputPosition

        ) -> Result<(), ParseError2> {

            // Consume identifier

            if !ident.value.is_empty() {

                ident.value.extend(b"::");

            }

                None => {}

            };

            Ok(())

        }

            position: self.source.pos(),

            value: Vec::new(),

            poly_args: Vec::new(),

            parts: Vec::new(),

        };

        }

        self.source.seek(backup_pos);

        Ok(ident)

    }

    // Types and type annotations

    /// Consumes a type definition. When called the input position should be at

    /// the type specification. When done the input position will be at the end

    /// of the type specifications (hence may be at whitespace).

    fn consume_type2(&mut self, h: &mut Heap, allow_inference: bool) -> Result<ParserTypeId, ParseError2> {

                    };

                    ParseError2::new_error(&self.source, pos, msg)

                })?;

            ParserTypeVariant::Output(poly_arg)

        } else {

            // Must be a symbolic type

            ParserTypeVariant::Symbolic(SymbolicParserType{identifier, variant: None, poly_args2: Vec::new()})

        };

        // If the type was a basic type (not supporting polymorphic type

        // arguments), then we make sure the user did not specify any of them.

        let mut backup_pos = self.source.pos();

    fn maybe_consume_type_spilled_without_pos_recovery(&mut self) -> bool {

        // Consume type identifier

        debug_log!("maybe_consume_type_spilled_...: {}", debug_line!(self.source));

        if self.has_type_keyword() {

            self.consume_any_chars();

        } else {

            if ident.is_err() { return false; }

        }

        // Consume any polymorphic arguments that follow the type identifier

        let mut backup_pos = self.source.pos();

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

        // Consume any array specifiers. Make sure we always leave the input

        // position at the end of the last array specifier if we do find a

        // valid type

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

        while let Some(b'[') = self.source.next() {

        // A struct literal is written as:

        //      namespace::StructName<maybe_one_of_these, auto>{ field: expr }

        // We will parse up until the opening brace to see if we're dealing with

        // a struct literal.

        let backup_pos = self.source.pos();

        let result = self.consume_namespaced_identifier_spilled().is_ok() &&

            self.consume_whitespace(false).is_ok() &&

            self.source.next() == Some(b'{');

        self.source.seek(backup_pos);

        return result;

    }

    fn consume_struct_literal_expression(&mut self, h: &mut Heap) -> Result<LiteralExpressionId, ParseError2> {

        // Consume identifier and polymorphic arguments

        debug_log!("consume_struct_literal_expression: {}", debug_line!(self.source));

        let position = self.source.pos();

        self.consume_whitespace(false)?;

        // Consume fields

        let fields = match self.consume_comma_separated(

            h, b'{', b'}', "Expected the end of the list of struct fields",

            |lexer, heap| {

        }

        let backup_pos = self.source.pos();

        let mut result = false;

        if self.consume_namespaced_identifier_spilled().is_ok() &&

            self.consume_whitespace(false).is_ok() &&

            self.source.next() == Some(b'(') {

            // Seems like we have a function call or an enum literal

            result = true;

        }

            self.consume_keyword(b"fires")?;

            method = Method::Fires;

        } else if self.has_keyword(b"create") {

            self.consume_keyword(b"create")?;

            method = Method::Create;

        } else {

            method = Method::Symbolic(MethodSymbolic{

                identifier,

                definition: None

            });

            consume_poly_args_explicitly = false;

        };

impl SymbolKey {

    fn from_identifier(module_id: RootId, symbol: &Identifier) -> Self {

        Self{ module_id, symbol_name: symbol.value.clone() }

    }

        Self{ module_id, symbol_name: symbol.strip_poly_args() }

    }

}

pub(crate) enum Symbol {

    Namespace(RootId),

    /// 1. Polymorphic arguments are encountered on the identifier.

    /// 2. A non-namespace symbol is encountered.

    /// 3. A part of the identifier couldn't be resolved to anything

    /// The returned iterator will always point to the next symbol (even if 

    /// nothing was found)

    pub(crate) fn resolve_namespaced_identifier<'t, 'i>(

        let mut iter = identifier.iter();

        let mut symbol: Option<&SymbolValue> = None;

        let mut within_module_id = root_module_id;

        while let Some((partial, poly_args)) = iter.next() {

            // Lookup the symbol within the currently iterated upon module

use super::symbol_table::*;

use super::type_table::*;

/// Utility result type.

pub(crate) enum FindTypeResult<'t, 'i> {

    // Found the type exactly

    // Could not match symbol

    SymbolNotFound{ident_pos: InputPosition},

    // Matched part of the namespaced identifier, but not completely

    // Symbol matched, but points to a namespace/module instead of a type

    SymbolNamespace{ident_pos: InputPosition, symbol_pos: InputPosition},

}

// TODO: @cleanup Find other uses of this pattern

impl<'t, 'i> FindTypeResult<'t, 'i> {

    /// Utility function to transform the `FindTypeResult` into a `Result` where

    /// `Ok` contains the resolved type, and `Err` contains a `ParseError` which

    /// can be readily returned. This is the most common use.

        match self {

            FindTypeResult::Found(defined_type) => Ok(defined_type),

            FindTypeResult::SymbolNotFound{ident_pos} => {

                Err(ParseError2::new_error(

                    module_source, ident_pos,

                    "Could not resolve this identifier to a symbol"

/// Attempt to find the type pointer to by a (root, identifier) combination. The

/// type must match exactly (no parts in the namespace iterator remaining) and

/// must be a type, not a namespace. 

pub(crate) fn find_type_definition<'t, 'i>(

    symbols: &SymbolTable, types: &'t TypeTable, 

) -> FindTypeResult<'t, 'i> {

    // Lookup symbol

    let (symbol, ident_iter) = symbols.resolve_namespaced_identifier(root_id, identifier);

    if symbol.is_none() { 

        return FindTypeResult::SymbolNotFound{ident_pos: identifier.position};

    }

}

pub(crate) enum MatchPolymorphResult<'t> {

    Matching,

    InferAll(usize),

    Mismatch{defined_type: &'t DefinedType, ident_position: InputPosition, num_specified: usize},

}

impl<'t> MatchPolymorphResult<'t> {

    pub(crate) fn as_parse_error(self, heap: &Heap, module_source: &InputSource) -> Result<usize, ParseError2> {

        match self {

            MatchPolymorphResult::Matching => Ok(0),

    if defined_type.poly_vars.is_empty() {

        // No polymorphic variables on type

        if poly_args.is_some() {

            return MatchPolymorphResult::NoneExpected{

                defined_type,

                ident_position, 

        }

    } else {

        // Polymorphic variables on type

        let has_specified = poly_args.map_or(false, |a| a.len() != 0);

        if !has_specified {

            // Implicitly infer all of the polymorphic arguments

        Ok(())

    }

    /// Finds a variable in the visitor's scope that must appear before the

    /// specified relative position within that block.

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

        debug_assert!(identifier.parts.len() == 1, "implement namespaced seeking of target associated with identifier");

        // TODO: May still refer to an alias of a global symbol using a single

        //  identifier in the namespace.

        // No need to use iterator over namespaces if here

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

    fn find_symbol_of_type<'a>(

        &self, source: &InputSource, root_id: RootId, symbols: &SymbolTable, types: &'a TypeTable,

    ) -> Result<&'a DefinedType, ParseError2> {

        // Find symbol associated with identifier

        let (find_result, _) = find_type_definition(symbols, types, root_id, identifier)

            .as_parse_error(source)?;

        let definition_type_class = find_result.definition.type_class();