fix: resolve merge conflicts with feat/prototype-resolver-1317

Author: carlos-alm

biome.json

@@ -25,5 +25,13 @@
       "semicolons": "always",
       "trailingCommas": "all"
     }
-  }
+  },
+  "overrides": [
+    {
+      "includes": ["tests/benchmarks/resolution/fixtures/**"],
+      "linter": {
+        "enabled": false
+      }
+    }
+  ]
 }

crates/codegraph-core/src/edge_builder.rs

@@ -483,15 +483,27 @@ fn resolve_call_targets<'a>(
                 if !class_scoped.is_empty() { return class_scoped; }
             }
 
-            // Broader fallback: same-file suffix scan to pick up CHA-expanded targets
-            // (subclasses that override the method).
+            // Broader fallback: same-file suffix scan.  Always restrict to the caller's
+            // own class prefix — regardless of how many matches are found — to avoid
+            // false-positive edges to unrelated classes in the same file.
+            // (e.g. this.area() inside Shape.describe must never yield Calculator.area,
+            // even when Calculator.area is the only method with that name in the file.)
             let suffix = format!(".{}", call.name);
             if let Some(file_nodes) = ctx.nodes_by_file.get(rel_path) {
                 let same_file_methods: Vec<&NodeInfo> = file_nodes.iter()
                     .filter(|n| n.kind == "method" && n.name.ends_with(&suffix))
                     .copied()
                     .collect();
-                if !same_file_methods.is_empty() { return same_file_methods; }
+                if !same_file_methods.is_empty() {
+                    if let Some(dot_pos) = caller_name.find('.') {
+                        let caller_prefix = format!("{}.", &caller_name[..dot_pos]);
+                        let caller_scoped: Vec<&NodeInfo> = same_file_methods.iter()
+                            .filter(|n| n.name.starts_with(&caller_prefix))
+                            .copied()
+                            .collect();
+                        if !caller_scoped.is_empty() { return caller_scoped; }
+                    }
+                }
             }
         }
         return exact; // empty
@@ -1406,3 +1418,52 @@ mod call_edge_tests {
         assert_eq!(receiver_edge.unwrap().target_id, 2);
     }
 }
+
+#[cfg(test)]
+mod inline_new_type_tests {
+    use super::extract_inline_new_type;
+
+    #[test]
+    fn parens_new_uppercase() {
+        assert_eq!(extract_inline_new_type("(new Foo)"), Some("Foo".to_string()));
+    }
+
+    #[test]
+    fn parens_new_with_args() {
+        // (new Foo('arg')) — parens and constructor args
+        assert_eq!(extract_inline_new_type("(new Foo('arg'))"), Some("Foo".to_string()));
+    }
+
+    #[test]
+    fn no_parens_new_uppercase() {
+        assert_eq!(extract_inline_new_type("new Bar"), Some("Bar".to_string()));
+    }
+
+    #[test]
+    fn underscore_prefix_accepted() {
+        assert_eq!(extract_inline_new_type("new _Factory"), Some("_Factory".to_string()));
+    }
+
+    #[test]
+    fn dollar_prefix_accepted() {
+        assert_eq!(extract_inline_new_type("new $Service"), Some("$Service".to_string()));
+    }
+
+    #[test]
+    fn lowercase_constructor_rejected() {
+        // `new foo()` — lowercase, should return None to avoid false positives
+        assert_eq!(extract_inline_new_type("new foo"), None);
+    }
+
+    #[test]
+    fn not_a_new_expression() {
+        // plain receiver name — no `new` keyword
+        assert_eq!(extract_inline_new_type("myVar"), None);
+    }
+
+    #[test]
+    fn new_without_whitespace_is_not_new_keyword() {
+        // `newFoo` — not a `new` keyword, just an identifier
+        assert_eq!(extract_inline_new_type("newFoo"), None);
+    }
+}

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

@@ -95,10 +95,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"))
@@ -196,13 +204,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; }
@@ -230,9 +383,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);
@@ -479,7 +632,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)
         }
@@ -642,7 +795,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(),
@@ -796,7 +949,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"),
@@ -2537,4 +2690,77 @@ 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);
     }
+
+
+    /// 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<_>>()
+        );
+    }
 }