// Tuple: expecting any number of elements. Note that the parser type can

    // have one-valued tuples, these will be filtered out later during type

    // checking.

    Tuple(u32), // u32 = number of subsequent types

            Definition(_, num) | Tuple(num) => *num as usize,

pub(crate) mod pass_definitions_types;

                // declaration, the other one is to parse it as a normal

                // expression. This is a bit ugly.

    // After parsing the array modifier "[]", we need to insert an array type

use crate::protocol::*;

use crate::protocol::parser::*;

struct Entry {

    element: ParserTypeElement,

    depth: i32,

}

#[derive(Copy, Clone)]

enum DepthKind {

    Tuple, // because we had a `(` token

    PolyArgs, // because we had a `<` token

}

struct DepthElement {

    kind: DepthKind,

    pos: InputPosition,

}

/// Temporarily keep the error around in unevaluated format because sometimes

/// when we evaluate a `ParserType`, we perform some backtracking if it fails.

enum ParserTypeError {

    ExpectedAType(InputPosition),

    MessageAt(InputPosition, &'static str),

    TwoMessageAt(InputPosition, &'static str, InputPosition, &'static str),

}

/// Parsers tokens into `ParserType` instances (yes, the name of the struct is

/// silly). Essentially a little state machine with its own temporary storage.

pub(crate) struct ParserTypeParser {

    entries: Vec<Entry>,

    depths: Vec<DepthElement>,

    first_pos: InputPosition,

    last_pos: InputPosition,

}

impl ParserTypeParser {

    pub(crate) fn consume_parser_type(

        &mut self,

        source: &InputSource, iter: &mut TokenIter,

        symbols: &SymbolTable, heap: &Heap, poly_vars: &[Identifier],

        cur_scope: SymbolScope, wrapping_definition: DefinitionId,

        allow_inference: bool, inside_angular_bracket: Option<InputPosition>,

    ) -> Result<ParserType, ParserTypeError> {

        // Make sure we start in an empty state

        debug_assert!(self.entries.is_empty());

        debug_assert!(self.depths.is_empty());

        // Setup processing

        if let Some(bracket_pos) = inside_angular_bracket {

            self.push_depth(DepthKind::PolyArgs, bracket_pos);

        }

        let first_element = match iter.next() {

            Some(TokenKind::Ident) => {

            },

            Some(TokenKind::OpenParen) => {

                let tuple_start_pos = iter.next_start_position();

                self.push_depth(DepthKind::Tuple, tuple_start_pos);

                self.entries.push(Entry{

                    element: ParserTypeElement{

                        element_span: InputSpan::from_positions(tuple_start_pos, tuple_start_pos),

                        variant: ParserTypeVariant::Tuple(0),

                    },

                    depth: self.cur_depth(),

                });

                iter.consume();

            },

            _ => return Err(ParserTypeError::MessageAt(iter.last_valid_pos(), "expected a type")),

        };

        // Convert the results from parsing into the `ParserType`

        let mut elements = Vec::with_capacity(self.entries.len());

        debug_assert!(!self.entries.is_empty());

        for entry in self.entries.drain(..) {

            elements.push(entry.element)

        }

        return Ok(ParserType{

            elements,

            full_span: InputSpan::from_positions(self.first_pos, self.last_pos),

        });

    }

    /// Consumes an identifier that should resolve to some kind of type. There

    /// may be trailing '::' tokens, commas, or polymorphic arguments.

    fn consume_parser_type_ident(

        &self, iter: &mut TokenIter, symbols: &SymbolTable, poly_vars: &[Identifier],

        allow_inference: bool,

    ) -> Result<ParserTypeElement, ParserTypeError> {

    }

    #[inline]

    fn push_depth(&mut self, kind: DepthKind, pos: InputPosition) {

        self.depths.push(DepthElement{ kind, pos });

    }

    #[inline]

    fn pop_depth(&mut self, kind: DepthKind, pos: InputPosition) -> Result<(), ParserTypeError> {

        if self.depths.is_empty() {

            // More closing parens than opening ones

            let message = match kind {

                DepthKind::Tuple => "unmatched ')'",

                DepthKind::PolyArgs => "unmatched '>'",

            };

            return Err(ParserTypeError::MessageAt(pos, message))

        }

        let last = *self.depths.last().unwrap();

        if last != kind {

            // Wrong kind of paren

            let (message_second) = match kind {

                DepthKind::Tuple => "unexpected closing"

            }

        }

    }

    #[inline]

    fn cur_depth(&self) -> i32 {

        return self.depths.len() as i32;

    }

}

    /// Assumes the token is not at the end and returns the starting position

    /// belonging to the token returned by `next`.

    pub(crate) fn next_start_position(&self) -> InputPosition {

        debug_assert!(self.cur < self.end);

        return self.tokens[self.cur].pos;

    }