Name every punctuation lexeme (Ampersand, Hash, Dot, …) à la bsl-parser

ANTLR's BSLLexer.g4 names every lexeme — AMPERSAND, HASH, DOT, LPAREN,
RPAREN, COMMA, SEMICOLON, COLON, ASSIGN, PLUS, MINUS, MUL, QUOTIENT,
MODULO, LESS, LESS_OR_EQUAL, NOT_EQUAL, GREATER, GREATER_OR_EQUAL,
QUESTION, BAR, TILDA. The Lezer grammar used anonymous string literals
which forced the awkward quoted-form path syntax in styleTags
(Annotation/"&") — @lezer/highlight's selector mini-language only
accepts identifier-shaped names in path positions.

Renamed every punctuation/operator literal in both bsl.grammar and
sdbl.grammar:

  &   → Ampersand     #   → Hash         .   → Dot
  ~   → Tilda         ?   → Question     (   → LParen
  )   → RParen        [   → LBrack       ]   → RBrack
  ,   → Comma         :   → Colon        ;   → Semicolon
  +   → Plus          -   → Minus        *   → Mul
  /   → Quotient      %   → Modulo       =   → Assign
  <>  → NotEqual      <   → Less         <=  → LessOrEqual
  >   → Greater       >=  → GreaterOrEqual

Every reference inside productions, every styleTags selector, and every
test fixture got updated in lock-step. Tree shape now exposes named
tokens (BinaryExpr(Identifier, CmpOp(Assign), Number) instead of
…CmpOp, Number) — that's intentional and makes downstream tree
inspection more readable.

Other knock-on cleanups:
- Dropped unused LBrace/RBrace defs (BSL has no { } syntax).
- styleTags map for SDBL Parameter/Ampersand and BSL Annotation/Ampersand
  and *Preprocessor/Hash now uses bare identifier path selectors.

Tests: 28/28 fixtures pass; sample-set parse rate unchanged
(84% / 88%).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: nixel2007

src/bsl.grammar

@@ -32,24 +32,24 @@ ModuleAnnotation {
   PreprocNativeDirective
 }
 
-PreprocUseDirective { "#" PreprocUse useTarget }
+PreprocUseDirective { Hash PreprocUse useTarget }
 useTarget { String | Identifier }
-PreprocNativeDirective { "#" PreprocNative }
+PreprocNativeDirective { Hash PreprocNative }
 
 // ---- Compiler directives & annotations ----
 
 Annotation {
-  "&" AnnotationName AnnotationParams?
+  Ampersand AnnotationName AnnotationParams?
 }
 
 AnnotationName { Identifier }
 
 AnnotationParams {
-  "(" (AnnotationParam ("," AnnotationParam)*)? ")"
+  LParen (AnnotationParam (Comma AnnotationParam)*)? RParen
 }
 
 AnnotationParam {
-  AnnotationParamName ("=" annotationValue)? |
+  AnnotationParamName (Assign annotationValue)? |
   annotationValue
 }
 
@@ -71,10 +71,10 @@ decoration { Annotation }
 // (LR(1) cannot pick between reducing here and shifting `;` as the next stmt).
 VarStatement {
   decoration*
-  Var varDeclList ";"
+  Var varDeclList Semicolon
 }
 
-varDeclList { VarDeclaration ("," VarDeclaration)* }
+varDeclList { VarDeclaration (Comma VarDeclaration)* }
 
 VarDeclaration { Identifier Export? }
 
@@ -83,27 +83,27 @@ VarDeclaration { Identifier Export? }
 ProcedureDecl {
   decoration*
   Async?
-  Procedure SubName "(" paramList? ")" Export?
+  Procedure SubName LParen paramList? RParen Export?
   body
   EndProcedure
 }
 
 FunctionDecl {
   decoration*
   Async?
-  Function SubName "(" paramList? ")" Export?
+  Function SubName LParen paramList? RParen Export?
   body
   EndFunction
 }
 
 SubName { Identifier }
 
-paramList { Param ("," Param)* }
+paramList { Param (Comma Param)* }
 
 Param {
   Annotation*
   Val?
-  Identifier ("=" DefaultValue)?
+  Identifier (Assign DefaultValue)?
 }
 
 DefaultValue { unaryConstValue }
@@ -133,15 +133,15 @@ body { (BodyStatement | Preprocessor | VarStatement)* }
 // that lets Label sit on its own *or* prefix the next statement.
 BodyStatement {
   Label ~labelOpt flatStatement |
-  Label ~labelOpt flatStatement !stmtSemi ";" |
+  Label ~labelOpt flatStatement !stmtSemi Semicolon |
   Label ~labelOpt blockStatement ~blockSemi |
-  Label ~labelOpt blockStatement ~blockSemi !stmtSemi ";" |
+  Label ~labelOpt blockStatement ~blockSemi !stmtSemi Semicolon |
   Label ~labelOpt |
   flatStatement |
-  flatStatement !stmtSemi ";" |
+  flatStatement !stmtSemi Semicolon |
   blockStatement ~blockSemi |
-  blockStatement ~blockSemi !stmtSemi ";" |
-  ";"
+  blockStatement ~blockSemi !stmtSemi Semicolon |
+  Semicolon
 }
 
 flatStatement {
@@ -166,10 +166,10 @@ blockStatement {
   TryStatement
 }
 
-Label { "~" LabelName ":" }
+Label { Tilda LabelName Colon }
 LabelName { Identifier }
 
-Assignment { lvalue "=" expression }
+Assignment { lvalue Assign expression }
 
 CallStatement { reference }
 
@@ -185,7 +185,7 @@ ElseBranch { Else body }
 WhileStatement { While expression Do body EndDo }
 
 ForStatement {
-  For Identifier "=" expression To expression Do body EndDo
+  For Identifier Assign expression To expression Do body EndDo
 }
 
 ForEachStatement {
@@ -211,9 +211,9 @@ RaiseStatement[@dynamicPrecedence=1] {
 ContinueStatement { Continue }
 BreakStatement { Break }
 ExecuteStatement { Execute expression }
-GotoStatement { Goto "~" Identifier }
-AddHandlerStatement { AddHandler expression "," expression }
-RemoveHandlerStatement { RemoveHandler expression "," expression }
+GotoStatement { Goto Tilda Identifier }
+AddHandlerStatement { AddHandler expression Comma expression }
+RemoveHandlerStatement { RemoveHandler expression Comma expression }
 AwaitStatement { Await expression }
 
 // ---- Expressions ----
@@ -239,10 +239,10 @@ UnaryExpr { !unary UnaryOp expression }
 
 OrOp  { Or }
 AndOp { And }
-CmpOp { "=" | "<>" | "<" | "<=" | ">" | ">=" }
-AddOp { "+" | "-" }
-MulOp { "*" | "/" | "%" }
-UnaryOp { "+" | "-" | Not }
+CmpOp { Assign | NotEqual | Less | LessOrEqual | Greater | GreaterOrEqual }
+AddOp { Plus | Minus }
+MulOp { Mul | Quotient | Modulo }
+UnaryOp { Plus | Minus | Not }
 
 primary {
   constValue |
@@ -253,7 +253,7 @@ primary {
   reference
 }
 
-ParenExpr { "(" expression ")" accessChain }
+ParenExpr { LParen expression RParen accessChain }
 
 reference { refHead accessChain }
 
@@ -274,8 +274,8 @@ access {
 // as identifiers. We can't do mode-shifting in Lezer's specializer, so the
 // parser rules below explicitly accept every BSL keyword term *or* a plain
 // Identifier in the dot position.
-PropertyAccess { "." dotIdentifier }
-CallAccess { "." dotIdentifier callArgs }
+PropertyAccess { Dot dotIdentifier }
+CallAccess { Dot dotIdentifier callArgs }
 
 dotIdentifier { Identifier | dotKeyword }
 
@@ -292,17 +292,17 @@ dotKeyword {
   And | Or | Not |
   True | False | Undefined | Null
 }
-IndexAccess { "[" expression "]" }
+IndexAccess { LBrack expression RBrack }
 
 // Argument list — comma-skipping (`Метод(a,,b)` / `Метод(,a)`) is not
 // supported. Removed the failed attempt to model `,` as a stand-alone item;
 // it fundamentally collides with `f(g(...))` inner-call parsing in LR(1).
 // See README → Limitations for context.
-callArgs { "(" callArgsList? ")" }
-callArgsList { callArg ("," callArg)* }
+callArgs { LParen callArgsList? RParen }
+callArgsList { callArg (Comma callArg)* }
 callArg { expression }
 
-TernaryOp { "?" "(" expression "," expression "," expression ")" }
+TernaryOp { Question LParen expression Comma expression Comma expression RParen }
 NewExpr { New (Identifier callArgs? | callArgs) }
 AwaitExpr { Await expression }
 
@@ -334,8 +334,8 @@ Preprocessor {
   PreprocessorEndInsert
 }
 
-Region { "#" PreprocRegion RegionName }
-EndRegion { "#" PreprocEndRegion }
+Region { Hash PreprocRegion RegionName }
+EndRegion { Hash PreprocEndRegion }
 RegionName { Identifier }
 
 // Preprocessor `#Если/#ИначеЕсли/#Иначе/#КонецЕсли/#Тогда` and their logical
@@ -344,24 +344,24 @@ RegionName { Identifier }
 // cannot do natively against the existing identifier specialize hook), we
 // reuse the BSL terms here and let styleTags discriminate via parent
 // selectors like `"PreprocessorIf/If": t.macroName`.
-PreprocessorIf { "#" If preprocExpr Then }
-PreprocessorElsif { "#" Elsif preprocExpr Then }
-PreprocessorElse { "#" Else }
-PreprocessorEndIf { "#" EndIf }
+PreprocessorIf { Hash If preprocExpr Then }
+PreprocessorElsif { Hash Elsif preprocExpr Then }
+PreprocessorElse { Hash Else }
+PreprocessorEndIf { Hash EndIf }
 
 // Configuration-extension preprocessor markers. `#Удаление`/`#КонецУдаления`
 // brackets code that the *base* configuration has but that the extension
 // removes; `#Вставка`/`#КонецВставки` brackets code the extension *adds*.
 // For highlighting purposes both are simple bracket-style directive pairs;
 // the BSL between them stays in the regular token stream.
-PreprocessorDelete { "#" PreprocDelete }
-PreprocessorEndDelete { "#" PreprocEndDelete }
-PreprocessorInsert { "#" PreprocInsert }
-PreprocessorEndInsert { "#" PreprocEndInsert }
+PreprocessorDelete { Hash PreprocDelete }
+PreprocessorEndDelete { Hash PreprocEndDelete }
+PreprocessorInsert { Hash PreprocInsert }
+PreprocessorEndInsert { Hash PreprocEndInsert }
 
 preprocExpr {
   Not preprocExpr |
-  "(" preprocExpr ")" |
+  LParen preprocExpr RParen |
   preprocExpr !preprocBool preprocBoolOp preprocExpr |
   PreprocSymbol
 }
@@ -431,18 +431,41 @@ preprocBoolOp { Or | And }
   // Shebang line — matched as a single token so its content is not parsed.
   ShebangLine { "#!" ![\n]* }
 
-  // Punctuation
-  "(" ")" "[" "]" "{" "}"
-  "," ":" ";" "."
-  "+" "-" "*" "/" "%"
-  "=" "<>" "<=" ">=" "<" ">"
-  "?" "&" "~" "#"
-
-  @precedence { "<=", "<>", "<" }
-  @precedence { ">=", ">" }
-  @precedence { DocComment, LineComment, "/" }
-  @precedence { Number, "." }
-  @precedence { ShebangLine, "#" }
+  // Named punctuation and operator tokens. Naming each lexeme mirrors the
+  // upstream ANTLR convention from `1c-syntax/bsl-parser` (AMPERSAND, HASH,
+  // DOT, …) and — more pragmatically — sidesteps @lezer/highlight's
+  // selector mini-language, which only accepts identifier-shaped names in
+  // path positions. With named tokens the styleTags selectors can read
+  // `Annotation/Ampersand` instead of the awkward quoted `Annotation/"&"`.
+  LParen        { "(" }
+  RParen        { ")" }
+  LBrack        { "[" }
+  RBrack        { "]" }
+  Comma         { "," }
+  Colon         { ":" }
+  Semicolon     { ";" }
+  Dot           { "." }
+  Plus          { "+" }
+  Minus         { "-" }
+  Mul           { "*" }
+  Quotient      { "/" }
+  Modulo        { "%" }
+  Assign        { "=" }
+  NotEqual      { "<>" }
+  LessOrEqual   { "<=" }
+  GreaterOrEqual { ">=" }
+  Less          { "<" }
+  Greater       { ">" }
+  Question      { "?" }
+  Ampersand     { "&" }
+  Tilda         { "~" }
+  Hash          { "#" }
+
+  @precedence { LessOrEqual, NotEqual, Less }
+  @precedence { GreaterOrEqual, Greater }
+  @precedence { DocComment, LineComment, Quotient }
+  @precedence { Number, Dot }
+  @precedence { ShebangLine, Hash }
 }
 
 // ---- External specialization: case-insensitive keyword matching ----

src/index.ts

@@ -119,11 +119,12 @@ export const sdblLanguage = sdblParser.configure({
       Number: t.number,
       StringLit: t.string,
       // Parameter references (&ИмяПараметра) — tagged as a typed local so
-      // they stand out from regular identifiers.
+      // they stand out from regular identifiers; the `&` punctuation gets
+      // the modifier tag so it renders together with the parameter name.
       "Parameter/Identifier": t.local(t.variableName),
-      "Parameter/&": t.modifier,
+      "Parameter/Ampersand": t.modifier,
       // Punctuation
-      "( )": t.paren,
+      "LParen RParen": t.paren,
       "AddOp MulOp": t.arithmeticOperator,
       CmpOp: t.compareOperator,
       Punct: t.punctuation,
@@ -251,13 +252,11 @@ export const bslLanguage = LRLanguage.define({
 
         // ---- Annotations (compiler directives like &НаКлиенте) ----
         // Every leaf token of an annotation gets `t.annotation` so the whole
-        // `&Имя` reads as one visual unit. The `AnnotationName/Identifier`
-        // selector is needed because @lezer/highlight resolves tags at the
-        // leaf level — a parent-only `AnnotationName: t.annotation` would
-        // lose against the global `Identifier: t.variableName`. The quoted
-        // `"&"` form is the only way to reference a non-identifier-shaped
-        // literal inside a path selector.
-        'Annotation/AnnotationName AnnotationName/Identifier Annotation/"&"': t.annotation,
+        // `&Имя` reads as one visual unit. AnnotationName/Identifier is
+        // needed because @lezer/highlight resolves at the leaf level —
+        // `AnnotationName: t.annotation` alone would lose against the global
+        // `Identifier: t.variableName`.
+        "Annotation/AnnotationName AnnotationName/Identifier Annotation/Ampersand": t.annotation,
 
         // ---- Preprocessor ----
         // Per bsl-language-server PreprocessorSemanticTokensSupplier:
@@ -274,37 +273,38 @@ export const bslLanguage = LRLanguage.define({
         // at the leaf — parent-only tags lose against any leaf rule.
 
         // Namespace bucket — regions and use directive.
-        'Region EndRegion PreprocUseDirective Region/"#" EndRegion/"#" PreprocUseDirective/"#" PreprocRegion PreprocEndRegion PreprocUse': t.namespace,
+        "Region EndRegion PreprocUseDirective Region/Hash EndRegion/Hash PreprocUseDirective/Hash PreprocRegion PreprocEndRegion PreprocUse": t.namespace,
 
         // Macro bucket — conditional directives, native, configuration-
         // extension markers. The `Preprocessor*/If` etc. selectors retag
         // BSL control-flow terms that share their surface form with
         // preprocessor keywords.
-        'PreprocessorIf PreprocessorElsif PreprocessorElse PreprocessorEndIf PreprocessorDelete PreprocessorEndDelete PreprocessorInsert PreprocessorEndInsert PreprocNativeDirective PreprocessorIf/"#" PreprocessorElsif/"#" PreprocessorElse/"#" PreprocessorEndIf/"#" PreprocessorDelete/"#" PreprocessorEndDelete/"#" PreprocessorInsert/"#" PreprocessorEndInsert/"#" PreprocNativeDirective/"#" PreprocessorIf/If PreprocessorIf/Then PreprocessorElsif/Elsif PreprocessorElsif/Then PreprocessorElse/Else PreprocessorEndIf/EndIf PreprocessorIf/Not PreprocessorElsif/Not PreprocessorIf/And PreprocessorElsif/And PreprocessorIf/Or PreprocessorElsif/Or PreprocDelete PreprocEndDelete PreprocInsert PreprocEndInsert PreprocNative': t.macroName,
+        "PreprocessorIf PreprocessorElsif PreprocessorElse PreprocessorEndIf PreprocessorDelete PreprocessorEndDelete PreprocessorInsert PreprocessorEndInsert PreprocNativeDirective PreprocessorIf/Hash PreprocessorElsif/Hash PreprocessorElse/Hash PreprocessorEndIf/Hash PreprocessorDelete/Hash PreprocessorEndDelete/Hash PreprocessorInsert/Hash PreprocessorEndInsert/Hash PreprocNativeDirective/Hash PreprocessorIf/If PreprocessorIf/Then PreprocessorElsif/Elsif PreprocessorElsif/Then PreprocessorElse/Else PreprocessorEndIf/EndIf PreprocessorIf/Not PreprocessorElsif/Not PreprocessorIf/And PreprocessorElsif/And PreprocessorIf/Or PreprocessorElsif/Or PreprocDelete PreprocEndDelete PreprocInsert PreprocEndInsert PreprocNative": t.macroName,
 
         ShebangLine: t.processingInstruction,
         "Region/RegionName": t.variableName,
 
         // ---- Punctuation and operators ----
-        // Punctuation literals are tagged via their wrapping named nodes
-        // (MulOp, AddOp, etc.) — the styleTags selector mini-language treats
-        // a bare `*` as a wildcard, so we cannot list multiplication directly.
+        // Every lexeme is named (Ampersand, Hash, Dot, …) so styleTags can
+        // reference them by identifier — no quoted-literal syntax needed.
+        // Leaf tokens get their tag directly; the *Op wrappers also get a
+        // tag for downstream consumers walking the tree, but the leaves win
+        // for highlighting.
         "OrOp AndOp": t.logicOperator,
-        CmpOp: t.compareOperator,
-        AddOp: t.arithmeticOperator,
-        MulOp: t.arithmeticOperator,
+        "CmpOp Assign NotEqual Less LessOrEqual Greater GreaterOrEqual": t.compareOperator,
+        "AddOp Plus Minus": t.arithmeticOperator,
+        "MulOp Mul Quotient Modulo": t.arithmeticOperator,
         UnaryOp: t.operator,
-        "( )": t.paren,
-        "[ ]": t.squareBracket,
-        "{ }": t.brace,
-        ", ;": t.separator,
-        ":": t.punctuation,
-        ".": t.derefOperator,
-        "?": t.controlOperator,
+        "LParen RParen": t.paren,
+        "LBrack RBrack": t.squareBracket,
+        "Comma Semicolon": t.separator,
+        Colon: t.punctuation,
+        Dot: t.derefOperator,
+        Question: t.controlOperator,
         // Default colour for `&`/`~`/`#` outside their usual contexts —
-        // contextual selectors above (Annotation/&, Preprocessor/#, etc.)
-        // take precedence when the token sits inside the matching parent.
-        "& ~ #": t.punctuation,
+        // contextual selectors above (Annotation/Ampersand, *Preprocessor/Hash,
+        // etc.) take precedence when the token sits inside the matching parent.
+        "Ampersand Tilda Hash": t.punctuation,
 
         // ---- Comments ----
         LineComment: t.lineComment,