AST Lens

AST Lens is a VS Code extension that generates tree-sitter queries from your code selection and runs them across your workspace — or just the current file. Select a pattern once, and AST Lens finds every structurally similar piece of code, in any supported language.

Open the AST Lens sidebar from the activity bar (globe icon) to start.

Quick Start

1. Open the AST Lens sidebar (globe icon on the left).
2. Put your cursor in (or select part of) a .java, .js, .ts, or .c file.
3. Select some code and press ✦ Add Query — a query is generated into the editor.
4. Press ⟫ Run All (whole workspace) or ▶ Run File (current file only).
5. Click any result to jump straight to the matching line.

Demo

Query View

Video demonstrates how to build complex query that consists of multiple patterns.

Instant AST view

1. Click on source code to instantly generate and highlight the corresponding AST
2. Click on the AST to highlight the matching source code.

The QUERY Tab

[⟫ Run All] [▶ Run File] [✦ Add Query] [⤓ Export] [⤒ Import] [✕ Clear]

Query editor

• The editor has live syntax highlighting (node types, captures, predicates, strings, fields, numbers, comments).
• Place your cursor next to (, [ or { and the matching bracket is highlighted.
• The editor is resizable — drag the handle below it for more room.
• You can hand-edit the query at any time (rename captures, tweak predicates, add #eq?) and run the edited version. If you then press ✦ Add Query while the text was written/edited by hand, the generator treats it as a fresh start and replaces it with a query generated from your current selection.

Results

• Results appear below the editor, grouped by file (filename (n)).
• Click a filename to open that file; click a result row to jump to the exact line.
• Each row shows the line number, a preview of the matching text, and the matched node type.
• Clear clears the results; Export .txt saves them to a file.
• The header shows the totals: Results (count in n files, elapsed ms).

The AST Tab

A real-time view of the syntax tree for the current file.

• Toolbar: Expand All, Collapse All, Refresh (re-parse the file), and a counter (Nodes: n | Depth: d).
• Each row shows the node type, its field name (e.g. name:, body:), a named / anon badge, a short text preview for leaf nodes, and its line:col range.
• Nodes are color-coded by category: declarations, statements, functions, types, variables, expressions, strings, numbers, keywords, punctuation, comments.
• Click a node → the corresponding range is selected in the editor.
• Move the cursor in the editor → the matching node is highlighted and scrolled into view in the tree.
• Keyboard while focused on a node: ↑/↓ navigate, ←/→ collapse/expand, Enter/Space selects the node's range in the editor.

Selection Guide

The generator anchors on the smallest syntax node that fully contains your selection, then keeps only the parts you touched. Two rules drive everything:

1. Select a little → general match. Select more → specific match.

2. Whitespace decides roles. Whether a type keyword is read as a bare type ("anywhere") or as a specific role (return type / parameter / field / local) depends on how the selection ends: the end point is treated as exclusive.

• Double-click the token (selection ends exactly at word end) → bare type → matches everywhere.
• Include a trailing space (or anything after the token) → the anchor climbs to the enclosing declaration → the type is scoped to its role there.

The reference below is organized by AST node type (the same color categories as the AST tab). Queries are shown condensed; actual output may wrap/rename captures, but the structure is faithful.

Type nodes — bare keyword vs. role

int, void, double, boolean, String, number, float, char, …

Modifiers + type combinations — which declaration

Combining modifiers with a type pins the type to the declaration that owns it. Result depends on where you select it.

Declaration nodes — class, import, implements

Statement nodes — keyword vs. keyword+content vs. whole statement

Function & method nodes

Call & member-access nodes

Expression nodes

Variable & field nodes

Literal & string nodes

Comment nodes

The comment node holds no named children, so there is nothing to pin — a comment selection always matches all comments. To target comment text, hand-edit the query and add an #eq? on a (comment) capture (textual, not structural).

Composing Queries (Add Query)

Combine multiple selections into a single AND query — matches must satisfy every selected part.

1. Select part A (e.g. the if keyword) → ✦ Add Query. The editor now holds a query for if.
2. Select part B in the same file (e.g. the throw keyword inside that if) → ✦ Add Query again. The editor now holds a merged query:

(if_statement
  "if"
  (block
    (throw_statement "throw"))) @match_root

3. Run it — only if statements that contain a throw (with the throw keyword) match. Conditions, else branches, and bodies are not part of the query unless selected.

Rules of composition:

• Every ✦ Add Query after the first adds the new selection as an AND constraint; the anchor becomes the smallest node containing all selections.
• Selection order doesn't matter; the merge is always structural.
• Composed selections reset when you switch files, change language, hand-edit the query, or press ✕ Clear.
• Selections that live in unrelated places (e.g. two far-apart statements) still compose — the anchor widens to their common container (a whole block, class, etc.), so the query means "a container that includes both parts".

Supported Languages

Tips

• Start with the file scope (▶ Run File) while tuning a query; it's fast and limited to the file you're looking at.
• If a search returns too many results, add a modifier or surrounding keyword to the selection — the query immediately becomes more specific.
• If a search returns nothing, try selecting less code — a single keyword is the most permissive starting point.
• Generated queries are valid tree-sitter .scm files — export them, tweak them by hand, and import them back later.