feat(symbols): break out JS/TS class methods in the definition index

The Python pass already records methods one indent inside a class, but the
JS/TS pass only captured top-level functions, classes and arrow assignments,
so a TypeScript class showed up as a single opaque entry. Track an indent
frame stack the same way the Python side does and read a method declaration
(name + params + opening brace, with TS modifiers/get/set/return types) when
it sits directly in a class body. Control-flow heads that also read as
`word (...) {` are excluded, and a method's own body is not re-scanned, so the
outline now nests JS methods under their class just like Python.

Author: he-yufeng

backend/services/symbols.py

@@ -13,8 +13,8 @@
   Python   ``def`` / ``async def`` / ``class`` at module level, plus methods
            one indent inside a class (recorded with their enclosing class).
   JS / TS  ``function`` / ``async function`` / ``export function`` / ``class``,
-           and ``const name = (...) =>`` / ``const name = function`` style
-           assignments.
+           ``const name = (...) =>`` / ``const name = function`` assignments, and
+           methods one indent inside a class (recorded with their class).
 
 Each entry carries the name, its kind (function / class / method), the
 enclosing class for a method, the file, and a 1-based line number.
@@ -140,28 +140,67 @@ class is a method; a ``def`` nested inside another ``def`` is a local helper
     r"^\s*(?:export\s+)?(?:default\s+)?(?:const|let|var)\s+(" + _IDENT + r")\s*=\s*"
     r"(?:async\s+)?(?:function\b|\*?\s*\([^)]*\)\s*=>|" + _IDENT + r"\s*=>)"
 )
+# A method *declaration* inside a class body: optional TS modifiers, an optional
+# get/set or generator marker, the name, a parameter list, an optional TS return
+# annotation, and the opening brace on the same line. The trailing ``{`` is what
+# separates a declaration (``render() {``) from a call (``render();``).
+_JS_METHOD_RE = re.compile(
+    r"^\s*(?:(?:public|private|protected|readonly|static|async|override|abstract)\s+)*"
+    r"(?:(?:get|set)\s+)?\*?\s*"
+    r"(?P<name>" + _IDENT + r")\s*\([^;]*\)\s*(?::[^={};]+)?\{"
+)
+# Control-flow heads also read as ``word (...) {``; never treat them as methods.
+_JS_NON_METHODS = frozenset(
+    {"if", "for", "while", "switch", "catch", "do", "with", "return", "function", "else"}
+)
 
 
 def _js_definitions(path: str, content: str) -> list[dict]:
     out: list[dict] = []
+    # frames: list of (indent, kind, name) for currently open class/block scopes,
+    # mirroring the Python pass so a method is only read inside a class body and a
+    # method's own body is not re-scanned for nested "methods".
+    frames: list[tuple[int, str, str]] = []
+
     for lineno, raw in enumerate(content.splitlines(), start=1):
         stripped = raw.strip()
         if not stripped or stripped.startswith("//"):
             continue
 
+        indent = _indent_width(raw)
+        while frames and frames[-1][0] >= indent:
+            frames.pop()
+        enclosing = frames[-1] if frames else None
+
         class_match = _JS_CLASS_RE.match(raw)
         if class_match:
-            out.append(_entry(path, "js", class_match.group(1), "class", None, lineno))
+            name = class_match.group(1)
+            parent = enclosing[2] if enclosing and enclosing[1] == "class" else None
+            out.append(_entry(path, "js", name, "class", parent, lineno))
+            frames.append((indent, "class", name))
             continue
 
         func_match = _JS_FUNC_RE.match(raw)
         if func_match:
-            out.append(_entry(path, "js", func_match.group(1), "function", None, lineno))
+            name = func_match.group(1)
+            out.append(_entry(path, "js", name, "function", None, lineno))
+            frames.append((indent, "block", name))
             continue
 
         assign_match = _JS_ASSIGN_RE.match(raw)
         if assign_match:
-            out.append(_entry(path, "js", assign_match.group(1), "function", None, lineno))
+            name = assign_match.group(1)
+            out.append(_entry(path, "js", name, "function", None, lineno))
+            frames.append((indent, "block", name))
+            continue
+
+        if enclosing is not None and enclosing[1] == "class":
+            method_match = _JS_METHOD_RE.match(raw)
+            if method_match:
+                name = method_match.group("name")
+                if name not in _JS_NON_METHODS:
+                    out.append(_entry(path, "js", name, "method", enclosing[2], lineno))
+                    frames.append((indent, "block", name))
 
     return out
 
@@ -437,8 +476,9 @@ def _outline_notes(path: str, lang: str, defs: list[dict], total: int) -> list[s
     notes = [f"{name} defines {', '.join(parts)}, listed in the order they appear."]
     if lang == "js":
         notes.append(
-            "For JS/TS, methods inside a class are not broken out yet; the class "
-            "is listed as a whole."
+            "For JS/TS, class methods are broken out when the class body is "
+            "conventionally indented; arrow-function fields and computed names "
+            "are still listed under the class as a whole."
         )
     notes.append("Regex-based outline: runtime-built or re-exported names may be missed.")
     return notes

tests/test_symbols.py

@@ -114,6 +114,57 @@ def test_class_declaration(self):
         entry = next(d for d in index["definitions"] if d["name"] == "Widget")
         assert entry["kind"] == "class"
 
+    def test_class_methods_are_broken_out(self):
+        code = (
+            "export class Store {\n"
+            "  constructor(state) {\n"
+            "    this.state = state;\n"
+            "  }\n"
+            "  async load(id) {\n"
+            "    return this.fetch(id);\n"
+            "  }\n"
+            "  get size() {\n"
+            "    return this.state.length;\n"
+            "  }\n"
+            "}\n"
+        )
+        index = build_definition_index({"store.ts": code})
+        by_name = {d["name"]: d for d in index["definitions"]}
+        for name in ("constructor", "load", "size"):
+            assert by_name[name]["kind"] == "method"
+            assert by_name[name]["parent"] == "Store"
+            assert by_name[name]["qualname"] == f"Store.{name}"
+
+    def test_typescript_return_type_method(self):
+        code = "class View {\n  render(): JSX.Element {\n    return null;\n  }\n}\n"
+        index = build_definition_index({"view.tsx": code})
+        render = next(d for d in index["definitions"] if d["name"] == "render")
+        assert render["kind"] == "method"
+        assert render["parent"] == "View"
+
+    def test_control_flow_in_method_body_is_not_a_method(self):
+        # `if (...) {` and a method call inside the body read like `name(...) {`
+        # / `name();` — neither should be mistaken for a class member.
+        code = (
+            "class Engine {\n"
+            "  run(items) {\n"
+            "    if (items.length) {\n"
+            "      this.start();\n"
+            "    }\n"
+            "  }\n"
+            "}\n"
+        )
+        index = build_definition_index({"engine.ts": code})
+        names = {d["name"] for d in index["definitions"]}
+        assert names == {"Engine", "run"}
+
+    def test_outline_nests_js_methods_under_class(self):
+        code = "class Box {\n  open() {}\n  close() {}\n}\n"
+        result = file_outline({"box.ts": code}, "box.ts")
+        box = next(n for n in result["outline"] if n["name"] == "Box")
+        child_names = {c["name"] for c in box["children"]}
+        assert child_names == {"open", "close"}
+
 
 # ---------------------------------------------------------------------------
 # Index assembly + lookup