tree-sitter-delphi13-pure 1.2.2 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-delphi13-pure",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Pure Delphi 13 tree-sitter sub-grammar — drops {$IFDEF}/pp_* tokens entirely and expects preprocessor-resolved source as input. Pairs with delphi13-preprocessor to reach 99%+ pass on real Delphi 13 corpora.",
   "main": "bindings/node",
   "types": "bindings/node",
@@ -29,15 +29,19 @@
   },
   "scripts": {
     "build": "tree-sitter generate && node-gyp build",
+    "build-wasm": "tree-sitter build --wasm -o tree-sitter-delphi13_pure.wasm .",
     "install": "node-gyp-build",
     "prebuildify": "prebuildify --napi --strip"
   },
   "files": [
     "grammar.js",
     "binding.gyp",
+    "tree-sitter.json",
     "prebuilds/**",
     "bindings/node/*",
-    "src/**"
+    "queries/*",
+    "src/**",
+    "tree-sitter-delphi13_pure.wasm"
   ],
   "dependencies": {
     "node-gyp-build": "^4.8.4"

package/queries/folds.scm

@@ -0,0 +1,53 @@
+; folds.scm -- tree-sitter-delphi13-pure
+;
+; 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)
+] @fold

package/queries/highlights.scm

@@ -0,0 +1,335 @@
+; 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} ...
+; ---------------------------------------------------------------------------
+
+; PURE-GRAMMAR VARIANT.
+; The pure grammar is a strict subset of the full one: identical named node types
+; except for four preprocessor nodes it does not produce, because conditional
+; compilation is resolved by the preprocessor before this grammar ever sees the
+; source. Three of those four are referenced by the full grammar's highlights.scm
+; and are omitted here -- `pp_open`, `pp_else_tail`, `pp_end_only`. Leaving them in
+; is not a harmless no-op: tree-sitter rejects the pattern as impossible and the
+; WHOLE query fails to compile, taking all highlighting with it.
+;
+; `pp` itself exists in both grammars, so it stays.
+(pp) @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-pure
+;
+; 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

package/queries/tags.scm

@@ -0,0 +1,183 @@
+; tags.scm -- tree-sitter-delphi13-pure
+;
+; Symbol extraction in the standard tree-sitter "tags" format. This is the file
+; code-intelligence consumers read to build a symbol index: GitHub's tree-sitter
+; tags CLI, nvim-treesitter, and the VS Code / Cursor codebase indexers.
+;
+; Capture convention (tree-sitter-tags):
+;   @name               the identifier indexed for the symbol
+;   @definition.<kind>  the node the symbol spans
+;   @reference.<kind>   a use site
+; Every @name MUST sit inside its @definition node.
+;
+; NODE NAMES ARE DELPHI-SHAPED
+; This grammar uses declType / declClass / declIntf / declHelper / declProc /
+; defProc / declProp -- NOT the class_declaration / procedure_declaration names
+; of the generic Pascal grammars. A tags query copied from a Pascal grammar
+; compiles here but matches nothing.
+;
+; GENERICS
+; `TFoo<T: class>` parses as (genericTpl entity: (identifier) args: ...), so every
+; declaration pattern below is written twice: once for a plain or dotted name,
+; once unwrapping `entity:` out of a generic. Without the second form the indexed
+; symbol would be the literal text `TFoo<T: class>` rather than `TFoo` -- which
+; matters a great deal in Spring4D-heavy code.
+;
+; Qualified implementation names (`TFoo<T>.Bar`) are captured whole, matching
+; queries/outline.scm, so the indexed symbol stays unambiguous.
+
+;; ---------------------------------------------------------------- modules --
+
+(unit    (moduleName) @name) @definition.module
+(program (moduleName) @name) @definition.module
+(library (moduleName) @name) @definition.module
+(package (moduleName) @name) @definition.module
+
+(declUsesUnit (moduleName) @name) @reference.module
+
+;; ------------------------------------------------------------------ types --
+
+; type TFoo = class(TBar, IBaz) ... end;   /   = object ... end;
+(declType
+  name: [(identifier) (genericDot)] @name
+  type: [(declClass (kClass)) (type (declClass (kClass)))]) @definition.class
+(declType
+  name: (genericTpl entity: [(identifier) (genericDot)] @name)
+  type: [(declClass (kClass)) (type (declClass (kClass)))]) @definition.class
+
+(declType
+  name: [(identifier) (genericDot)] @name
+  type: [(declClass (kObject)) (type (declClass (kObject)))]) @definition.class
+(declType
+  name: (genericTpl entity: [(identifier) (genericDot)] @name)
+  type: [(declClass (kObject)) (type (declClass (kObject)))]) @definition.class
+
+; type TFoo = record ... end;
+(declType
+  name: [(identifier) (genericDot)] @name
+  type: [(declClass (kRecord)) (type (declClass (kRecord)))]) @definition.struct
+(declType
+  name: (genericTpl entity: [(identifier) (genericDot)] @name)
+  type: [(declClass (kRecord)) (type (declClass (kRecord)))]) @definition.struct
+
+; type IFoo = interface / dispinterface ... end;
+(declType
+  name: [(identifier) (genericDot)] @name
+  type: (declIntf)) @definition.interface
+(declType
+  name: (genericTpl entity: [(identifier) (genericDot)] @name)
+  type: (declIntf)) @definition.interface
+
+; type TFooHelper = class helper for TFoo ... end;
+(declType
+  name: [(identifier) (genericDot)] @name
+  type: (declHelper)) @definition.class
+(declType
+  name: (genericTpl entity: [(identifier) (genericDot)] @name)
+  type: (declHelper)) @definition.class
+
+; type TColor = (clRed, clGreen);
+(declType
+  name: [(identifier) (genericDot)] @name
+  type: (type (declEnum))) @definition.enum
+
+(declEnumValue name: (identifier) @name) @definition.constant
+
+; aliases, sets, arrays, strings, files, procedural types, metaclasses, subranges
+(declType
+  name: [(identifier) (genericDot)] @name
+  type: [
+    (identifier)
+    (subrangeType)
+    (type (typeref))
+    (type (declSet))
+    (type (declArray))
+    (type (declString))
+    (type (declFile))
+    (type (declProcRef))
+    (type (declMetaClass))
+  ]) @definition.type
+(declType
+  name: (genericTpl entity: [(identifier) (genericDot)] @name)
+  type: [
+    (identifier)
+    (subrangeType)
+    (type (typeref))
+    (type (declSet))
+    (type (declArray))
+    (type (declString))
+    (type (declFile))
+    (type (declProcRef))
+    (type (declMetaClass))
+  ]) @definition.type
+
+;; ---------------------------------------------------------------- methods --
+;
+; Routines declared inside a class / record / interface / helper body, either
+; directly or under a visibility section (private / protected / public /
+; published / strict private ...).
+
+(declClass (declProc name: (identifier) @name) @definition.method)
+(declClass (declProc name: (genericTpl entity: (identifier) @name)) @definition.method)
+(declClass (declSection (declProc name: (identifier) @name) @definition.method))
+(declClass (declSection (declProc name: (genericTpl entity: (identifier) @name)) @definition.method))
+
+(declIntf (declProc name: (identifier) @name) @definition.method)
+(declIntf (declProc name: (genericTpl entity: (identifier) @name)) @definition.method)
+(declIntf (declSection (declProc name: (identifier) @name) @definition.method))
+(declIntf (declSection (declProc name: (genericTpl entity: (identifier) @name)) @definition.method))
+
+(declHelper (declProc name: (identifier) @name) @definition.method)
+(declHelper (declProc name: (genericTpl entity: (identifier) @name)) @definition.method)
+(declHelper (declSection (declProc name: (identifier) @name) @definition.method))
+(declHelper (declSection (declProc name: (genericTpl entity: (identifier) @name)) @definition.method))
+
+; property Name: string read GetName write SetName;
+(declProp name: (identifier) @name) @definition.property
+
+; FName: string;   (only ever occurs in a class-like body)
+(declField name: (identifier) @name) @definition.field
+
+;; -------------------------------------------------------------- functions --
+;
+; Free routines: declared in the interface section, forward-declared in the
+; implementation section, or written straight into a program / library /
+; package / bare include fragment.
+
+(interface      (declProc name: (identifier) @name) @definition.function)
+(implementation (declProc name: (identifier) @name) @definition.function)
+(program        (declProc name: (identifier) @name) @definition.function)
+(library        (declProc name: (identifier) @name) @definition.function)
+(package        (declProc name: (identifier) @name) @definition.function)
+(root           (declProc name: (identifier) @name) @definition.function)
+
+(interface      (declProc name: (genericTpl entity: (identifier) @name)) @definition.function)
+(implementation (declProc name: (genericTpl entity: (identifier) @name)) @definition.function)
+(program        (declProc name: (genericTpl entity: (identifier) @name)) @definition.function)
+(library        (declProc name: (genericTpl entity: (identifier) @name)) @definition.function)
+(package        (declProc name: (genericTpl entity: (identifier) @name)) @definition.function)
+(root           (declProc name: (genericTpl entity: (identifier) @name)) @definition.function)
+
+; Implemented bodies.
+;   procedure TFoo.Bar;   begin ... end;   -> a method implementation
+;   function Helper(...); begin ... end;   -> a free routine implementation
+(defProc header: (declProc name: (genericDot) @name)) @definition.method
+(defProc header: (declProc name: (identifier) @name)) @definition.function
+(defProc header: (declProc name: (genericTpl entity: (identifier) @name))) @definition.function
+
+;; ------------------------------------------------------ constants and vars --
+
+(declConst name: (identifier) @name) @definition.constant
+(declVar   name: (identifier) @name) @definition.variable
+
+;; ------------------------------------------------------------- references --
+
+; Foo(...), Unit.Foo(...) / Obj.Foo(...), Foo<T>(...)
+(exprCall entity: (identifier) @name) @reference.call
+(exprCall entity: (exprDot rhs: (identifier) @name)) @reference.call
+(exprCall entity: (exprTpl entity: (identifier) @name)) @reference.call
+
+; Ancestor class and implemented interfaces.
+(declClass  parent: (typeref (identifier) @name) @reference.implementation)
+(declIntf   parent: (typeref (identifier) @name) @reference.implementation)
+(declHelper parent: (typeref (identifier) @name) @reference.implementation)

package/tree-sitter.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://tree-sitter.github.io/tree-sitter/assets/schemas/config.schema.json",
+  "grammars": [
+    {
+      "name": "delphi13_pure",
+      "camelcase": "Delphi13Pure",
+      "title": "Delphi 13 (pure, no preprocessor)",
+      "scope": "source.delphi-pure",
+      "file-types": [],
+      "class-name": "TreeSitterDelphi13Pure"
+    }
+  ],
+  "metadata": {
+    "version": "1.3.0",
+    "license": "MIT",
+    "description": "Pure Delphi 13 sub-tree-sitter — knows no IFDEFs"
+  },
+  "bindings": {
+    "c": true,
+    "node": true
+  }
+}