Method parse_callable_signature

core/src/parser.rs:1473–1516

Parses the signature of a callable declaration or definition.

(
        &mut self,
        is_declare: bool,
        is_function: bool,
    )

    /// Parses the signature of a callable declaration or definition.
    fn parse_callable_signature(
        &mut self,
        is_declare: bool,
        is_function: bool,
    ) -> Result<(VarRef, LineCol, Vec<VarRef>)> {
        let kw_name = if is_function { "FUNCTION" } else { "SUB" };
        let token_span = self.lexer.read()?;
        let name = match token_span.token {
            Token::Symbol(name) => match (name.ref_type, is_function) {
                (None, true) => VarRef::new(name.name, Some(ExprType::Integer)),
                (Some(..), true) => name,
                (None, false) => name,
                (Some(..), false) => {
                    return Err(Error::Bad(
                        token_span.pos,
                        "SUBs cannot return a value so type annotations are not allowed".to_owned(),
                    ));
                }
            },
            _ => {
                return Err(Error::Bad(
                    token_span.pos,
                    format!("Expected a name after {}", kw_name),
                ));
            }
        };
        let name_pos = token_span.pos;

        let params = self.parse_callable_args()?;

        let peeked = self.lexer.peek()?;
        match peeked.token {
            Token::Eol => (),
            Token::Eof if is_declare => (),
            _ => {
                return Err(Error::Bad(
                    peeked.pos,
                    format!("Expected newline after {} name", kw_name),
                ));
            }
        }

        Ok((name, name_pos, params))
    }

    /// Parses a `FUNCTION` definition.
    fn parse_function(&mut self, function_pos: LineCol) -> Result<Statement> {