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
refactor(dataflow): give declared-type reading its own home (#3554)
Raghav Chamadiyaee4df5cdf1fd
diff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/base.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/base.pyindex 3db5a1b3f..ca3c908db 100644--- a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/base.py+++ b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/base.py@@ -173,6 +173,48 @@ class DefUseDialect(Protocol):def handler_head(self, handler: Node) -> HandlerHead: ...+@dataclass(frozen=True)+class DeclaredTypes:+ """Reads the type written where a name is declared. A language sets its+ holder / wrapper kinds and, where its declarators add to the type (C++),+ overrides the two hooks below."""++ #: Nodes whose ``type`` field types the names they declare: a typed+ #: parameter, a typed local declaration.+ holder_kinds: frozenset[str] = frozenset()+ #: Declarators between a declared name and its holder (Java's+ #: ``variable_declarator``, C++'s ``init_declarator`` / ``pointer_declarator``).+ wrapper_kinds: frozenset[str] = frozenset()++ def of(self, name: Node) -> str | None:+ """The type written where identifier *name* is declared, or None when+ the declaration writes none, or only asks for inference (``var``,+ ``auto``). Reads the retained tree around one node: no walk."""+ node, suffix = name.parent, ""+ while node is not None and node.type in self.wrapper_kinds:+ if node.child_by_field_name("dimensions") is not None:+ return None # Java ``int a[]``: the declarator changes the type+ suffix = self._declarator_token(node) + suffix+ node = node.parent+ if node is None or node.type not in self.holder_kinds:+ return None+ typ = node.child_by_field_name("type")+ if typ is None or typ.start_byte <= name.start_byte < typ.end_byte:+ return None+ text = " ".join(node_text(typ).lstrip(":").split())+ if not text or text in _INFERRED_TYPES:+ return None+ return self._type_prefix(node, typ) + text + suffix++ def _declarator_token(self, node: Node) -> str:+ """What declarator *node* adds to the type (C++ ``*`` / ``&``)."""+ return ""++ def _type_prefix(self, holder: Node, typ: Node) -> str:+ """Qualifiers written before the type (C++ ``const``)."""+ return ""++class BaseDefUseDialect:"""Shared machinery for concrete dialects.@@ -520,42 +562,8 @@ class BaseDefUseDialect:repeat it (a Go ``(s *S)``, a Rust ``&self``). Default: none."""return None- # -- declared types ----------------------------------------------------------- #: Nodes whose ``type`` field types the names they declare: a typed- #: parameter, a typed local declaration.- type_holder_kinds: frozenset[str] = frozenset()- #: Declarators between a declared name and its holder (Java's- #: ``variable_declarator``, C++'s ``init_declarator`` / ``pointer_declarator``).- type_wrapper_kinds: frozenset[str] = frozenset()-- def declared_type(self, name: Node) -> str | None:- """The type written where identifier *name* is declared, or None when- the declaration writes none, or only asks for inference (``var``,- ``auto``). Reads the retained tree around one node: no walk."""- node, suffix = name.parent, ""- while node is not None and node.type in self.type_wrapper_kinds:- if node.child_by_field_name("dimensions") is not None:- return None # Java ``int a[]``: the declarator changes the type- suffix = self._declarator_token(node) + suffix- node = node.parent- if node is None or node.type not in self.type_holder_kinds:- return None- typ = node.child_by_field_name("type")- if typ is None or typ.start_byte <= name.start_byte < typ.end_byte:- return None- text = " ".join(node_text(typ).lstrip(":").split())- if not text or text in _INFERRED_TYPES:- return None- return self._type_prefix(node, typ) + text + suffix-- def _declarator_token(self, node: Node) -> str:- """What declarator *node* adds to the type (C++ ``*`` / ``&``)."""- return ""-- def _type_prefix(self, holder: Node, typ: Node) -> str:- """Qualifiers written before the type (C++ ``const``)."""- return ""+ #: How this language writes a declared name's type (see :class:`DeclaredTypes`).+ declared_types: DeclaredTypes = DeclaredTypes()def _receiver(self, names: frozenset[str], **flags: bool) -> Receiver:return Receiver(names, self.member_access_kinds, self.receiver_write_kinds, **flags)diff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/cpp.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/cpp.pyindex 85e144820..fdd114a61 100644--- a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/cpp.py+++ b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/cpp.py@@ -41,6 +41,7 @@ from typing import TYPE_CHECKINGfrom .base import (NO_RECEIVER,BaseDefUseDialect,+ DeclaredTypes,HandlerHead,Occurrence,Receiver,@@ -87,15 +88,32 @@ def _declarator_name(fn_node: Node) -> Node | None:return name+class _CppDeclaredTypes(DeclaredTypes):+ def _declarator_token(self, node: Node) -> str:+ """``*`` for a pointer declarator, ``&`` / ``&&`` for a reference."""+ if node.type == "init_declarator" or not node.children:+ return ""+ return node_text(node.children[0])++ def _type_prefix(self, holder: Node, typ: Node) -> str:+ """``const`` / ``volatile`` written before the type."""+ quals = [+ node_text(c)+ for c in holder.named_children+ if c.type == "type_qualifier" and c.end_byte <= typ.start_byte+ ]+ return "".join(q + " " for q in quals)++class CppDefUseDialect(BaseDefUseDialect):language = "cpp"member_access_kinds = frozenset({_FIELD_EXPRESSION})receiver_write_kinds = _ASSIGN_KINDS | _UPDATE_KINDSkeyword_kinds = frozenset() # C++ has no keyword arguments.- type_holder_kinds = frozenset(- {"parameter_declaration", "optional_parameter_declaration", "declaration"}+ declared_types = _CppDeclaredTypes(+ frozenset({"parameter_declaration", "optional_parameter_declaration", "declaration"}),+ frozenset({"init_declarator", "pointer_declarator", "reference_declarator"}),)- type_wrapper_kinds = frozenset({"init_declarator", "pointer_declarator", "reference_declarator"})def _is_scope_boundary(self, node: Node) -> bool:return node.type in _SCOPE_BOUNDARIES@@ -163,20 +181,6 @@ class CppDefUseDialect(BaseDefUseDialect):quals = {node_text(c) for c in node.children if c.type == "type_qualifier"}return "const" if "const" in quals else None- def _declarator_token(self, node: Node) -> str:- """``*`` for a pointer declarator, ``&`` / ``&&`` for a reference."""- if node.type == "init_declarator" or not node.children:- return ""- return node_text(node.children[0])-- def _type_prefix(self, holder: Node, typ: Node) -> str:- """``const`` / ``volatile`` written before the type."""- quals = [- node_text(c)- for c in holder.named_children- if c.type == "type_qualifier" and c.end_byte <= typ.start_byte- ]- return "".join(q + " " for q in quals)def _own_receiver(self, fn_node: Node, lmap: LanguageNodeMap) -> Receiver | None:"""``this`` for a member function defined in its class (a bare namediff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/go.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/go.pyindex f5153c60b..6d6efdb95 100644--- a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/go.py+++ b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/go.py@@ -23,6 +23,7 @@ from typing import TYPE_CHECKINGfrom .base import (NO_RECEIVER,BaseDefUseDialect,+ DeclaredTypes,Occurrence,Receiver,StatementDefUse,@@ -55,7 +56,7 @@ class GoDefUseDialect(BaseDefUseDialect):language = "go"member_access_kinds = frozenset({"selector_expression"})receiver_write_kinds = _ASSIGN_KINDS | _INC_DEC_KINDS- type_holder_kinds = frozenset({"parameter_declaration", "var_spec"})+ declared_types = DeclaredTypes(frozenset({"parameter_declaration", "var_spec"}))keyword_kinds = frozenset() # Go has no keyword arguments.def _is_scope_boundary(self, node: Node) -> bool:diff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/java.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/java.pyindex 44cf9aff4..1d8b15922 100644--- a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/java.py+++ b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/java.py@@ -27,6 +27,7 @@ from typing import TYPE_CHECKINGfrom .base import (NO_RECEIVER,BaseDefUseDialect,+ DeclaredTypes,HandlerHead,Occurrence,Receiver,@@ -63,10 +64,10 @@ class JavaDefUseDialect(BaseDefUseDialect):language = "java"member_access_kinds = frozenset({"field_access"})receiver_write_kinds = _ASSIGN_KINDS | _UPDATE_KINDS- type_holder_kinds = frozenset(- {"formal_parameter", "local_variable_declaration", "enhanced_for_statement"}+ declared_types = DeclaredTypes(+ frozenset({"formal_parameter", "local_variable_declaration", "enhanced_for_statement"}),+ frozenset({"variable_declarator"}),)- type_wrapper_kinds = frozenset({"variable_declarator"})keyword_kinds = frozenset() # Java has no keyword arguments.def _is_scope_boundary(self, node: Node) -> bool:diff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/python.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/python.pyindex ea7f4d6f7..a643dee33 100644--- a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/python.py+++ b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/python.py@@ -24,6 +24,7 @@ from .base import (NO_RECEIVER,BaseDefUseDialect,Captured,+ DeclaredTypes,HandlerHead,Occurrence,Receiver,@@ -63,7 +64,9 @@ class PythonDefUseDialect(BaseDefUseDialect):language = "python"member_access_kinds = frozenset({"attribute"})receiver_write_kinds = _ASSIGN_KINDS | _AUG_KINDS- type_holder_kinds = frozenset({"typed_parameter", "typed_default_parameter", "assignment"})+ declared_types = DeclaredTypes(+ frozenset({"typed_parameter", "typed_default_parameter", "assignment"})+ )keyword_kinds = frozenset({"keyword_argument"})# A nested ``def`` is visible in the enclosing scope from its statement on.diff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/rust.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/rust.pyindex 48a8deac8..7b6c8147e 100644--- a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/rust.py+++ b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/rust.py@@ -35,6 +35,7 @@ from typing import TYPE_CHECKINGfrom .base import (NO_RECEIVER,BaseDefUseDialect,+ DeclaredTypes,Occurrence,Receiver,StatementDefUse,@@ -102,7 +103,7 @@ class RustDefUseDialect(BaseDefUseDialect):language = "rust"member_access_kinds = frozenset({"field_expression"})receiver_write_kinds = _ASSIGN_KINDS | _AUG_KINDS- type_holder_kinds = frozenset({"parameter", "let_declaration"})+ declared_types = DeclaredTypes(frozenset({"parameter", "let_declaration"}))keyword_kinds = frozenset() # struct-literal field names are not reads.# ``self`` is its own node type in tree-sitter-rust, not an ``identifier``;# without it here every ``self.field`` read would drop its receiver (Go anddiff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/ts_js.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/ts_js.pyindex 22687e474..c15c01c43 100644--- a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/ts_js.py+++ b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/ts_js.py@@ -21,6 +21,7 @@ from typing import TYPE_CHECKINGfrom .base import (BaseDefUseDialect,+ DeclaredTypes,HandlerHead,Occurrence,Receiver,@@ -92,11 +93,26 @@ def _is_static(method: Node) -> bool:return any(c.type == "static" for c in method.children)+class _TsDeclaredTypes(DeclaredTypes):+ def of(self, name: Node) -> str | None:+ """The base rule, plus ``| undefined`` for an optional parameter+ (``x?: T`` holds ``T | undefined`` until something narrows it)."""+ typ = super().of(name)+ if typ is None or name.parent is None or name.parent.type != "optional_parameter":+ return typ+ arms = union_arms(typ)+ if "undefined" in arms:+ return typ+ return f"({typ}) | undefined" if len(arms) == 1 and "=>" in typ else f"{typ} | undefined"++class TsJsDefUseDialect(BaseDefUseDialect):language = "typescript"member_access_kinds = frozenset({"member_expression"})receiver_write_kinds = _ASSIGN_KINDS | _AUG_KINDS | _UPDATE_KINDS- type_holder_kinds = frozenset({"required_parameter", "optional_parameter", "variable_declarator"})+ declared_types = _TsDeclaredTypes(+ frozenset({"required_parameter", "optional_parameter", "variable_declarator"})+ )keyword_kinds = frozenset() # object-property keys are not variable reads.# ``shorthand_property_identifier`` is an object-literal read (``{ days }``# reads the local ``days``). Its ``_pattern`` twin is the destructuring@@ -144,17 +160,6 @@ class TsJsDefUseDialect(BaseDefUseDialect):named = param is not None and param.type == "identifier"return None, node_text(param) if named else None- def declared_type(self, name: Node) -> str | None:- """The base rule, plus ``| undefined`` for an optional parameter- (``x?: T`` holds ``T | undefined`` until something narrows it)."""- typ = super().declared_type(name)- if typ is None or name.parent is None or name.parent.type != "optional_parameter":- return typ- arms = union_arms(typ)- if "undefined" in arms:- return typ- return f"({typ}) | undefined" if len(arms) == 1 and "=>" in typ else f"{typ} | undefined"-def parameter_defs(self, fn_node: Node) -> tuple[Occurrence, ...]:params_node = fn_node.child_by_field_name("parameters")if params_node is None:diff --git a/packages/core/src/repowise/core/analysis/health/refactoring/extract_method.py b/packages/core/src/repowise/core/analysis/health/refactoring/extract_method.pyindex 88d6aa051..e573484e3 100644--- a/packages/core/src/repowise/core/analysis/health/refactoring/extract_method.py+++ b/packages/core/src/repowise/core/analysis/health/refactoring/extract_method.py@@ -752,7 +752,7 @@ def _declared_types(# Tree points are byte columns.node = fn_node.descendant_for_point_range((row, d.column), (row, d.column + len(raw)))if node is not None and node.text == raw:- typ = dialect.declared_type(node)+ typ = dialect.declared_types.of(node)if typ:found[d.var] = typreturn founddiff --git a/tests/unit/health/test_extract_method_render.py b/tests/unit/health/test_extract_method_render.pyindex c82b9a66e..a3a180857 100644--- a/tests/unit/health/test_extract_method_render.py+++ b/tests/unit/health/test_extract_method_render.py@@ -304,7 +304,7 @@ def test_declared_types_are_read_off_the_parse(language: str):for d in fn.def_use.definitions:row = d.line - 1node = fn.fn_node.descendant_for_point_range((row, d.column), (row, d.column + len(d.var)))- found[d.var] = dialect.declared_type(node)+ found[d.var] = dialect.declared_types.of(node)assert {k: found.get(k) for k in _EXPECTED_TYPES[language]} == _EXPECTED_TYPES[language]