fix(resolve): prefer a base CLASS for Python implements edges (#172)

crates/rag-rat-core/src/index/edges/resolve/mod.rs

@@ -590,7 +590,7 @@ pub(crate) fn resolve_symbol<'a>(
         .copied()
         .filter(|symbol| kind_matches(symbol))
         .collect::<Vec<_>>();
-    let preferred = preferred_matches(request.edge_kind, &matches);
+    let preferred = preferred_matches(request.edge_kind, request.source_language, &matches);
     // In languages with separate type/value namespaces (Rust, C, C++), a `references_type`
     // reference must resolve to a type DEFINITION (struct/enum/trait/type/…). If none of the
     // same-named candidates is one, do NOT fall back to a non-type symbol (an `impl` block, a
@@ -736,12 +736,18 @@ pub(crate) fn is_common_member_name(value: &str) -> bool {
 }
 pub(crate) fn preferred_matches<'a>(
     edge_kind: &str,
+    source_language: Option<&str>,
     matches: &[&'a IndexedSymbol],
 ) -> Vec<&'a IndexedSymbol> {
     let preferred_kinds: &[&str] = match edge_kind {
         "calls_name" => &["function", "method"],
         "constructs" => &["struct", "class", "object"],
         "uses_macro" => &["macro"],
+        // Python base-class inheritance emits an `implements` edge to a CLASS — Python has no
+        // traits/interfaces — so prefer class-like kinds for Python (#172). Kept language-scoped so
+        // Kotlin/TS are UNCHANGED: there `implements`/`: I` targets an interface, and a same-named
+        // class must not be preferred over it.
+        "implements" if source_language == Some(Language::Python.as_str()) => &["class", "object"],
         "implements" => &["trait", "interface"],
         "references_type" => &["struct", "enum", "trait", "type", "class", "interface", "object"],
         _ => &[],

crates/rag-rat-core/src/index/edges/resolve/tests.rs

@@ -572,3 +572,58 @@ fn oracle_unaffected_by_import_scope_columns() {
          scope columns must not pull it in"
     );
 }
+
+/// #172: a Python `class Sub(Base)` emits an `implements` edge to `Base`, which is a CLASS (Python
+/// has no traits/interfaces). The resolver must prefer the base CLASS over a same-named non-class
+/// (e.g. a function) — language-scoped, so Kotlin/TS `implements` still prefers an interface.
+#[test]
+fn python_implements_prefers_a_base_class_over_a_non_class() {
+    let conn = seeded_conn();
+    let sub = py_source(&conn, "sub.py");
+    let base = py_source(&conn, "base.py");
+    let other = py_source(&conn, "other.py");
+    // A symbol in sub.py so the resolver knows the reference's source language is Python (a file's
+    // language is inferred from its symbols, and the language-scoped `implements` preference is
+    // what this exercises).
+    py_sym(&conn, sub, "Sub", "sub.py::Sub", "class");
+    // The real base class, and a DECOY same-named non-class (a module-level function `Base`).
+    let base_class = py_sym(&conn, base, "Base", "base.py::Base", "class");
+    let _decoy_fn = py_sym(&conn, other, "Base", "other.py::Base", "function");
+    conn.execute(
+        "INSERT INTO edges(source_file_id, to_name, edge_kind, confidence, resolution, \
+         source_start_byte) VALUES (?1, 'Base', 'implements', 'NameOnly', 'unresolved', 10)",
+        params![sub],
+    )
+    .unwrap();
+    let edge: i64 = conn.query_row("SELECT MAX(id) FROM edges_data", [], |r| r.get(0)).unwrap();
+
+    crate::index::install_scope_view(&conn, NEW, "").unwrap();
+    resolve_all_edges(&conn).unwrap();
+
+    let (to, _confidence, _resolution) = edge_state(&conn, edge);
+    assert_eq!(
+        to,
+        Some(base_class),
+        "implements must prefer the base CLASS, not the decoy function"
+    );
+}
+
+fn py_source(conn: &Connection, path: &str) -> i64 {
+    conn.execute(
+        "INSERT INTO main.files(path, language, kind, sha256, modified_at_ms, indexed_at_ms, \
+         commit_sha, worktree_id) VALUES (?1, 'python', 'source', ?2, 0, 0, ?3, '')",
+        params![path, format!("sha-{path}"), NEW],
+    )
+    .unwrap();
+    conn.last_insert_rowid()
+}
+
+fn py_sym(conn: &Connection, file_id: i64, name: &str, qualified: &str, kind: &str) -> i64 {
+    conn.execute(
+        "INSERT INTO symbols(file_id, language, name, qualified_name, kind, start_byte, end_byte, \
+         start_line, end_line) VALUES (?1, 'python', ?2, ?3, ?4, 0, 10, 1, 1)",
+        params![file_id, name, qualified, kind],
+    )
+    .unwrap();
+    conn.last_insert_rowid()
+}