From 1cefaba3fc4a43ddc658bb581b235fa75702c67f Mon Sep 17 00:00:00 2001 From: MCR-3 Date: Tue, 22 Sep 2026 10:23:07 +0200 Subject: [PATCH] feat: resolve this.field.method() and variable.field.method() in the TypeScript/JavaScript plugin Tracks each class's field types - constructor parameter properties (constructor(private x: Type)) and typed field declarations (x: Type;) - and extends the resolver to unwrap one more hop through them: this.field.method() using the enclosing class's field types, and variable.field.method() using the variable's own type plus those field types. The field's type name is resolved against the module that declared the field, not the caller's, since that's where its import actually lives. Getter-backed properties and static field chains (Class.field.method()) stay unresolved, as does anything three or more hops deep - all out of scope per the issue, and each just falls out of the lookup finding nothing rather than needing a special case. Closes #20 --- backend/languages/typescript.py | 103 +++++++++++++++++++++--- sample_typescript_project/catalog.ts | 10 +++ sample_typescript_project/repository.ts | 5 ++ 3 files changed, 109 insertions(+), 9 deletions(-) create mode 100644 sample_typescript_project/catalog.ts create mode 100644 sample_typescript_project/repository.ts diff --git a/backend/languages/typescript.py b/backend/languages/typescript.py index 0cb0f6d..005f57e 100644 --- a/backend/languages/typescript.py +++ b/backend/languages/typescript.py @@ -39,13 +39,22 @@ to nothing (see the member-resolution limit below: a class has no single id in this plugin, only its methods do). -Real limits, in the spirit of the other plugins' resolvers: one object and -one member only (no `this.a.b()`, no ``); no inheritance -(`super`, inherited methods); no dynamic calls (`obj[key]()`, `.call`, -`.apply`); a function passed as a value (`items.map(fn)`) isn't a call; a -getter or setter runs on property access, which isn't a call; `export * as -ns` isn't followed; hand-written `React.createElement(...)` isn't recognized -as a JSX-shaped call; and top-level statements belong to no Function. +One extra hop is tracked for a field access: `this.field.m()` and +`variable.field.m()` resolve when the field's own type is known - a +constructor parameter property (`constructor(private x: Type)`) or a typed +field declaration (`x: Type;`) - the same way `variable.m()` needs the +variable's type known. A getter-backed "field" (`get x(): Type`) isn't +tracked, so a call through one is left unresolved, not misattributed. + +Real limits, in the spirit of the other plugins' resolvers: one object, one +field and one member at most (no `this.a.b.c()`, no ``); no +inheritance (`super`, inherited methods); no dynamic calls (`obj[key]()`, +`.call`, `.apply`); a function passed as a value (`items.map(fn)`) isn't a +call; a getter or setter runs on property access, which isn't a call; +`export * as ns` isn't followed; hand-written `React.createElement(...)` +isn't recognized as a JSX-shaped call; a static field chain +(`Class.field.m()`) isn't tracked, only an instance's; and top-level +statements belong to no Function. """ from __future__ import annotations @@ -102,6 +111,9 @@ class _ModuleInfo: top_level: dict[str, str] = field(default_factory=dict) # fn name -> function id # class (or object literal) name -> {member name -> function id} classes: dict[str, dict[str, str]] = field(default_factory=dict) + # class name -> {field name -> declared type name}, from a typed field declaration or a + # constructor parameter property; object literals have neither, so this is always empty for one + field_types: dict[str, dict[str, str]] = field(default_factory=dict) imports: dict[str, _Import] = field(default_factory=dict) # local name -> import export_aliases: dict[str, str] = field(default_factory=dict) # `export { local as name }`: name -> local default_export: str | None = None # local name behind `export default` @@ -558,14 +570,17 @@ def _register_declaration( def _register_members( self, mod: _ModuleInfo, owner: str, container: Node | None, source: bytes, source_lines: list[str] ) -> None: - """Registers a class body's or object literal's function members as `owner.member`.""" + """Registers a class body's or object literal's function members as `owner.member`, and a class's field types.""" members = mod.classes.setdefault(owner, {}) + field_types = mod.field_types.setdefault(owner, {}) if container is None: return for member in container.children: fn_node = member if member.type == "method_definition": name = _member_name(member.child_by_field_name("name"), source) + if name == "constructor": + self._register_parameter_properties(field_types, member, source) if name is None or member.child_by_field_name("body") is None: continue accessor = next((c.type for c in member.children if c.type in ("get", "set")), None) @@ -574,6 +589,10 @@ def _register_members( elif member.type in ("public_field_definition", "pair"): key = member.child_by_field_name("name" if member.type == "public_field_definition" else "key") name = _member_name(key, source) + if member.type == "public_field_definition": # object literals have no type annotations to read + type_name = _type_name(member.child_by_field_name("type"), source) + if name and type_name: + field_types[name] = type_name value = member.child_by_field_name("value") if name is None or value is None or value.type not in _FUNCTION_NODE_TYPES: continue @@ -583,6 +602,22 @@ def _register_members( info = self._register_function(mod, fn_node, member, name, owner, source, source_lines) members[name] = info.id + @staticmethod + def _register_parameter_properties(field_types: dict[str, str], ctor: Node, source: bytes) -> None: + """`constructor(private x: Type)` promotes a parameter to an instance field of the same name and type.""" + params = ctor.child_by_field_name("parameters") + if params is None: + return + for param in params.children: + if param.type not in ("required_parameter", "optional_parameter"): + continue + if not any(c.type in ("accessibility_modifier", "readonly") for c in param.children): + continue # a plain parameter, not one promoted to a field + pattern = param.child_by_field_name("pattern") + type_name = _type_name(param.child_by_field_name("type"), source) + if pattern is not None and pattern.type == "identifier" and type_name: + field_types[_text(pattern, source)] = type_name + def _register_function( self, mod: _ModuleInfo, @@ -738,6 +773,53 @@ def _method_of(self, mod: _ModuleInfo, class_name: str, method: str) -> str | No symbol = self._imported_symbol(mod, class_name) return symbol[0].classes.get(symbol[1], {}).get(method) if symbol else None + def _field_type(self, mod: _ModuleInfo, class_name: str, field_name: str) -> tuple[_ModuleInfo, str] | None: + """(module to resolve the field's type name in, type name) for `class_name`'s field `field_name`. + + The type name is only meaningful against the module that declared the field - its own file's + imports, not the caller's - which is why this returns a module alongside the name, the same + shape `_imported_symbol` hands back. + """ + if class_name in mod.field_types: + type_name = mod.field_types[class_name].get(field_name) + return (mod, type_name) if type_name else None + symbol = self._imported_symbol(mod, class_name) + if symbol is None: + return None + owner_mod, local_name = symbol + type_name = owner_mod.field_types.get(local_name, {}).get(field_name) + return (owner_mod, type_name) if type_name else None + + def _resolve_field_method( + self, + mod: _ModuleInfo, + class_name: str | None, + local_types: dict[str, str], + field_access: Node, + method: str, + source: bytes, + ) -> str | None: + """`this.field.method()` / `variable.field.method()`: one more hop via a known field type. + + `field_access` is the `this.field` / `variable.field` member_expression; its own object must + be `this` or a plain identifier - a third hop (`this.a.b.c()`) has no further field type to + follow and is left unresolved, same as any other chain this deep. + """ + inner_obj = field_access.child_by_field_name("object") + field_name = _member_name(field_access.child_by_field_name("property"), source) + if inner_obj is None or field_name is None: + return None + if inner_obj.type == "this": + field_owner = class_name + elif inner_obj.type == "identifier": + field_owner = local_types.get(_text(inner_obj, source)) + else: + return None + if field_owner is None: + return None + found = self._field_type(mod, field_owner, field_name) + return self._method_of(found[0], found[1], method) if found else None + def _make_resolver(self, mod: _ModuleInfo, class_name: str | None, local_types: dict[str, str]): source = self.sources_bytes[mod.rel_path] @@ -753,7 +835,8 @@ def resolve(func_node: Node, is_new: bool = False) -> str | None: return symbol[0].top_level.get(symbol[1]) if symbol else None # this.m(...) / ns.f(...) / Class.staticM(...) / variable.m(...) / new ns.Foo(...) - # - one object, one member: no deeper chains (`this.a.b()`), like the other plugins. + # - one object, one member, plus the one extra hop below for a field access + # (this.field.m() / variable.field.m()); no deeper chains (`this.a.b.c()`). if func_node.type == "member_expression": obj = func_node.child_by_field_name("object") member = _member_name(func_node.child_by_field_name("property"), source) @@ -761,6 +844,8 @@ def resolve(func_node: Node, is_new: bool = False) -> str | None: return None if obj.type == "this": return self._method_of(mod, class_name, member) if class_name and not is_new else None + if obj.type == "member_expression": + return None if is_new else self._resolve_field_method(mod, class_name, local_types, obj, member, source) if obj.type != "identifier": return None name = _text(obj, source) diff --git a/sample_typescript_project/catalog.ts b/sample_typescript_project/catalog.ts new file mode 100644 index 0000000..0eecece --- /dev/null +++ b/sample_typescript_project/catalog.ts @@ -0,0 +1,10 @@ +import { Repository } from "./repository"; + +/** Constructor-injected dependency: this.repo's type comes from the parameter property. */ +export class Catalog { + constructor(private repo: Repository) {} + + lookup(name: string) { + return this.repo.find(name); + } +} diff --git a/sample_typescript_project/repository.ts b/sample_typescript_project/repository.ts new file mode 100644 index 0000000..d5c1f25 --- /dev/null +++ b/sample_typescript_project/repository.ts @@ -0,0 +1,5 @@ +export class Repository { + find(name: string) { + return { name, weight: 1 }; + } +}