diff --git a/backend/languages/typescript.py b/backend/languages/typescript.py
index eb5ce02..0cb0f6d 100644
--- a/backend/languages/typescript.py
+++ b/backend/languages/typescript.py
@@ -30,14 +30,22 @@
Calls resolved: `foo()`, `new Foo()`, `this.m()`, `Class.staticM()`, `ns.f()`
and `variable.m()` when the variable's class is known from a parameter
annotation, `const x: Foo` or `const x = new Foo()` - so annotated code
-yields more edges than untyped code, but through the same path.
+yields more edges than untyped code, but through the same path. ``,
+`...` and `` resolve the same way, anchored to the
+opening tag's name - JSX desugars to a call, so mounting a component is a
+call from the function that renders it. A lowercase tag (`
`) is a DOM
+element, not a call, by JSX's own capitalization convention; a fragment
+(`<>...>`) has no name and is never a call. A tag naming a class resolves
+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 inheritance (`super`, inherited
-methods); no dynamic calls (`obj[key]()`, `.call`, `.apply`); a function
-passed as a value (`items.map(fn)`) isn't a call; JSX elements (``)
-aren't calls; a getter or setter runs on property access, which isn't a call;
-`export * as ns` isn't followed; and top-level statements belong to no Function.
+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.
"""
from __future__ import annotations
@@ -284,6 +292,24 @@ def _extract_params(fn_node: Node, source: bytes) -> list[dict]:
return params
+# jsx_opening_element (the `` half of a paired `...`) and
+# jsx_self_closing_element (``) both carry a `name` field; a fragment's
+# opening tag (`<>`) has none.
+_JSX_TAG_NODE_TYPES = frozenset({"jsx_opening_element", "jsx_self_closing_element"})
+
+
+def _is_intrinsic_jsx_tag(name_node: Node) -> bool:
+ """`` (lowercase first letter) is a DOM element, not a call; `` / `<_Foo />` are."""
+ first = (name_node.text or b"")[:1]
+ return first.islower()
+
+
+def _anchor_line(node: Node) -> int:
+ """A method name on a later line than its object (a chain) is where the wire should leave from."""
+ anchor = node.child_by_field_name("property") if node.type == "member_expression" else None
+ return (anchor or node).start_point[0] + 1
+
+
class _CallCollector:
"""Collects (lineno, callee-id) pairs inside one function body.
@@ -302,9 +328,13 @@ def visit(self, node: Node) -> None:
if func is not None:
target = self.resolver(func, is_new)
if target:
- # a method name on a later line than its object (a chain) is where the wire should leave from
- anchor = func.child_by_field_name("property") if func.type == "member_expression" else None
- self.found.append(((anchor or func).start_point[0] + 1, target))
+ self.found.append((_anchor_line(func), target))
+ elif node.type in _JSX_TAG_NODE_TYPES:
+ name = node.child_by_field_name("name")
+ if name is not None and not (name.type == "identifier" and _is_intrinsic_jsx_tag(name)):
+ target = self.resolver(name, False)
+ if target:
+ self.found.append((_anchor_line(name), target))
for child in node.children:
self.visit(child)
diff --git a/sample_typescript_project/List.tsx b/sample_typescript_project/List.tsx
new file mode 100644
index 0000000..bc9ba87
--- /dev/null
+++ b/sample_typescript_project/List.tsx
@@ -0,0 +1,20 @@
+import { Row } from "./formatting";
+import { Item } from "./models";
+
+/**
+ * A function component renders another named component (a Wire to Row), a
+ * lowercase host element and a fragment (neither is a Wire), and a class
+ * tag (Item has no single id in this plugin, so it stays unresolved too).
+ */
+export function List({ items }: { items: Item[] }) {
+ return (
+ <>
+
+ {items.map((item) => (
+
+ ))}
+
+
+ >
+ );
+}
diff --git a/sample_typescript_project/formatting.jsx b/sample_typescript_project/formatting.jsx
index 72c1e55..0d14268 100644
--- a/sample_typescript_project/formatting.jsx
+++ b/sample_typescript_project/formatting.jsx
@@ -6,3 +6,8 @@ function label(result) {
export function renderRow(result) {
return {label(result)};
}
+
+/** The JSX-mounted counterpart to renderRow: same content, called as a component. */
+export function Row({ item }) {
+ return {item.name};
+}