Method parse

src/modules/function/invocation.rs:62–112

(&mut self, meta: &mut ParserMetadata)

    }

    fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
        syntax(meta, &mut self.modifier)?;
        self.modifier.use_modifiers(meta, |_this, meta| {
            // Get the function name and store token for error reporting
            let tok = meta.get_current_token();
            if let Some(ref tok) = tok {
                (self.line, self.col) = tok.pos;
            }
            self.name = variable(meta, variable_name_extensions())?;
            self.name_tok = tok.clone();
            self.failure_handler.set_function_name(self.name.clone());

            // Parse arguments syntax
            token(meta, "(")?;
            loop {
                // Skip comments and newlines
                if token_by(meta, |token| {
                    token.starts_with("//") || token.starts_with('\n')
                })
                .is_ok()
                {
                    continue;
                }
                if token(meta, ")").is_ok() {
                    break;
                }
                let mut arg = Expr::new();
                syntax(meta, &mut arg)?;
                self.args.push(arg);
                match token(meta, ")") {
                    Ok(_) => break,
                    Err(_) => token(meta, ",")?,
                };
            }

            // Store position for later error reporting
            self.failure_handler
                .set_position(PositionInfo::from_between_tokens(
                    meta,
                    tok.clone(),
                    meta.get_current_token(),
                ));

            // Try to parse the failed block if present (optional in parse phase)
            if let Err(Failure::Loud(msg)) = syntax(meta, &mut self.failure_handler) {
                return Err(Failure::Loud(msg));
            }

            Ok(())
        })
    }
}

impl TypeCheckModule for FunctionInvocation {