fix(native): compute complexity and CFG for prototype method definitions

emit_js_prototype_method and the method_definition arm of
extract_js_prototype_object_literal both emitted complexity: None and
cfg: None. Call compute_all_metrics and build_function_cfg on the
function node, matching the pattern used by handle_function_decl,
handle_method_def, and handle_var_decl.

Author: carlos-alm

crates/codegraph-core/src/extractors/javascript.rs

@@ -368,8 +368,8 @@ fn emit_js_prototype_method(class_name: &str, method_name: &str, rhs: &Node, sou
                 line: start_line(rhs),
                 end_line: Some(end_line(rhs)),
                 decorators: None,
-                complexity: None,
-                cfg: None,
+                complexity: compute_all_metrics(rhs, source, "javascript"),
+                cfg: build_function_cfg(rhs, "javascript", source),
                 children: None,
             });
         }
@@ -398,8 +398,8 @@ fn extract_js_prototype_object_literal(class_name: &str, obj_node: &Node, source
                     line: start_line(&child),
                     end_line: Some(end_line(&child)),
                     decorators: None,
-                    complexity: None,
-                    cfg: None,
+                    complexity: compute_all_metrics(&child, source, "javascript"),
+                    cfg: build_function_cfg(&child, "javascript", source),
                     children: None,
                 });
             }
@@ -2504,4 +2504,41 @@ mod tests {
         let def = s.definitions.iter().find(|d| d.name.contains("Array"));
         assert!(def.is_none(), "built-in prototype assignment should be ignored; got: {:?}", def);
     }
+
+    #[test]
+    fn prototype_direct_method_has_complexity_and_cfg() {
+        let s = parse_js(
+            "function C() {}\n\
+             C.prototype.foo = function() { if (true) { return 1; } return 0; };",
+        );
+        let def = s.definitions.iter().find(|d| d.name == "C.foo").expect("C.foo missing");
+        assert!(def.complexity.is_some(), "C.foo should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.foo should have CFG data");
+    }
+
+    #[test]
+    fn prototype_object_literal_method_definition_has_complexity_and_cfg() {
+        let s = parse_js(
+            "function C() {}\n\
+             C.prototype = {\n\
+               greet() { if (true) { return 'hi'; } return ''; },\n\
+             };",
+        );
+        let def = s.definitions.iter().find(|d| d.name == "C.greet").expect("C.greet missing");
+        assert!(def.complexity.is_some(), "C.greet should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.greet should have CFG data");
+    }
+
+    #[test]
+    fn prototype_object_literal_pair_fn_has_complexity_and_cfg() {
+        let s = parse_js(
+            "function C() {}\n\
+             C.prototype = {\n\
+               bar: function() { if (true) { return 1; } return 0; },\n\
+             };",
+        );
+        let def = s.definitions.iter().find(|d| d.name == "C.bar").expect("C.bar missing");
+        assert!(def.complexity.is_some(), "C.bar should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.bar should have CFG data");
+    }
 }