Method parse_function_definition

parser/src/parser/parser.rs:592–643

(
        &mut self,
        node: Node,
        decorators: Vec<Expression>,
        is_async: bool,
    )

    }

    fn parse_function_definition(
        &mut self,
        node: Node,
        decorators: Vec<Expression>,
        is_async: bool,
    ) -> Result<Statement, ParsingError> {
        let name = intern(self.cur_token().as_str(self.source));
        self.expect(Kind::Identifier)?;
        let type_params = if self.at(Kind::LeftBrace) {
            self.parse_type_parameters()?
        } else {
            vec![]
        };
        self.expect(Kind::LeftParen)?;
        let args = self.parse_parameters(false)?;
        self.expect(Kind::RightParen)?;

        let return_type = if self.eat(Kind::Arrow) {
            Some(self.parse_expression()?)
        } else {
            None
        };

        self.expect(Kind::Colon)?;
        let body = self.parse_suite()?;
        if is_async {
            Ok(Statement::AsyncFunctionDef(Arc::new(
                AsyncFunctionDef::new(
                    self.finish_node_chomped(node),
                    name,
                    args,
                    body,
                    decorators,
                    return_type,
                    None,
                    type_params,
                ),
            )))
        } else {
            Ok(Statement::FunctionDef(Arc::new(FunctionDef::new(
                self.finish_node_chomped(node),
                name,
                args,
                body,
                decorators,
                return_type,
                // TODO: type comment
                None,
                type_params,
            ))))
        }
    }

    fn parse_decorated_function_def_or_class_def(&mut self) -> Result<Statement, ParsingError> {
        let node = self.start_node();