tree-sitter-delphi13-pure 1.2.1 → 1.3.0

package/grammar.js

@@ -700,7 +700,13 @@ 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` (raise-with-address) as an INHERITED method
+			// name: `inherited At(Offset)` (JCL JclCLR.pas). Mirrors the root
+			// full grammar's fix (2026-07-17).
+			alias($.kAtWord, $.identifier),
+		)))),
 
 		exprDot:         $ => choice(
 			op.infix(5, $._ref, $.kDot, $._ref),
@@ -1198,6 +1204,9 @@ module.exports = grammar({
 			// conflicts with typerefDot in this position.)
 			seq($.identifier, '.', $.identifier),
 			seq($.identifier, '(', $.identifier, ')'),
+			// Nested const-expr call bound — `2 .. Succ(High(TV))` (JCL
+			// JclSysUtils). Mirrors the root full grammar's fix (2026-07-17).
+			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
@@ -1546,6 +1555,9 @@ module.exports = grammar({
 			field('name', delimited1(choice(
 				$.identifier,
 				alias($.kRegister, $.identifier),
+				// `Operator` as a FIELD NAME (JVCL JvXmlDatabase). Mirrors the
+				// root full grammar's fix (2026-07-17).
+				alias($.kOperator, $.identifier),
 			))),
 			':',
 			// Ported from root v1.1.x: field type may be a subrange

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-delphi13-pure",
-  "version": "1.2.1",
+  "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