Scope a YAML block-scalar explicit key like a block scalar, not a name

A block scalar used as an explicit key (`? |` / `? >`) was scoped entirely as
`entity.name.tag` — including the `|`/`>` introducer. But `|`/`>` is a block-scalar
control sigil, never a name (this is exactly what fca5499 fixed for value-position
block scalars); painting it as a name in key position was the same mis-scope left on
one branch. And once the introducer is a keyword, the body should be a string too,
for coherence: a block scalar is `<keyword indicator><string body>` everywhere, and
the key-ness of a `? |` key is already carried by the `?` (map-key punctuation) and
the `:` separator — recolouring the body as a name only in key position makes the
construct look unlike itself depending on position. The maintained official grammar
does the coherent thing, and loses no information.

Now `? |\n  k\n: v` → `?`=punctuation.definition.map.key, `|`=keyword.control.flow.
block-scalar, body=string.unquoted.block (matching official). The oracle splits a
block-scalar key the same as a value (block-indicator + string body), so both
grammars are graded correct — the earlier false "Monogram-only" win is gone and the
official baseline is no longer unfairly penalised (YAML official 98.9% -> 99.0%,
gap +0.3 -> +0.2; Monogram still 99.2%). Parser 100% aligned; other six grammars
byte-identical.

Author: johnsoncodehk

src/gen-tm.ts

@@ -4636,6 +4636,8 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
   let bsIntro = '';
   let bsFunkyIntroRule: ((indicatorScope: string, contentScope: string) => TmPattern) | null = null;
   let bsHeaderIncludes: { include: string }[] = [];
+  let bsIndicatorScope = '';
+  let bsContentScope = '';
   if (blockScalar) {
     const bsTok = grammar.tokens.find(t => t.name === blockScalar.token);
     const bsKey = blockScalar.token.toLowerCase();
@@ -4736,6 +4738,8 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
     bsIntro = intro;
     bsFunkyIntroRule = bsIntroRule;
     bsHeaderIncludes = bsHeaderIncs;
+    bsIndicatorScope = bsIndicator;
+    bsContentScope = bsContent;
     repository[bsKey] = {
       begin: `^([ \\t]*)(?=${bsVp}${intro}[\\t ]*(?:#|$))`,
       while: '\\G(?=\\1[ \\t]|[ \\t]*$)',
@@ -4826,20 +4830,20 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
     topPatterns.push({ include: '#explicit-key-indicator' });
 
     // A block scalar can ALSO be an explicit key (`? |` / `? >`). An implicit key must be a single
-    // line, so a multi-line block scalar key is ALWAYS `?`-introduced — and like every other scalar
-    // key (plain / quoted, both already `entity.name.tag`) its content is the KEY NAME, not a value
-    // string. Same PORTABLE structure as §2a (forward-captured node indent + funky body), but gated on
-    // the `?` indicator and scoping the introducer + body with the KEY scope. The `?` is captured as
-    // map-key punctuation; the inner introducer rule scopes the `|`/`>` and the body as the key name.
-    // Ranked above the value-position block scalar (scopeOrder) so `? |` wins; a `: |` value has no
-    // leading `?`, so it is untouched.
+    // line, so a multi-line block scalar key is ALWAYS `?`-introduced. The block scalar itself is
+    // scoped like ANY block scalar — introducer (`|`/`>`) → the block-scalar keyword, body →
+    // string.unquoted.block — and the KEY-ness is carried by the `?` (map-key punctuation) + the `:`
+    // separator, NOT by recolouring the body as a name. (`|`/`>` is a control sigil, never a name; and
+    // a block scalar should read the SAME in key or value position — the official grammar does exactly
+    // this.) Same PORTABLE structure as §2a (forward-captured node indent + funky body), gated on the
+    // `?` indicator. Ranked above the value-position block scalar (scopeOrder) so `? |` wins; a `: |`
+    // value has no leading `?`, so it is untouched.
     if (blockScalar && bsFunkyIntroRule) {
-      const keyScope = `${explicitKey.keyScope}.${langName}`;
       repository['blockscalar-key'] = {
         begin: `^([ \\t]*)(${escapeRegex(explicitKey.indicator)})([\\t ]+)(?=${bsIntro}[\\t ]*(?:#|$))`,
         beginCaptures: { '2': { name: `punctuation.definition.map.key.${langName}` } },
         while: '\\G(?=\\1[ \\t]|[ \\t]*$)',
-        patterns: [bsFunkyIntroRule(keyScope, keyScope), ...bsHeaderIncludes],
+        patterns: [bsFunkyIntroRule(bsIndicatorScope, bsContentScope), ...bsHeaderIncludes],
       };
       topPatterns.push({ include: '#blockscalar-key' });
     }

test/yaml-oracle.ts

@@ -37,9 +37,10 @@ export function yamlOracle(text: string): GoldToken[] {
     ESCAPE.lastIndex = 0;
     while ((m = ESCAPE.exec(seg))) out.push({ start: r[0] + m.index, end: r[0] + m.index + m[0].length, text: m[0], role: R.escape });
   };
-  // A VALUE-position block scalar (`|`/`>`): split the introducer (a structural control sigil) from
-  // the verbatim body. introducer = `|`/`>` + chomping/indent on the header line; body = the lines
-  // below. (A block scalar in KEY position stays ONE tagName token — the whole scalar is the key name.)
+  // A block scalar (`|`/`>`), in KEY or VALUE position: split the introducer (a structural control
+  // sigil → block-indicator) from the verbatim body (a string). introducer = `|`/`>` + chomping/indent
+  // on the header line; body = the lines below. A block scalar reads the SAME wherever it sits — the
+  // key-ness of a `? |` key is carried by the `?`/`:`, NOT by recolouring the body as a name.
   const isBlockScalar = (n: any) => n?.type === 'BLOCK_LITERAL' || n?.type === 'BLOCK_FOLDED';
   const pushBlockScalar = (node: any): void => {
     const r = node?.range;
@@ -57,7 +58,7 @@ export function yamlOracle(text: string): GoldToken[] {
   const walk = (node: any, isKey: boolean): void => {
     if (!node) return;
     if (isScalar(node)) {
-      if (!isKey && isBlockScalar(node)) pushBlockScalar(node);
+      if (isBlockScalar(node)) pushBlockScalar(node);
       else { push(node, isKey ? R.tagName : valueRole(node.value)); pushEscapes(node); }
     }
     else if (isMap(node)) for (const p of node.items) { walk(p.key, true); walk(p.value, false); }

yaml.tmLanguage.json

@@ -631,7 +631,7 @@
           "begin": "[\\t ]*([|>](?:[1-9][-+]?|[-+][1-9]?|[-+])?)(?=[\\t ]*(?:#|$))([\\t ]*.*)",
           "beginCaptures": {
             "1": {
-              "name": "entity.name.tag.yaml"
+              "name": "keyword.control.flow.block-scalar.yaml"
             },
             "2": {
               "patterns": [
@@ -650,7 +650,7 @@
                 {
                   "begin": "\\G( ++)$",
                   "while": "\\G(?>(\\1)$|(?!\\1)( *+)($|.))",
-                  "contentName": "entity.name.tag.yaml"
+                  "contentName": "string.unquoted.block.yaml"
                 },
                 {
                   "begin": "\\G(?!$)(?=( *+))",
@@ -659,7 +659,7 @@
                     {
                       "begin": "\\G( *+)",
                       "while": "\\G(?>(\\1)|( *+)($|[^\\t#]|[\\t ]++[^#]))",
-                      "contentName": "entity.name.tag.yaml"
+                      "contentName": "string.unquoted.block.yaml"
                     }
                   ]
                 },