tree-sitter-delphi13 1.2.1 → 1.3.0

package/README.md

@@ -2,15 +2,22 @@
 
 [![npm](https://img.shields.io/npm/v/tree-sitter-delphi13.svg)](https://www.npmjs.com/package/tree-sitter-delphi13)
 [![license](https://img.shields.io/npm/l/tree-sitter-delphi13.svg)](LICENSE)
+[![corpus](https://img.shields.io/badge/valid_Delphi_13-100.000%25-brightgreen.svg)](CORPUS-CEILING-REPORT.md)
+[![corpus raw](https://img.shields.io/badge/full_corpus_raw-99.82%25-green.svg)](CORPUS-CEILING-REPORT.md)
 
 Tree-sitter grammar pipeline focused on **Delphi 13 (RAD Studio 37.0 / Florence)** and the surrounding modern Delphi ecosystem.
 
-**v1.2.1: 100.000% pass rate on compilable Delphi 13** (zero ERROR nodes), measured
-on an 11,722-unique-file corpus spanning the RAD Studio 13 RTL/VCL (including
-`System.pas`), DevExpress, Spring4D, EurekaLog, Indy, FireDAC, AsyncPro/Orpheus,
-mORMot-era community code and a full production application. Every failure that
-remains is individually diagnosed, dcc32-cross-checked, and *supposed* to fail
-(see [CORPUS-CEILING-REPORT.md](CORPUS-CEILING-REPORT.md)).
+**v1.2.2: 100.000% pass rate on compilable Delphi 13** (zero ERROR nodes), measured
+on a corpus spanning the RAD Studio 13 RTL/VCL (including `System.pas`), DevExpress,
+Spring4D, EurekaLog, Indy, FireDAC, AsyncPro/Orpheus, **JCL/JVCL (JEDI)**, mORMot-era
+community code and a full production application — 23,385 deduplicated files. Every
+failure that remains is individually diagnosed, dcc32-cross-checked, and *supposed*
+to fail (see [CORPUS-CEILING-REPORT.md](CORPUS-CEILING-REPORT.md)).
+
+v1.2.2 added the JEDI (JCL + JVCL) libraries to the corpus and closed the three
+valid-Delphi-13 gaps they surfaced: a subrange bound that is a nested constant-expr
+call (`2..Succ(High(T))`), the `at` soft keyword as an `inherited` method name
+(`inherited At(...)`), and `Operator` used as a record/class field name.
 
 | measurement basis | pass rate |
 |---|---|
@@ -31,9 +38,9 @@ watchlist).
 |---|---|
 | **`tree-sitter-delphi13`** *(this directory)* | Master grammar — Delphi-13 syntax, all proven fixes from upstream merged + new extensions. Self-contained "THEN-wins" parser (98.6% raw on its own). |
 | **[`tree-sitter-delphi13-pure`](pure/)** | Simpler sub-grammar that drops `pp_*` tokens entirely. Expects preprocessor-resolved source. |
-| **[`delphi13-preprocessor`](preprocessor/)** | Standalone JavaScript library that resolves `{$IFDEF}` / `{$IF}` / `{$DEFINE}` / `{$I X.inc}` directives as a text transformation. |
+| **[`delphi13-preprocessor`](preprocessor/)** | Standalone JavaScript library that resolves `{$IFDEF}` / `{$IF}` / `{$DEFINE}` / `{$I X.inc}` directives as a text transformation. The **canonical** preprocessor is now a pure-Delphi port of this library (shipping inside drag-lint); this JS package remains the byte-for-byte oracle and the drop-in choice for JavaScript consumers. |
 
-The full pipeline `preprocessor → pure → AST` is what reaches **99.97%** on valid
+The full pipeline `preprocessor → pure → AST` is what reaches **100.000%** on valid
 Delphi 13. Use the master grammar alone (98.6% raw) if you don't need
 conditional-compilation awareness; use the pipeline if you do.
 
@@ -134,11 +141,48 @@ npm install --ignore-scripts
 node-gyp rebuild
 ```
 
+## WASM and editor queries
+
+Each package ships a prebuilt **tree-sitter ABI 14** `.wasm` alongside the native
+binding, so browser and Electron hosts (`web-tree-sitter`) can load the parser with
+no toolchain:
+
+```js
+const Parser = require('web-tree-sitter');
+await Parser.init();
+const L = await Parser.Language.load('node_modules/tree-sitter-delphi13/tree-sitter-delphi13.wasm');
+```
+
+Rebuilding it needs a pinned Emscripten -- see [WASM-BUILD.md](WASM-BUILD.md).
+
+The full standard query set lives in `queries/`:
+
+| File | Used for |
+|---|---|
+| `highlights.scm` | syntax highlighting |
+| `injections.scm` | SQL-in-string and inline `asm` embedding |
+| `indents.scm` | auto-indent |
+| `folds.scm` | code folding |
+| `outline.scm` | outline / breadcrumb panel |
+| `tags.scm` | symbol extraction for codebase indexers (GitHub, Cursor, Sourcegraph) |
+
+Validate them after any edit -- against the **WASM**, because the native CLI and the
+WASM host do not run the same regex engine and a query can compile in one and throw
+in the other:
+
+```sh
+npm run build-wasm
+npm run validate-queries
+```
+
+See [DISTRIBUTION.md](DISTRIBUTION.md) for the state of editor integrations.
 ## Known limitations
 
 - **Inline `asm` blocks** treated as opaque text by design. Not tree-sitter-asm.
 - **`{$IF declared(SymName)}`** always evaluates to `false` — no symbol table. ~10 corpus files use this. A lightweight symbol pre-scan would address most cases.
-- **Include search path** is currently same-directory only. Cross-directory `{$I ..\Common\X.inc}` requires a search-path option (see TODO.md).
+- **Include resolution** is nearest-first (same directory, its subdirectories, then
+  up to 3 parent levels with their subdirectories — v1.1.0 of the preprocessor).
+  Arbitrary project search paths still need the `includePaths` option.
 - **FreePascal-specific extensions** (operator overloading variants, `{$mode ObjFPC}` directives, macOS PasCocoa namespaces) are not covered. A separate `tree-sitter-delphi-plus-fp` repo is planned.
 
 ## Acknowledgements

package/grammar.js

@@ -756,7 +756,16 @@ module.exports = grammar({
 			field('body', choice(tr($, 'block'), tr($, 'asm'))),
 		),
 
-		inherited:       $ => prec.right(seq($.kInherited, optional($.identifier))),
+		inherited:       $ => prec.right(seq($.kInherited, optional(choice(
+			$.identifier,
+			// Soft keyword `at` (the raise-with-address `raise E at Addr`
+			// keyword) used as an INHERITED method name: `inherited At(Offset)`
+			// (JCL JclCLR.pas). `At` already works as a plain/dotted call and a
+			// field name; only the inherited slot lost it to the kAtWord token.
+			// Aliased to identifier so the call-args attach exactly as for
+			// `inherited Foo(x)`. Narrow — only the corpus-confirmed kAtWord.
+			alias($.kAtWord, $.identifier),
+		)))),
 
 		exprDot:         $ => choice(
 			op.infix(5, $._ref, $.kDot, $._ref),
@@ -1288,6 +1297,13 @@ module.exports = grammar({
 			// conflicts with typerefDot in this position.)
 			seq($.identifier, '.', $.identifier),
 			seq($.identifier, '(', $.identifier, ')'),
+			// Iter 2026-07-17: nested const-expr call bound —
+			// `2 .. Succ(High(TDigitValue))` (JCL JclSysUtils TNumericSystemBase).
+			// dcc accepts any constant ordinal expression as a bound; the grammar
+			// stays with the narrow corpus-driven enumeration (a wide `_expr`
+			// bound blows the parser tables, see above), adding just the one
+			// real shape: `Ident( Ident(Ident) )`, one level of call nesting.
+			seq($.identifier, '(', seq($.identifier, '(', $.identifier, ')'), ')'),
 			// `hid - 1`, `MaxN + 2` — narrow `identifier OP integer` form for
 			// real-corpus patterns like `TNmbrRange = 0 .. hid - 1;`.
 			// Kept narrow (no full _expr) to avoid the conflict cascade hit
@@ -1663,6 +1679,12 @@ module.exports = grammar({
 			field('name', delimited1(choice(
 				$.identifier,
 				alias($.kRegister, $.identifier),
+				// Iter 2026-07-17: `Operator` as a FIELD NAME
+				// (`Operator: TJvXmlSQLOperator;` — JVCL JvXmlDatabase). The
+				// `operator` token otherwise starts _declOperator; GLR splits
+				// on the follow token (`:` -> field, operator-name -> class
+				// operator). Same narrow one-keyword alias as kRegister above.
+				alias($.kOperator, $.identifier),
 			))),
 			':',
 			// Iter 2026-07-06: a record/class field type may be a subrange, same

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-delphi13",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Tree-sitter grammar focused on Delphi 13 (RAD Studio 37.0)",
   "main": "bindings/node",
   "types": "bindings/node",
@@ -23,21 +23,26 @@
   "license": "MIT",
   "devDependencies": {
     "prebuildify": "^6.0.1",
+    "web-tree-sitter": "^0.24.7",
     "tree-sitter-cli": "^0.24.5"
   },
   "scripts": {
     "build": "tree-sitter generate && node-gyp build",
+    "build-wasm": "tree-sitter build --wasm -o tree-sitter-delphi13.wasm .",
     "test": "tree-sitter test && tree-sitter parse examples/* --quiet --time",
     "install": "node-gyp-build",
+    "validate-queries": "node tools/validate-queries.js",
     "prebuildify": "prebuildify --napi --strip"
   },
   "files": [
     "grammar.js",
     "binding.gyp",
+    "tree-sitter.json",
     "prebuilds/**",
     "bindings/node/*",
     "queries/*",
-    "src/**"
+    "src/**",
+    "tree-sitter-delphi13.wasm"
   ],
   "dependencies": {
     "node-gyp-build": "^4.8.4"

package/queries/folds.scm

@@ -0,0 +1,56 @@
+; folds.scm -- tree-sitter-delphi13
+;
+; Nodes that may be collapsed to a single line. The `@fold` capture is the
+; convention read by nvim-treesitter, Helix and Zed; editors that compute folds
+; from the syntax tree use the captured node's span as the foldable region.
+;
+; Rule of thumb: fold anything with its own `end`, plus the declaration groups
+; that routinely run to hundreds of lines in real Delphi units (a `uses` clause,
+; a `type` section, a visibility section of a large form class).
+
+[
+  ; --- module structure ---
+  (interface)
+  (implementation)
+  (initialization)
+  (finalization)
+
+  ; --- declaration groups ---
+  (declUses)
+  (declTypes)
+  (declConsts)
+  (declVars)
+  (declExports)
+  (declLabels)
+  (declArgs)
+
+  ; --- type bodies ---
+  (declClass)
+  (declIntf)
+  (declHelper)
+  (declEnum)
+  (declSection)
+  (declVariant)
+
+  ; --- routines ---
+  (defProc)
+  (block)
+  (asm)
+
+  ; --- statements with an `end` / closing keyword ---
+  (try)
+  (exceptionHandler)
+  (case)
+  (caseCase)
+  (if)
+  (ifElse)
+  (while)
+  (for)
+  (foreach)
+  (repeat)
+  (with)
+  (lambda)
+
+  ; --- conditional compilation ---
+  (pp_block)
+] @fold

package/queries/highlights.scm

@@ -0,0 +1,328 @@
+; highlights.scm -- tree-sitter-delphi13
+;
+; Syntax highlighting queries for Delphi 13 (Object Pascal).
+; Consumed by Zed, Neovim, Helix and anything else using tree-sitter-highlight.
+;
+; Capture names follow the common tree-sitter highlight vocabulary that Zed's
+; theme syntax keys map directly (keyword, type, function, string, number,
+; boolean, comment, operator, property, attribute, preproc, punctuation.*).
+;
+; NOTE ON ORDER: tree-sitter-highlight resolves the FIRST matching pattern for a
+; node, so specific patterns are listed before general ones.
+
+; ---------------------------------------------------------------------------
+; Comments
+; ---------------------------------------------------------------------------
+
+(comment) @comment
+
+; ---------------------------------------------------------------------------
+; Preprocessor / conditional compilation  {$IFDEF} {$R} {$I} ...
+; ---------------------------------------------------------------------------
+
+(pp) @preproc
+(pp_open) @preproc
+(pp_else_tail) @preproc
+(pp_end_only) @preproc
+
+; ---------------------------------------------------------------------------
+; Literals
+; ---------------------------------------------------------------------------
+
+(literalString) @string
+(literalChar) @string.special
+(char_literal) @string.special
+(literalNumber) @number
+(trailing_dot_float) @number
+(guid) @string.special
+
+[
+  (kTrue)
+  (kFalse)
+] @boolean
+
+(kNil) @constant
+
+; ---------------------------------------------------------------------------
+; Attributes -- [Weak], [Ref], custom RTTI attributes
+; ---------------------------------------------------------------------------
+
+(rttiAttributes) @attribute
+(declAssemblyAttribute) @attribute
+
+; ---------------------------------------------------------------------------
+; Module structure
+; ---------------------------------------------------------------------------
+
+[
+  (kUnit)
+  (kProgram)
+  (kLibrary)
+  (kPackage)
+  (kInterface)
+  (kImplementation)
+  (kInitialization)
+  (kFinalization)
+  (kUses)
+  (kExports)
+  (kContains)
+  (kRequires)
+] @keyword
+
+(moduleName) @type
+
+; ---------------------------------------------------------------------------
+; Declaration introducers
+; ---------------------------------------------------------------------------
+
+[
+  (kType)
+  (kVar)
+  (kConst)
+  (kThreadvar)
+  (kResourcestring)
+  (kLabel)
+  (kAbsolute)
+] @keyword
+
+; ---------------------------------------------------------------------------
+; Routines
+; ---------------------------------------------------------------------------
+
+[
+  (kProcedure)
+  (kFunction)
+  (kConstructor)
+  (kDestructor)
+  (kOperator)
+  (kProperty)
+  (kRead)
+  (kWrite)
+  (kReadonly)
+  (kWriteonly)
+  (kStored)
+  (kDefault)
+  (kNodefault)
+  (kIndex)
+  (kImplements)
+] @keyword
+
+; ---------------------------------------------------------------------------
+; Type-forming keywords
+; ---------------------------------------------------------------------------
+
+[
+  (kClass)
+  (kRecord)
+  (kObject)
+  (kArray)
+  (kSet)
+  (kFile)
+  (kString)
+  (kHelper)
+  (kDispInterface)
+  (kPacked)
+  (kGeneric)
+  (kReference)
+  (kOf)
+] @keyword
+
+; ---------------------------------------------------------------------------
+; Visibility
+; ---------------------------------------------------------------------------
+
+[
+  (kPrivate)
+  (kProtected)
+  (kPublic)
+  (kPublished)
+  (kStrict)
+] @keyword
+
+; ---------------------------------------------------------------------------
+; Control flow
+; ---------------------------------------------------------------------------
+
+[
+  (kBegin)
+  (kEnd)
+  (kEndDot)
+  (kIf)
+  (kThen)
+  (kElse)
+  (kCase)
+  (kFor)
+  (kTo)
+  (kDownto)
+  (kDo)
+  (kWhile)
+  (kRepeat)
+  (kUntil)
+  (kWith)
+  (kGoto)
+  (kTry)
+  (kExcept)
+  (kFinally)
+  (kRaise)
+  (kOn)
+  (kInherited)
+  (kAsm)
+  (kAssembler)
+] @keyword
+
+; ---------------------------------------------------------------------------
+; Routine directives / modifiers
+; ---------------------------------------------------------------------------
+
+[
+  (kVirtual)
+  (kOverride)
+  (kAbstract)
+  (kSealed)
+  (kFinal)
+  (kStatic)
+  (kOverload)
+  (kReintroduce)
+  (kInline)
+  (kForward)
+  (kExternal)
+  (kDynamic)
+  (kDelayed)
+  (kDispId)
+  (kMessage)
+  (kName)
+  (kDeprecated)
+  (kExperimental)
+  (kPlatform)
+  (kNoreturn)
+  (kUnsafe)
+  (kVarargs)
+  (kLocal)
+  (kAlign)
+  (kDependency)
+  (kOut)
+  (kConstref)
+] @keyword
+
+; ---------------------------------------------------------------------------
+; Calling conventions
+; ---------------------------------------------------------------------------
+
+[
+  (kCdecl)
+  (kStdcall)
+  (kSafecall)
+  (kRegister)
+  (kPascal)
+  (kWinapi)
+  (kFar)
+  (kNear)
+  (kExport)
+  (kInterrupt)
+] @keyword
+
+; ---------------------------------------------------------------------------
+; Operator keywords
+; ---------------------------------------------------------------------------
+
+[
+  (kAnd)
+  (kOr)
+  (kNot)
+  (kXor)
+  (kDiv)
+  (kMod)
+  (kShl)
+  (kShr)
+  (kIn)
+  (kIs)
+  (kAs)
+  (kAt)
+] @operator
+
+; ---------------------------------------------------------------------------
+; Symbolic operators
+; ---------------------------------------------------------------------------
+
+[
+  (kAssign)
+  (kAssignAdd)
+  (kAssignSub)
+  (kAssignMul)
+  (kAssignDiv)
+  (kEq)
+  (kNeq)
+  (kLt)
+  (kLte)
+  (kGt)
+  (kGte)
+  (kAdd)
+  (kSub)
+  (kMul)
+  (kFdiv)
+  (kHat)
+  (kAtWord)
+] @operator
+
+(kDot) @punctuation.delimiter
+
+; ---------------------------------------------------------------------------
+; Types
+; ---------------------------------------------------------------------------
+
+(typeref) @type
+(typerefDot) @type
+(typerefPtr) @type
+(typerefTpl) @type
+(genericTpl) @type
+(genericDot) @type
+(declEnumValue) @constant
+
+; ---------------------------------------------------------------------------
+; Labels
+; ---------------------------------------------------------------------------
+
+(label) @label
+(declLabel) @label
+(caseLabel) @label
+
+; ---------------------------------------------------------------------------
+; Punctuation
+; ---------------------------------------------------------------------------
+
+[
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ","
+  ";"
+  ":"
+  "."
+  ".."
+] @punctuation.delimiter
+
+; ---------------------------------------------------------------------------
+; Declaration names -- more specific than the bare identifier rule below, so
+; they must be listed first (tree-sitter-highlight takes the first match).
+; ---------------------------------------------------------------------------
+
+(declProc name: (identifier) @function)
+(declProc name: (genericDot) @function)
+(declProc name: (genericTpl) @function)
+
+(declType name: (identifier) @type)
+(declType name: (genericDot) @type)
+(declType name: (genericTpl) @type)
+
+(declProp name: (identifier) @property)
+(declField name: (identifier) @property)
+
+; ---------------------------------------------------------------------------
+; Identifiers -- least specific, listed last
+; ---------------------------------------------------------------------------
+
+(identifier) @variable

package/queries/indents.scm

@@ -0,0 +1,58 @@
+; indents.scm -- tree-sitter-delphi13
+;
+; Auto-indent behaviour. This is the query users actually *feel*: it decides
+; where the caret lands after `begin`, `case`, `try`, `record`, `class`.
+;
+; Convention (matches Zed's own language extensions):
+;   @indent  the node whose body should be indented
+;   @start   the token that opens the indented region
+;   @end     the token that closes it (dedents the line it appears on)
+
+; --- begin ... end -------------------------------------------------------
+(block
+  (kBegin) @start
+  (kEnd)? @end) @indent
+
+; --- try ... except / finally ... end ------------------------------------
+(try
+  (kTry) @start
+  (kEnd)? @end) @indent
+
+; --- case ... of ... end -------------------------------------------------
+(case
+  (kCase) @start
+  (kEnd)? @end) @indent
+
+; --- record ... end ------------------------------------------------------
+(declClass
+  (kEnd)? @end) @indent
+
+(declIntf
+  (kEnd)? @end) @indent
+
+(declHelper
+  (kEnd)? @end) @indent
+
+; --- asm ... end ---------------------------------------------------------
+(asm
+  (kAsm) @start
+  (kEnd)? @end) @indent
+
+; --- repeat ... until ----------------------------------------------------
+(repeat
+  (kRepeat) @start
+  (kUntil)? @end) @indent
+
+; --- declaration sections: the names under type/var/const line up --------
+(declTypes) @indent
+(declVars) @indent
+(declConsts) @indent
+
+; --- bracketed continuations --------------------------------------------
+(exprParens
+  "(" @start
+  ")" @end) @indent
+
+(declArgs
+  "(" @start
+  ")" @end) @indent

package/queries/injections.scm

@@ -0,0 +1,34 @@
+; injections.scm -- tree-sitter-delphi13
+;
+; Embeds other languages inside Delphi source.
+;
+; SQL-in-string is the high-value case for this codebase: FireDAC/Firebird
+; projects carry a lot of SQL in string literals and assembling it by hand is
+; where the bugs live. Highlighting it as SQL makes malformed statements
+; visible without running them.
+;
+; Matching is deliberately conservative -- anchored at the start of the literal
+; on a leading SQL verb. A loose pattern would paint ordinary prose strings as
+; SQL, which is worse than no injection at all: it makes correct code look
+; broken.
+
+; A LEADING VERB ALONE IS NOT ENOUGH. `'Select a file to continue'` starts with
+; "Select " and is obviously prose -- an early draft of this query painted it as
+; SQL. Every branch below therefore demands a PAIRED keyword (SELECT..FROM,
+; UPDATE..SET, INSERT INTO, ...), which prose effectively never satisfies.
+;
+; NO INLINE `(?i)` FLAG -- THIS IS LOAD-BEARING, DO NOT "SIMPLIFY" IT.
+; Native tree-sitter matches #match? with the Rust regex crate, which supports
+; the inline `(?i)` group. web-tree-sitter (the WASM build that VS Code, Cursor
+; and every browser host use) hands the pattern to JavaScript's RegExp, which
+; rejects `(?i)` outright with "Invalid group" -- and a query that throws on
+; compile takes the WHOLE injections file down with it, silently, in exactly
+; the editors this grammar is meant to ship in. Case-insensitivity is therefore
+; spelled out as [Ss][Ee][Ll]... character classes, which both engines accept.
+((literalString) @injection.content
+  (#match? @injection.content "^'\\s*([Ss][Ee][Ll][Ee][Cc][Tt]\\b[\\s\\S]*\\b[Ff][Rr][Oo][Mm]\\b|[Ii][Nn][Ss][Ee][Rr][Tt]\\s+[Ii][Nn][Tt][Oo]\\b|[Uu][Pp][Dd][Aa][Tt][Ee]\\b[\\s\\S]*\\b[Ss][Ee][Tt]\\b|[Dd][Ee][Ll][Ee][Tt][Ee]\\s+[Ff][Rr][Oo][Mm]\\b|[Cc][Rr][Ee][Aa][Tt][Ee]\\s+([Oo][Rr]\\s+[Aa][Ll][Tt][Ee][Rr]\\s+)?([Tt][Aa][Bb][Ll][Ee]|[Vv][Ii][Ee][Ww]|[Ii][Nn][Dd][Ee][Xx]|[Pp][Rr][Oo][Cc][Ee][Dd][Uu][Rr][Ee]|[Tt][Rr][Ii][Gg][Gg][Ee][Rr]|[Gg][Ee][Nn][Ee][Rr][Aa][Tt][Oo][Rr]|[Ss][Ee][Qq][Uu][Ee][Nn][Cc][Ee]|[Dd][Oo][Mm][Aa][Ii][Nn]|[Ee][Xx][Cc][Ee][Pp][Tt][Ii][Oo][Nn])\\b|[Aa][Ll][Tt][Ee][Rr]\\s+([Tt][Aa][Bb][Ll][Ee]|[Vv][Ii][Ee][Ww]|[Ii][Nn][Dd][Ee][Xx]|[Pp][Rr][Oo][Cc][Ee][Dd][Uu][Rr][Ee]|[Tt][Rr][Ii][Gg][Gg][Ee][Rr]|[Dd][Aa][Tt][Aa][Bb][Aa][Ss][Ee])\\b|[Dd][Rr][Oo][Pp]\\s+([Tt][Aa][Bb][Ll][Ee]|[Vv][Ii][Ee][Ww]|[Ii][Nn][Dd][Ee][Xx]|[Pp][Rr][Oo][Cc][Ee][Dd][Uu][Rr][Ee]|[Tt][Rr][Ii][Gg][Gg][Ee][Rr]|[Gg][Ee][Nn][Ee][Rr][Aa][Tt][Oo][Rr]|[Ss][Ee][Qq][Uu][Ee][Nn][Cc][Ee]|[Dd][Oo][Mm][Aa][Ii][Nn]|[Ee][Xx][Cc][Ee][Pp][Tt][Ii][Oo][Nn])\\b|[Ee][Xx][Ee][Cc][Uu][Tt][Ee]\\s+([Pp][Rr][Oo][Cc][Ee][Dd][Uu][Rr][Ee]|[Bb][Ll][Oo][Cc][Kk]|[Ss][Tt][Aa][Tt][Ee][Mm][Ee][Nn][Tt])\\b|[Mm][Ee][Rr][Gg][Ee]\\s+[Ii][Nn][Tt][Oo]\\b)")
+  (#set! injection.language "sql"))
+
+; Inline assembler blocks.
+((asmBody) @injection.content
+  (#set! injection.language "asm"))

package/queries/outline.scm

@@ -0,0 +1,35 @@
+; outline.scm -- tree-sitter-delphi13
+;
+; Drives Zed's outline panel (Ctrl-Shift-O / the breadcrumb symbol list).
+;
+; Convention:
+;   @item    the whole entry
+;   @name    the text shown for it
+;   @context surrounding keywords shown greyed next to the name
+
+; Types:  type TFoo = class ... end;
+(declType
+  (kType)? @context
+  name: [(identifier) (genericDot) (genericTpl)] @name) @item
+
+; Routines in the interface section and standalone declarations:
+;   procedure Foo(const X: Integer);
+(declProc
+  [
+    (kProcedure)
+    (kFunction)
+    (kConstructor)
+    (kDestructor)
+    (kOperator)
+  ] @context
+  name: [(identifier) (genericDot) (genericTpl)] @name) @item
+
+; NOTE: implemented routines (procedure TFoo.Bar; begin ... end;) are NOT given
+; their own pattern. A defProc's `header:` IS a declProc, so the pattern above
+; already matches it -- adding a defProc pattern here produced every
+; implementation twice in the outline.
+
+; Properties:  property Count: Integer read FCount;
+(declProp
+  (kProperty) @context
+  name: (identifier) @name) @item