Method build_method_signature

atomic-semantic/src/parser.rs:1098–1147

Build method signature

(&self, node: &Node, source: &str)

    /// Build method signature
    fn build_method_signature(&self, node: &Node, source: &str) -> String {
        let name = node
            .child_by_field_name("name")
            .and_then(|n| self.node_text(&n, source))
            .unwrap_or_default();

        // Get parameters
        let params = node
            .child_by_field_name("parameters")
            .map(|p| self.node_text(&p, source).unwrap_or_default())
            .unwrap_or_else(|| "()".to_string());

        // Get return type
        let return_type = node
            .child_by_field_name("return_type")
            .map(|r| self.node_text(&r, source).unwrap_or_default())
            .unwrap_or_default();

        // Check for async/static modifiers
        let mut modifiers = Vec::new();
        for i in 0..node.child_count() {
            if let Some(child) = node.child(i) {
                match child.kind() {
                    "async" => modifiers.push("async"),
                    "static" => modifiers.push("static"),
                    "readonly" => modifiers.push("readonly"),
                    "accessibility_modifier" => {
                        if let Some(text) = self.node_text(&child, source) {
                            modifiers.push(if text == "public" {
                                "public"
                            } else if text == "private" {
                                "private"
                            } else {
                                "protected"
                            });
                        }
                    }
                    _ => {}
                }
            }
        }

        let modifier_str = if modifiers.is_empty() {
            String::new()
        } else {
            format!("{} ", modifiers.join(" "))
        };

        format!("{}{}{}{}", modifier_str, name, params, return_type)
    }

    /// Build type alias signature
    fn build_type_alias_signature(&self, node: &Node, source: &str) -> String {