fix(native): compute complexity/cfg for prototype method definitions (#1340)

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

@@ -521,8 +521,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,
             });
         }
@@ -551,8 +551,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,
                 });
             }
@@ -2601,7 +2601,24 @@ mod tests {
         );
         let def = s.definitions.iter().find(|d| d.name == "C.foo");
         assert!(def.is_some(), "C.foo definition missing; got: {:?}", s.definitions.iter().map(|d| &d.name).collect::<Vec<_>>());
-        assert_eq!(def.unwrap().kind, "method");
+        let def = def.unwrap();
+        assert_eq!(def.kind, "method");
+        assert!(def.complexity.is_some(), "C.foo should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.foo should have a CFG");
+    }
+
+    #[test]
+    fn prototype_arrow_function_method_emits_definition() {
+        let s = parse_js(
+            "function C() {}\n\
+             C.prototype.foo = () => { return 1; };",
+        );
+        let def = s.definitions.iter().find(|d| d.name == "C.foo");
+        assert!(def.is_some(), "C.foo definition missing; got: {:?}", s.definitions.iter().map(|d| &d.name).collect::<Vec<_>>());
+        let def = def.unwrap();
+        assert_eq!(def.kind, "method");
+        assert!(def.complexity.is_some(), "C.foo (arrow) should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.foo (arrow) should have a CFG");
     }
 
     #[test]
@@ -2628,8 +2645,15 @@ mod tests {
         let foo = s.definitions.iter().find(|d| d.name == "C.foo");
         let bar = s.definitions.iter().find(|d| d.name == "C.bar");
         assert!(foo.is_some(), "C.foo missing");
-        assert_eq!(foo.unwrap().kind, "method");
+        let foo = foo.unwrap();
+        assert_eq!(foo.kind, "method");
+        assert!(foo.complexity.is_some(), "C.foo should have complexity metrics");
+        assert!(foo.cfg.is_some(), "C.foo should have a CFG");
         assert!(bar.is_some(), "C.bar missing");
+        let bar = bar.unwrap();
+        assert_eq!(bar.kind, "method");
+        assert!(bar.complexity.is_some(), "C.bar should have complexity metrics");
+        assert!(bar.cfg.is_some(), "C.bar should have a CFG");
     }
 
     #[test]
@@ -2642,7 +2666,10 @@ mod tests {
         );
         let def = s.definitions.iter().find(|d| d.name == "C.greet");
         assert!(def.is_some(), "C.greet definition missing; got: {:?}", s.definitions.iter().map(|d| &d.name).collect::<Vec<_>>());
-        assert_eq!(def.unwrap().kind, "method");
+        let def = def.unwrap();
+        assert_eq!(def.kind, "method");
+        assert!(def.complexity.is_some(), "C.greet should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.greet should have a CFG");
     }
 
     #[test]