Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

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.py
index 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.py
index 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_CHECKING
from .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_KINDS
keyword_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 name
diff --git a/packages/core/src/repowise/core/analysis/health/dataflow/dialects/go.py b/packages/core/src/repowise/core/analysis/health/dataflow/dialects/go.py
index 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_CHECKING
from .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.py
index 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_CHECKING
from .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.py
index 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.py
index 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_CHECKING
from .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 and
diff --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.py
index 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_CHECKING
from .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.py
index 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] = typ
return found
diff --git a/tests/unit/health/test_extract_method_render.py b/tests/unit/health/test_extract_method_render.py
index 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 - 1
node = 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]