Merge branch 'main' into docs/phase8-language-analysis-reference-map

Author: carlos-alm

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

@@ -93,10 +93,18 @@ fn match_js_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
                                 });
                             }
                         }
+                        // Phase 8.3e: Object.create({ key: fn }) → composite pts key per property
+                        if value_n.kind() == "call_expression" {
+                            seed_object_create_entries(var_name, &value_n, source, symbols);
+                        }
                     }
                 }
             }
         }
+        // Phase 8.3e: Object.defineProperty / defineProperties → composite pts key
+        "call_expression" => {
+            seed_define_property_entries(node, source, symbols);
+        }
         "required_parameter" | "optional_parameter" => {
             let name_node = node.child_by_field_name("pattern")
                 .or_else(|| node.child_by_field_name("left"))
@@ -194,13 +202,158 @@ fn is_js_builtin_global(name: &str) -> bool {
     )
 }
 
+// ── Phase 8.3e: Object.defineProperty / defineProperties / create ────────────
+
+/// Seed composite pts keys for `Object.defineProperty(obj, "key", { value: fn })`
+/// and `Object.defineProperties(obj, { "key": { value: fn }, ... })`.
+fn seed_define_property_entries(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
+    let Some(callee) = node.child_by_field_name("function") else { return };
+    if callee.kind() != "member_expression" { return; }
+    let Some(callee_obj) = callee.child_by_field_name("object") else { return };
+    if node_text(&callee_obj, source) != "Object" { return; }
+    let Some(callee_prop) = callee.child_by_field_name("property") else { return };
+    let method = node_text(&callee_prop, source);
+    if method != "defineProperty" && method != "defineProperties" { return; }
+
+    let args_node = node.child_by_field_name("arguments")
+        .or_else(|| find_child(node, "arguments"));
+    let Some(args_node) = args_node else { return };
+
+    // Collect non-punctuation argument nodes in order
+    let mut args: Vec<Node> = Vec::new();
+    for i in 0..args_node.child_count() {
+        let Some(child) = args_node.child(i) else { continue };
+        if !matches!(child.kind(), "(" | ")" | ",") {
+            args.push(child);
+        }
+    }
+
+    if method == "defineProperty" {
+        // Object.defineProperty(obj, "key", { value: fn })
+        if args.len() < 3 { return; }
+        if args[0].kind() != "identifier" { return; }
+        let obj_name = node_text(&args[0], source);
+        let Some(key) = extract_string_fragment(&args[1], source) else { return };
+        let Some(target) = find_descriptor_value(&args[2], source) else { return };
+        symbols.type_map.push(TypeMapEntry {
+            name: format!("{}.{}", obj_name, key),
+            type_name: target.to_string(),
+            confidence: 0.85,
+        });
+    } else {
+        // Object.defineProperties(obj, { "key": { value: fn }, ... })
+        if args.len() < 2 { return; }
+        if args[0].kind() != "identifier" { return; }
+        let obj_name = node_text(&args[0], source).to_string();
+        if args[1].kind() != "object" { return; }
+        seed_descriptor_object(&obj_name, &args[1], source, symbols);
+    }
+}
+
+/// Seed composite pts keys from `const obj = Object.create({ f1, f2 })`.
+fn seed_object_create_entries(var_name: &str, call_node: &Node, source: &[u8], symbols: &mut FileSymbols) {
+    let Some(callee) = call_node.child_by_field_name("function") else { return };
+    if callee.kind() != "member_expression" { return; }
+    let Some(callee_obj) = callee.child_by_field_name("object") else { return };
+    if node_text(&callee_obj, source) != "Object" { return; }
+    let Some(callee_prop) = callee.child_by_field_name("property") else { return };
+    if node_text(&callee_prop, source) != "create" { return; }
+
+    let args_node = call_node.child_by_field_name("arguments")
+        .or_else(|| find_child(call_node, "arguments"));
+    let Some(args_node) = args_node else { return };
+
+    // First non-punctuation argument = prototype object
+    let proto = (0..args_node.child_count())
+        .filter_map(|i| args_node.child(i))
+        .find(|n| !matches!(n.kind(), "(" | ")" | ","));
+    let Some(proto) = proto else { return };
+    if proto.kind() != "object" { return };
+
+    for i in 0..proto.child_count() {
+        let Some(child) = proto.child(i) else { continue };
+        match child.kind() {
+            "shorthand_property_identifier" => {
+                // { f1 } shorthand — property name equals value name
+                let name = node_text(&child, source);
+                symbols.type_map.push(TypeMapEntry {
+                    name: format!("{}.{}", var_name, name),
+                    type_name: name.to_string(),
+                    confidence: 0.85,
+                });
+            }
+            "pair" => {
+                let Some(key_n) = child.child_by_field_name("key") else { continue };
+                let Some(val_n) = child.child_by_field_name("value") else { continue };
+                if val_n.kind() != "identifier" { continue; }
+                let key = if key_n.kind() == "string" {
+                    extract_string_fragment(&key_n, source).map(|s| s.to_string())
+                } else {
+                    Some(node_text(&key_n, source).to_string())
+                };
+                let Some(key) = key else { continue };
+                symbols.type_map.push(TypeMapEntry {
+                    name: format!("{}.{}", var_name, key),
+                    type_name: node_text(&val_n, source).to_string(),
+                    confidence: 0.85,
+                });
+            }
+            _ => {}
+        }
+    }
+}
+
+/// Iterate over the properties of a `defineProperties` descriptor object and seed the type_map.
+fn seed_descriptor_object(obj_name: &str, obj_node: &Node, source: &[u8], symbols: &mut FileSymbols) {
+    for i in 0..obj_node.child_count() {
+        let Some(child) = obj_node.child(i) else { continue };
+        if child.kind() != "pair" { continue; }
+        let Some(key_n) = child.child_by_field_name("key") else { continue };
+        let Some(val_n) = child.child_by_field_name("value") else { continue };
+        let key = if key_n.kind() == "string" {
+            extract_string_fragment(&key_n, source).map(|s| s.to_string())
+        } else {
+            Some(node_text(&key_n, source).to_string())
+        };
+        let Some(key) = key else { continue };
+        let Some(target) = find_descriptor_value(&val_n, source) else { continue };
+        symbols.type_map.push(TypeMapEntry {
+            name: format!("{}.{}", obj_name, key),
+            type_name: target.to_string(),
+            confidence: 0.85,
+        });
+    }
+}
+
+/// Extract the text of the `string_fragment` child of a string node, i.e. content without quotes.
+fn extract_string_fragment<'a>(node: &Node<'a>, source: &'a [u8]) -> Option<&'a str> {
+    if node.kind() != "string" { return None; }
+    find_child(node, "string_fragment").map(|n| node_text(&n, source))
+}
+
+/// Find the `value` identifier in a property descriptor object `{ value: fn }`.
+fn find_descriptor_value<'a>(node: &Node<'a>, source: &'a [u8]) -> Option<&'a str> {
+    if node.kind() != "object" { return None; }
+    for i in 0..node.child_count() {
+        let Some(child) = node.child(i) else { continue };
+        if child.kind() != "pair" { continue; }
+        let Some(key) = child.child_by_field_name("key") else { continue };
+        if node_text(&key, source) != "value" { continue; }
+        let Some(val) = child.child_by_field_name("value") else { continue };
+        if val.kind() == "identifier" {
+            return Some(node_text(&val, source));
+        }
+    }
+    None
+}
+
 // ── Return-type map extraction (Phase 8.2 parity) ───────────────────────────
 
 /// Walk the AST collecting function/method return types into `symbols.return_type_map`.
 /// Mirrors `extractReturnTypeMapWalk` in src/extractors/javascript.ts.
 fn match_js_return_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth: usize) {
     match node.kind() {
-        "function_declaration" => {
+        "function_declaration" | "generator_function_declaration" => {
             let Some(name_n) = node.child_by_field_name("name") else { return };
             let fn_name = node_text(&name_n, source);
             if fn_name == "constructor" { return; }
@@ -228,9 +381,9 @@ fn match_js_return_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbol
             let Some(name_n) = node.child_by_field_name("name") else { return };
             if name_n.kind() != "identifier" { return; }
             let Some(value_n) = node.child_by_field_name("value") else { return };
-            // Only arrow_function and function_expression match the TS reference;
+            // Only arrow_function, function_expression and generator_function match the TS reference;
             // "function" is not a valid tree-sitter value-expression kind here.
-            if !matches!(value_n.kind(), "arrow_function" | "function_expression") {
+            if !matches!(value_n.kind(), "arrow_function" | "function_expression" | "generator_function") {
                 return;
             }
             let var_name = node_text(&name_n, source);
@@ -334,7 +487,7 @@ fn match_js_call_assignments(node: &Node, source: &[u8], symbols: &mut FileSymbo
 
 fn match_js_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth: usize) {
     match node.kind() {
-        "function_declaration" => handle_function_decl(node, source, symbols),
+        "function_declaration" | "generator_function_declaration" => handle_function_decl(node, source, symbols),
         "class_declaration" | "abstract_class_declaration" => {
             handle_class_decl(node, source, symbols)
         }
@@ -497,7 +650,7 @@ fn handle_var_decl(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
         let value_n = declarator.child_by_field_name("value");
         let (Some(name_n), Some(value_n)) = (name_n, value_n) else { continue };
         let vt = value_n.kind();
-        if vt == "arrow_function" || vt == "function_expression" || vt == "function" {
+        if vt == "arrow_function" || vt == "function_expression" || vt == "function" || vt == "generator_function" {
             let children = extract_js_parameters(&value_n, source);
             symbols.definitions.push(Definition {
                 name: node_text(&name_n, source).to_string(),
@@ -651,7 +804,7 @@ fn handle_export_stmt(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
 
 fn handle_export_declaration(node: &Node, decl: &Node, source: &[u8], symbols: &mut FileSymbols) {
     let (kind_str, field) = match decl.kind() {
-        "function_declaration" => ("function", "name"),
+        "function_declaration" | "generator_function_declaration" => ("function", "name"),
         "class_declaration" | "abstract_class_declaration" => ("class", "name"),
         "interface_declaration" => ("interface", "name"),
         "type_alias_declaration" => ("type", "name"),
@@ -2292,4 +2445,76 @@ mod tests {
             "compute call should have receiver='calc'"
         );
     }
+
+    /// Phase 8.3e: Object.defineProperty seeds composite type_map key.
+    #[test]
+    fn type_map_from_define_property() {
+        let s = parse_js(
+            "function f1() {}\n\
+             const obj = {};\n\
+             Object.defineProperty(obj, \"f\", { value: f1 });",
+        );
+        let entry = s.type_map.iter().find(|e| e.name == "obj.f");
+        assert!(entry.is_some(), "type_map should contain 'obj.f'; got: {:?}", s.type_map);
+        assert_eq!(entry.unwrap().type_name, "f1");
+    }
+
+    /// Phase 8.3e: Object.defineProperties seeds composite type_map keys.
+    #[test]
+    fn type_map_from_define_properties() {
+        let s = parse_js(
+            "function f1() {}\n\
+             function f2() {}\n\
+             const obj = {};\n\
+             Object.defineProperties(obj, {\n\
+               \"f1\": { value: f1 },\n\
+               \"f2\": { value: f2 },\n\
+             });",
+        );
+        let e1 = s.type_map.iter().find(|e| e.name == "obj.f1");
+        let e2 = s.type_map.iter().find(|e| e.name == "obj.f2");
+        assert!(e1.is_some(), "type_map should contain 'obj.f1'; got: {:?}", s.type_map);
+        assert!(e2.is_some(), "type_map should contain 'obj.f2'; got: {:?}", s.type_map);
+        assert_eq!(e1.unwrap().type_name, "f1");
+        assert_eq!(e2.unwrap().type_name, "f2");
+    }
+
+    /// Phase 8.3e: Object.create seeds composite type_map keys from shorthand proto.
+    #[test]
+    fn type_map_from_object_create() {
+        let s = parse_js(
+            "function f1() {}\n\
+             function f2() {}\n\
+             const obj = Object.create({ f1, f2 });",
+        );
+        let e1 = s.type_map.iter().find(|e| e.name == "obj.f1");
+        let e2 = s.type_map.iter().find(|e| e.name == "obj.f2");
+        assert!(e1.is_some(), "type_map should contain 'obj.f1'; got: {:?}", s.type_map);
+        assert!(e2.is_some(), "type_map should contain 'obj.f2'; got: {:?}", s.type_map);
+        assert_eq!(e1.unwrap().type_name, "f1");
+        assert_eq!(e2.unwrap().type_name, "f2");
+    }
+
+    /// Phase 8.3e: call receiver is correctly recorded for obj.f() inside defProp body.
+    #[test]
+    fn call_receiver_for_define_property() {
+        let s = parse_js(
+            "function f1() {}\n\
+             function defProp() {\n\
+               const obj = {};\n\
+               Object.defineProperty(obj, \"f\", { value: f1 });\n\
+               obj.f();\n\
+             }",
+        );
+        let tm = s.type_map.iter().find(|e| e.name == "obj.f");
+        assert!(tm.is_some(), "type_map should contain 'obj.f'; got: {:?}", s.type_map);
+        assert_eq!(tm.unwrap().type_name, "f1");
+
+        let call = s.calls.iter().find(|c| c.name == "f" && c.receiver.as_deref() == Some("obj"));
+        assert!(
+            call.is_some(),
+            "calls should contain obj.f() with receiver='obj'; got: {:?}",
+            s.calls.iter().map(|c| (&c.name, &c.receiver)).collect::<Vec<_>>()
+        );
+    }
 }

docs/benchmarks/RESOLUTION-COMPARISON.md

@@ -177,10 +177,35 @@ Established Java static call graph tools all require compiled bytecode:
 | [Soot](https://github.com/soot-oss/soot) | CHA / RTA / VTA / Spark | Needs compiled `.class` files |
 | [javacg-static](https://github.com/gousiosg/java-callgraph) | CHA | Lightweight, reads JARs |
 
-The fixture contains raw `.java` source with no build system. Running these
-tools requires a `javac` compilation step (tracked in #1307).
+The fixture now includes a `Makefile` that compiles all `.java` sources into
+`fixture.jar`:
 
-**Current codegraph Java metrics** (`scripts/resolution-benchmark.ts`):
+```bash
+cd tests/benchmarks/resolution/fixtures/java && make
+```
+
+`scripts/compare-javacg.mjs` then runs
+[javacg-static](https://github.com/gousiosg/java-callgraph) on the compiled JAR.
+javacg-static uses CHA to enumerate all possible call targets at virtual,
+interface, and static call sites.
+
+```bash
+node scripts/compare-javacg.mjs --jar /path/to/javacg-0.1-SNAPSHOT.jar
+# or: JAVACG_JAR=... node scripts/compare-javacg.mjs
+```
+
+Download javacg-static from
+[github.com/gousiosg/java-callgraph/releases](https://github.com/gousiosg/java-callgraph/releases)
+or build with `mvn package -DskipTests`.
+
+**Name mapping:** javacg-static uses `pkg.ClassName:method(JVM-descriptors)` form.
+`compare-javacg.mjs` maps this to `ClassName.method` and matches
+`ClassName.ClassName` (source constructor) / `ClassName` (target constructor)
+against the expected-edges.json convention. Only edges where both class names
+appear in the fixture source files are counted; JDK calls (`String`, `HashMap`,
+`System.out`, …) are filtered out.
+
+**Codegraph Java metrics** (`scripts/resolution-benchmark.ts`):
 
 | Mode | Codegraph |
 |------|:---------:|
@@ -192,6 +217,19 @@ tools requires a `javac` compilation step (tracked in #1307).
 | `class-inheritance` (3 edges) | 0/3 (0%) |
 | **Total** | **9/17 (53%)** · precision=100% |
 
+**javacg-static comparison** — run `node scripts/compare-javacg.mjs` to populate:
+
+| Tool | Precision | Recall | TP | FP | FN |
+|------|:---------:|:------:|---:|---:|---:|
+| Codegraph | 100% | 53% | 9 | 0 | 8 |
+| javacg-static (CHA) | — | — | — | — | — |
+
+javacg-static uses CHA and reads compiled bytecode, so it should resolve
+`class-inheritance` (inherited `log()` calls) and `interface-dispatched`
+(virtual dispatch via `UserRepository` interface) edges that codegraph
+currently misses at the source-level. `static` and `same-file` calls
+(`invokestatic` in bytecode) should also be fully captured.
+
 ---
 
 ## Conclusions
@@ -231,8 +269,9 @@ tools requires a `javac` compilation step (tracked in #1307).
    2 `class-inheritance` edges (+7 recall on TS fixture).
 2. **Property-assignment type tracking** (#1306) — Track `this.prop = new Foo()`
    writes. Recovers 3 JS `receiver-typed` FN.
-3. **Java comparison with javacg-static** (#1307) — Add `javac` compilation to
-   the Java fixture so a bytecode-level tool can validate Java recall claims.
+3. **Java recall gaps** — `same-file` (0/2) and `static` (0/2) are `invokestatic`
+   patterns that javacg-static will expose; `class-inheritance` (0/3) requires
+   tracking inherited method calls from superclass to subclass invocation site.
 
 ---
 
@@ -300,6 +339,10 @@ npx tsx scripts/resolution-benchmark.ts | jq '{javascript, typescript, java}'
 npm install @cs-au-dk/jelly @persper/js-callgraph
 node scripts/compare-tools.mjs --all
 
+# javacg-static comparison (Java)
+cd tests/benchmarks/resolution/fixtures/java && make && cd -
+node scripts/compare-javacg.mjs --jar /path/to/javacg-0.1-SNAPSHOT.jar
+
 # Full resolution test suite
 npx vitest run tests/benchmarks/resolution/resolution-benchmark.test.ts
 ```