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 }; + } +}