Method visit_function_declaration

src/extraction/lua_extractor.rs:167–266

Extract a function declaration. Lua function declarations come in three flavours: - `local function foo(...)` → name is `identifier`, local/private function - `function Foo.bar(...)` → name is `dot_index_expression`, public function with class context - `function Foo:bar(...)` → name is `method_index_expression`, method

(state: &mut ExtractionState, node: TsNode<'_>)

    /// - `function Foo.bar(...)` → name is `dot_index_expression`, public function with class context
    /// - `function Foo:bar(...)` → name is `method_index_expression`, method
    fn visit_function_declaration(state: &mut ExtractionState, node: TsNode<'_>) {
        let Some(name_node) = node.child_by_field_name("name") else {
            return;
        };

        let is_local = node.child(0).is_some_and(|c| c.kind() == "local");

        let (name, kind, visibility, class_context) = match name_node.kind() {
            "identifier" => {
                let name = state.node_text(name_node);
                (
                    name,
                    NodeKind::Function,
                    if is_local {
                        Visibility::Private
                    } else {
                        Visibility::Pub
                    },
                    None,
                )
            }
            "dot_index_expression" => {
                // e.g. Connection.new
                let table_name = name_node
                    .child_by_field_name("table")
                    .map(|n| state.node_text(n));
                let field_name = name_node
                    .child_by_field_name("field")
                    .map_or_else(|| "<anonymous>".to_string(), |n| state.node_text(n));
                (field_name, NodeKind::Function, Visibility::Pub, table_name)
            }
            "method_index_expression" => {
                // e.g. Connection:connect
                let table_name = name_node
                    .child_by_field_name("table")
                    .map(|n| state.node_text(n));
                let method_name = name_node
                    .child_by_field_name("method")
                    .map_or_else(|| "<anonymous>".to_string(), |n| state.node_text(n));
                (method_name, NodeKind::Method, Visibility::Pub, table_name)
            }
            _ => return,
        };

        let docstring = Self::extract_docstring(state, node);
        let signature = Self::extract_function_signature(state, node, class_context.as_deref());
        let start_line = node.start_position().row as u32;
        let end_line = node.end_position().row as u32;
        let start_column = node.start_position().column as u32;
        let end_column = node.end_position().column as u32;
        let qualified_name = if let Some(ref ctx) = class_context {
            format!("{}::{}::{}", state.qualified_prefix(), ctx, name)
        } else {
            format!("{}::{}", state.qualified_prefix(), name)
        };
        let id = generate_node_id(&state.file_path, &kind, &name, start_line);
        let metrics = count_complexity(node, &LUA_COMPLEXITY, &state.source);