[Bug]: Same-named types under different owners cause merged declarations or missing call relationships #5185

import argparse
import contextlib
import importlib
import io
import subprocess
import sys
import tempfile
from pathlib import Path

from graphify.extract import extract
from tree_sitter import Language, Parser


CASES = [
    ("Java", "java", "tree_sitter_java", "language", """class OWNER {
    static class INNER {
        void setEnabled(boolean value) {}
    }
}
"""),
    ("C#", "cs", "tree_sitter_c_sharp", "language", """class OWNER {
    public class INNER {
        public void setEnabled(bool value) {}
    }
}
"""),
    ("C++", "cpp", "tree_sitter_cpp", "language", """struct OWNER {
    struct INNER {
        void setEnabled(bool value) {}
    };
};
"""),
    ("Kotlin", "kt", "tree_sitter_kotlin", "language", """class OWNER {
    class INNER {
        fun setEnabled(value: Boolean) {}
    }
}
"""),
    ("Scala", "scala", "tree_sitter_scala", "language", """class OWNER {
    class INNER {
        def setEnabled(value: Boolean): Unit = {}
    }
}
"""),
    ("Swift", "swift", "tree_sitter_swift", "language", """class OWNER {
    class INNER {
        func setEnabled(_ value: Bool) {}
    }
}
"""),
    ("TypeScript", "ts", "tree_sitter_typescript", "language_typescript", """namespace OWNER {
    export class INNER {
        setEnabled(value: boolean) {}
    }
}
"""),
]


def main():
    arguments = argparse.ArgumentParser()
    arguments.add_argument("--case", type=int, choices=range(2 * len(CASES)))
    case = arguments.parse_args().case
    if case is None:
        print("| Language | Second nested type | Types (actual / expected) | Methods (actual / expected) |")
        print("|---|---|---:|---:|", flush=True)
        for index in range(2 * len(CASES)):
            subprocess.run([sys.executable, __file__, "--case", str(index)], check=True)
        return

    label, suffix, module, language_fn, template = CASES[case // 2]
    second_name = ("Builder", "SecondBuilder")[case % 2]
    grammar = importlib.import_module(module)
    parser = Parser(Language(getattr(grammar, language_fn)()))
    source = template.replace("OWNER", "Left").replace("INNER", "Builder")
    source += template.replace("OWNER", "Right").replace("INNER", second_name)
    assert not parser.parse(source.encode()).root_node.has_error, label
    with tempfile.TemporaryDirectory() as temporary:
        root = Path(temporary)
        path = root / f"Identity.{suffix}"
        path.write_text(source, encoding="utf-8")
        with contextlib.redirect_stdout(io.StringIO()):
            result = extract(
                [path], root=root, cache_root=root / "cache", parallel=False
            )
        assert not result.get("failed_sources"), result.get("failed_sources")
        assert not result.get("skipped_sources"), result.get("skipped_sources")
        types = {
            node["id"] for node in result["nodes"]
            if node.get("source_file")
            and node.get("label") in {"Builder", "SecondBuilder"}
        }
        methods = {
            node["id"] for node in result["nodes"]
            if node.get("source_file") and node.get("label") == ".setEnabled()"
        }
        print(f"| {label} | `{second_name}` | {len(types)} / 2 | {len(methods)} / 2 |")


if __name__ == "__main__":
    main()

import argparse
import contextlib
import importlib
import io
from pathlib import Path
import subprocess
import sys
import tempfile

from graphify.extract import extract
from tree_sitter import Language, Parser


CASES = [
    ("Java qualified", "java", "tree_sitter_java",
     "class Left { static class Builder {\n void setEnabled(boolean v) {}\n} }\n",
     "class Caller { void run(Left.Builder b) { b.setEnabled(true); } }\n",
     "class Right { static class Builder {\n void setEnabled(boolean v) {}\n} }\n"),
    ("C# nested", "cs", "tree_sitter_c_sharp",
     "public class Left { public class Builder {\n public void setEnabled(bool v) {}\n} }\n",
     "public class Caller { public void run(Left.Builder b) { b.setEnabled(true); } }\n",
     "public class Right { public class Builder {\n public void setEnabled(bool v) {}\n} }\n"),
    ("C# namespace", "cs", "tree_sitter_c_sharp",
     "namespace Left { public class Builder {\n public void setEnabled(bool v) {}\n} }\n",
     "public class Caller { public void run(Left.Builder b) { b.setEnabled(true); } }\n",
     "namespace Right { public class Builder {\n public void setEnabled(bool v) {}\n} }\n"),
    ("Kotlin imported object", "kt", "tree_sitter_kotlin",
     "package left\nobject Builder {\n fun setEnabled(v: Boolean) {}\n}\n",
     "import left.Builder\nclass Caller {\n fun run() { Builder.setEnabled(true) }\n}\n",
     "package right\nobject Builder {\n fun setEnabled(v: Boolean) {}\n}\n"),
    ("Swift static", "swift", "tree_sitter_swift",
     "class Builder {\n static func setEnabled(_ v: Bool) {}\n}\n",
     "class Caller {\n func run() { Builder.setEnabled(true) }\n}\n",
     "class Right {\n class Builder {\n  static func setEnabled(_ v: Bool) {}\n }\n}\n"),
]


def main():
    arguments = argparse.ArgumentParser()
    arguments.add_argument("--case", type=int, choices=range(len(CASES)))
    case = arguments.parse_args().case
    if case is None:
        print("| Form | Competitor added | Distinct setter nodes (actual / expected) | Correct calls (actual / expected) |")
        print("|---|---|---:|---:|", flush=True)
        for index in range(len(CASES)):
            subprocess.run([sys.executable, __file__, "--case", str(index)], check=True)
        return
    label, suffix, module, target, caller, competitor = CASES[case]
    grammar = importlib.import_module(module)
    parser = Parser(Language(grammar.language()))
    assert all(not parser.parse(s.encode()).root_node.has_error
               for s in (target, caller, competitor)), label
    with tempfile.TemporaryDirectory() as directory:
        root = Path(directory)
        left, use, right = root / f"Left.{suffix}", root / f"Caller.{suffix}", root / f"Right.{suffix}"
        left.write_text(target, encoding="utf-8")
        use.write_text(caller, encoding="utf-8")
        original_target = None
        for competing in (False, True):
            paths = [left, use]
            if competing:
                right.write_text(competitor, encoding="utf-8")
                paths.append(right)
            # Independent cold extraction isolates competition from cache effects.
            with contextlib.redirect_stdout(io.StringIO()):
                result = extract(paths, root=root, cache_root=root / str(competing), parallel=False)
            assert not result["failed_sources"], result["failed_sources"]
            assert not result["skipped_sources"], result["skipped_sources"]
            nodes = {n["id"]: n for n in result["nodes"]}
            setters = {n["id"] for n in nodes.values()
                       if n.get("source_file") and n["label"] == ".setEnabled()"}
            targets = {nid for nid in setters
                       if Path(nodes[nid]["source_file"]).name == left.name}
            assert len(setters) == 1 + competing and len(targets) == 1
            if original_target is None:
                original_target = targets
            assert targets == original_target
            calls = [e for e in result["edges"]
                     if e["relation"] == "calls" and e["target"] in setters
                     and nodes[e["source"]]["label"].lstrip(".") == "run()"
                     and Path(nodes[e["source"]].get("source_file", "")).name == use.name]
            assert all(e["target"] in targets for e in calls), "wrong target"
            added = "yes" if competing else "no"
            print(f"| {label} | {added} | {len(setters)} / {1 + competing} | {len(calls)} / 1 |")


if __name__ == "__main__":
    main()