Function List plugin

A filterable outline of the current document's symbols — functions, classes, methods, headings and more — in a dockable side panel. Activate a symbol to jump the editor caret straight to it.

Where to find it

View ▸ Function List opens the dock (it starts hidden). The list refreshes as you type and follows the active tab.

Using the list

• Jump to a symbol — double-click an entry, or select it and press Enter. The editor scrolls to the symbol, unfolding it if it sits inside a collapsed fold, and places the caret there.
• Filter — type in the box at the top to narrow the list by name (case-insensitive). In tree mode, a parent stays visible when any of its children match.
• Follow the caret — as you move around the document, the symbol that encloses the caret is highlighted in the list.

View options

The ⋮ button (next to the filter box) opens the view menu:

Option	Effect
Show as Tree	Nest members under their container (methods under a class, a class under its namespace). Turn it off for a flat list.
Sort by Position	Document order (default).
Sort by Name	Alphabetical (case-insensitive).
Sort by Kind	Group by symbol kind (classes, functions, …), then by name.

Your choices are remembered across sessions.

Where the outline comes from

The dock draws symbols from one of two sources, shown in the footer at the bottom of the panel:

• Source: language server — when a language server is configured for the file's language, the dock uses its symbols. This is the accurate, complete outline (member variables, precise class → method nesting, every symbol kind the server reports).
• Source: patterns — otherwise, the dock falls back to the built-in pattern rules described below.

You don't configure this: the pattern-based outline appears instantly, and if a language server answers it is used automatically. A language that has a server but no bundled patterns still gets an outline (from the server).

Supported languages

The pattern rules produce an outline without any language server (and are the fallback when one is not available):

Language	Symbols recognised
C / C++	namespaces, classes, structs, enums, #defines, functions
Python	classes, functions/methods (def, async def)
JavaScript / TypeScript	classes, functions, arrow-function constants, class methods
Markdown	headings (# … ######)

The list reflects the language the editor has applied to the file (its syntax colouring). Files of other types show "No symbol outline for this file type."

Patterns are approximate

The pattern-based outline (Source: patterns) is a best effort, not a full parser: for example, a free function written after a class body may be shown nested under that class. For a precise outline, configure a language server for the language — the dock then shows its symbols (Source: language server).

Custom rulesets

The rulesets are plain JSON files, so you can tweak them or add languages without rebuilding. The bundled set ships next to the application in a function-list/ folder (one *.json per ruleset); those files are overwritten on update, so treat them as read-only examples.

To customise, drop your own *.json into the rulesets/ subfolder of the Function List plugin's data directory. A user file whose languageIds includes a language overrides the bundled ruleset for that language.

A ruleset file looks like:

{
    "languageIds": ["cpp", "c"],
    "caseSensitive": true,
    "rules": [
        { "pattern": "^\\s*class\\s+([A-Za-z_]\\w*)", "kind": "class" },
        { "pattern": "^\\s*(?:async\\s+)?def\\s+([A-Za-z_]\\w*)", "kind": "function" }
    ]
}

Field	Meaning
languageIds	One or more editor language ids the ruleset applies to (e.g. cpp, python). One file can serve several.
caseSensitive	Whether the patterns match case-sensitively (default true).
rules	Ordered list of rules; the first rule that matches a line wins, one symbol per line.
rules[].pattern	An ECMAScript regular expression matched against a single line.
rules[].nameGroup	The capture group holding the symbol name (default 1).
rules[].kind	The symbol kind — a name (class, struct, enum, namespace, function, method, constant, string, …) or an LSP SymbolKind number. Controls grouping/sorting.
rules[].containerGroup	Optional capture group used as the symbol's container detail (0 = none).