Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
feat(graph): type a Go receiver from its declaration (#1674)
Raghav Chamadiya662ebb118364
diff --git a/packages/core/src/repowise/core/ingestion/call_resolver.py b/packages/core/src/repowise/core/ingestion/call_resolver.pyindex aadb18146..e3c43587e 100644--- a/packages/core/src/repowise/core/ingestion/call_resolver.py+++ b/packages/core/src/repowise/core/ingestion/call_resolver.py@@ -113,9 +113,14 @@ _CPP_STRATEGIES = _LanguageCallStrategies(free=("_resolve_cpp_same_target",))# Rust's crate-root strategy is deliberately absent: it runs for every language# today, and gating it here would drop crate-name receivers in mixed repos._LANGUAGE_CALL_STRATEGIES: dict[str, _LanguageCallStrategies] = {+ # Go's package tier runs first and claims ``pkg.Func()`` outright, so a+ # package qualifier never reaches the typed fallback — 41% of gitleaks'+ # lowercase-receiver misses are package names, and this is what keeps them+ # out of it."go": _LanguageCallStrategies(free=("_resolve_go_same_package",),member=("_resolve_go_package_call",),+ member_fallback=_TYPED_RECEIVER,),# Kotlin shares the JVM tiers but not the typed-receiver fallback: it has# no declaration shapes yet, so registering it would promise a resolutiondiff --git a/packages/core/src/repowise/core/ingestion/languages/receiver_types.py b/packages/core/src/repowise/core/ingestion/languages/receiver_types.pyindex 329ae75c1..6eaaf0452 100644--- a/packages/core/src/repowise/core/ingestion/languages/receiver_types.py+++ b/packages/core/src/repowise/core/ingestion/languages/receiver_types.py@@ -3,8 +3,11 @@``user.save()`` names no type, so member resolution has nothing to look up.The declaration that gives ``user`` its type is either inside the same function— a parameter, a local, a catch or loop binding — or, when the receiver is a-field, at the enclosing class's own scope. Both are written ``T name``, so one-scan finds both and only the span they are read back over differs.+field, at the enclosing class's own scope. In the C family both are written+``T name``, so one scan finds both and only the span they are read back over+differs. A language may order them the other way round: Go writes ``name T``+and declares a method's receiver in the signature, which the body span already+covers.The scan is allowed to be wrong. Nothing it returns becomes an edge until theresolver has checked that the type actually declares the method, so a@@ -88,10 +91,68 @@ _PY_CONSTRUCTED = re.compile(r"(?m)^[ \t]*(?P<name>[a-z_]\w*)\s*=\s*(?P<type>[A-Z]\w*)\s*\(")+# Go writes the name before the type, so none of the C-family shapes above+# match a line of it. Two further differences decide these patterns.+#+# A type name may be lowercase, because that is how Go spells an unexported+# one, and a private method hangs off exactly those. Admitting lowercase is+# only safe because the language spec carries every predeclared identifier in+# ``builtin_types``, so ``string`` and ``error`` are refused downstream rather+# than looked up.+#+# The receiver a method is declared on — ``func (s *Server) handle()`` — is+# written in the signature rather than the body, and it is the largest shape+# by some way: 50.2% of the reachable population over five Go repos, against+# 24.1% for parameters and 21.5% for composite literals. It needs no scope of+# its own, because a function symbol's span starts at its ``func`` line, so+# the body scan already reads it.+_GO_NAME = r"[a-z_]\w*"+_GO_TYPE = r"[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?"++# A parameter, a named return, or a method's own receiver: ``name Type``+# juxtaposed before a comma or the end of the list. Juxtaposition is a+# declaration nearly everywhere it is legal in Go, which is why this needs+# less guarding than the C family's did.+#+# ``func (s *Server) handle()`` needs no pattern of its own — the receiver+# group presents as ``s *Server)`` and is matched here. A separate anchored+# pattern for it was measured and removed: it added a whole-file scan and+# changed no edge on any of the five Go repos.+#+# ``a * b`` is not matched because gofmt spaces a binary operator on both+# sides while a pointer type binds tight, and Go source is gofmt'd.+_GO_PARAM = re.compile(+ rf"(?<![\w.])(?P<name>{_GO_NAME})\s+\*?(?P<type>{_GO_TYPE})\s*(?=[,)])"+)++# ``x := Foo{}``, ``x := &Foo{}``, ``x := y.(Foo)`` and ``x, ok := y.(Foo)``.+# One scan rather than two: both shapes are a short declaration whose type is+# written outright, and they differ only in what brackets it. The closing+# ``{`` or ``)`` is what tells them from ``x := f()``, whose type is a return+# value this phase deliberately does not chase.+#+# ``x := []Foo{}`` and ``x := map[k]Foo{}`` match nothing on purpose: the+# value is a slice or a map, and typing ``x`` as ``Foo`` would be wrong rather+# than merely unhelpful.+_GO_SHORT_DECL = re.compile(+ rf"(?<![\w.])(?P<name>{_GO_NAME})\s*(?:,\s*{_GO_NAME}\s*)?:="+ rf"\s*(?:&|[\w.]+\.\(\*?)?(?P<type>{_GO_TYPE})\s*(?:\{{|\))"+)++# ``var x Foo`` / ``var x *Foo``. The smallest shape in every Go repo+# measured — 2.5% of the reachable population — and kept only because it is+# the one shape neither pattern above reaches.+_GO_VAR_DECL = re.compile(rf"(?<![\w.])var\s+(?P<name>{_GO_NAME})\s+\*?(?P<type>{_GO_TYPE})")+_C_FAMILY = (_TYPED_DECLARATION, _INFERRED_FROM_NEW)+# No Go shape captures a closer, so every Go declaration carries ``""`` and+# class scope would drop all of them. That is the intended reading: Go is not+# in IMPLICIT_FIELD_LANGUAGES and must not be.+_GO_FAMILY = (_GO_PARAM, _GO_SHORT_DECL, _GO_VAR_DECL)_LANGUAGE_PATTERNS: dict[str, tuple[re.Pattern[str], ...]] = {"csharp": _C_FAMILY,+ "go": _GO_FAMILY,"java": _C_FAMILY,"python": (_PY_ANNOTATED, _PY_CONSTRUCTED),}@@ -107,6 +168,7 @@ IMPLICIT_FIELD_LANGUAGES = frozenset({"csharp", "java"})_LANGUAGE_COMMENTS: dict[str, re.Pattern[str]] = {"csharp": _LINE_COMMENT,+ "go": _LINE_COMMENT,"java": _LINE_COMMENT,"python": _HASH_COMMENT,}diff --git a/tests/unit/ingestion/test_receiver_types.py b/tests/unit/ingestion/test_receiver_types.pyindex 482a1df43..1d23ecd92 100644--- a/tests/unit/ingestion/test_receiver_types.py+++ b/tests/unit/ingestion/test_receiver_types.py@@ -224,8 +224,83 @@ class TestRefusals:assert declared_types("void run() { // a Node node; once lived here\n }", "java") == {}def test_an_unregistered_language_yields_nothing(self) -> None:- body = "func run(w *TimerWheel) { }"- assert declared_types(body, "go") == {}+ # Kotlin rather than Go: Go registered its shapes and now types this+ # exact line. Kotlin is still one of the languages P8 left unattempted.+ body = "fun run(w: TimerWheel) { }"+ assert declared_types(body, "kotlin") == {}+++class TestGoShapes:+ """Go writes ``name T``, which is the reverse of every other shape here.++ The receiver a method is declared on is the largest share of the reachable+ population — 56.5% over five Go repos — and it needs no scope of its own,+ because a function symbol's span starts at its ``func`` line.+ """++ def test_a_methods_own_receiver(self) -> None:+ body = "func (s *Server) handle() { s.route() }"+ assert declared_types(body, "go")["s"] == "Server"++ def test_a_value_receiver(self) -> None:+ body = "func (c Config) apply() { c.merge() }"+ assert declared_types(body, "go")["c"] == "Config"++ def test_a_parameter(self) -> None:+ body = "func run(d *Detector, n int) { d.Detect() }"+ assert declared_types(body, "go")["d"] == "Detector"++ def test_a_named_return(self) -> None:+ body = "func build() (out *Report, err error) { out.Write() }"+ assert declared_types(body, "go")["out"] == "Report"++ def test_a_composite_literal(self) -> None:+ assert declared_types("func f() { r := Rule{} ; r.Match() }", "go")["r"] == "Rule"++ def test_an_addressed_composite_literal(self) -> None:+ assert declared_types("func f() { r := &Rule{} }", "go")["r"] == "Rule"++ def test_a_qualified_composite_literal_keeps_the_bare_name(self) -> None:+ assert declared_types("func f() { a := config.Allowlist{} }", "go")["a"] == "Allowlist"++ def test_a_type_assertion(self) -> None:+ assert declared_types("func f() { w, ok := r.(*Writer) }", "go")["w"] == "Writer"++ def test_a_var_declaration(self) -> None:+ assert declared_types("func f() { var vc ViperConfig }", "go")["vc"] == "ViperConfig"++ def test_an_unexported_type_is_admitted(self) -> None:+ """A private method hangs off an unexported type, so refusing one on+ case would refuse most of what this mechanism exists to reach."""+ assert declared_types("func (s *startEnd) add() { }", "go")["s"] == "startEnd"++ def test_a_predeclared_type_is_refused(self) -> None:+ """Admitting a lowercase type is only safe because these are dropped."""+ assert declared_types("func f(name string, n int) { }", "go") == {}++ def test_a_constructor_call_names_no_type(self) -> None:+ """``x := NewFoo()`` types ``x`` only via the callee's return type,+ which is a second lookup this mechanism does not do."""+ assert declared_types("func f() { d := NewDetector() }", "go") == {}++ def test_a_slice_literal_does_not_type_its_element(self) -> None:+ """``x`` is a slice of Rule, not a Rule, so typing it would be wrong."""+ assert declared_types("func f() { rs := []Rule{} }", "go") == {}++ def test_a_map_literal_does_not_type_its_value(self) -> None:+ assert declared_types("func f() { m := map[string]Rule{} }", "go") == {}++ def test_a_multiplication_is_not_a_pointer_declaration(self) -> None:+ """gofmt spaces a binary operator on both sides and binds a pointer+ type tight, which is the whole of what separates these two."""+ assert declared_types("func f() { n := total(count * size) }", "go") == {}++ def test_a_declaration_in_a_line_comment_is_ignored(self) -> None:+ assert declared_types("func f() { // a *Rule rule once lived here\n }", "go") == {}++ def test_two_types_for_one_name_yields_neither(self) -> None:+ body = "func f(r *Rule) { r := Config{} }"+ assert declared_types(body, "go")["r"] is Noneclass TestClassScope:@@ -282,9 +357,19 @@ class TestClassScope:def test_the_language_set_is_what_the_patterns_declare() -> None:"""Excluding a language means removing its shapes, not gating a caller."""- assert set(RECEIVER_TYPE_LANGUAGES) == {"csharp", "java", "python"}+ assert set(RECEIVER_TYPE_LANGUAGES) == {"csharp", "go", "java", "python"}+++def test_go_is_not_a_field_language() -> None:+ """Go declares no field this mechanism can read, and must not claim to.++ Its shapes capture no closer, so class scope would drop every one of them+ anyway — but the set is the contract, and a package-level ``var`` is a+ wider scope than a field rather than the same one.+ """+ assert "go" not in IMPLICIT_FIELD_LANGUAGES[email protected]("language", ["java", "csharp", "python"])[email protected]("language", ["java", "csharp", "python", "go"])def test_an_empty_body_is_not_an_error(language: str) -> None:assert declared_types("", language) == {}