Function parse

dossier-ts/src/function.rs:88–141

(node: &Node, ctx: &mut ParserContext)

}

pub(crate) fn parse(node: &Node, ctx: &mut ParserContext) -> Result<Symbol> {
    assert_eq!(node.kind(), NODE_KIND);

    let mut children = vec![];

    let mut cursor = QueryCursor::new();
    let function = cursor
        .matches(&QUERY, *node, ctx.code.as_bytes())
        .next()
        .unwrap();

    let main_node = node_for_capture("function", function.captures, &QUERY).unwrap();
    let name_node = node_for_capture("function_name", function.captures, &QUERY).unwrap();
    let type_param_node = node_for_capture("function_type_parameters", function.captures, &QUERY);
    let parameters_node = node_for_capture("function_parameters", function.captures, &QUERY);
    let return_type_node = node_for_capture("function_return_type", function.captures, &QUERY);

    let identifier = name_node.utf8_text(ctx.code.as_bytes()).unwrap().to_owned();

    ctx.push_scope();
    ctx.push_fqn(&identifier);

    if let Some(type_parameters) = type_param_node {
        parse_type_parameters(&type_parameters, &mut children, ctx);
        ctx.push_scope();
    }

    if let Some(parameter_nodes) = parameters_node {
        parse_parameters(&parameter_nodes, &mut children, ctx)?;
    }

    if let Some(type_node) = return_type_node {
        parse_return_type(&type_node, &mut children, ctx)?;
    }

    let docs = find_docs(&main_node, ctx.code);

    if type_param_node.is_some() {
        ctx.pop_scope();
    }
    ctx.pop_scope();
    ctx.pop_fqn();

    Ok(Symbol::in_context(
        ctx,
        SymbolKind::Function(Function {
            identifier,
            documentation: docs.map(process_comment),
            is_exported: is_exported(&main_node),
            children,
        }),
        Source::for_node(&main_node, ctx),
    ))
}

pub(crate) fn parse_return_type(
    node: &Node,