docs: record as contextual-keyword fix as deferred (entangled)

Attempted to generalize the #891 `from` guard to `as`/`keyof`/`is`/`infer`/`satisfies`
(all 'keyword only before a type/value'). It failed and was reverted: unlike `from`
(one scoping mechanism), these are scoped by four at once — the flat keyword group, a
per-keyword `keyword.operator.expression.as` rule, the type-inner injection, and the
structural type rules. De-keywording from the flat group alone (a) didn't fix
`const as = 1` and (b) regressed `keyof`/`is`/`infer` in type position to
entity.name.type (coverage 99.3%->99.2%). A correct fix must reconcile all four.

No functional change: gen-tm reverted to the `from`-only guard (tmLanguage byte-identical),
plus a clarifying comment; ledger documents the attempt + finding honestly. Coverage 99.3%,
test-issues 313/0 unchanged.

Author: johnsoncodehk

docs/upstream-issues.md

@@ -56,7 +56,9 @@ TM-expressible parse/lex disambiguation in Monogram's wheelhouse, still open aft
 - `#1071` `import.meta.dirname` — **contested:** we scope `import` as `keyword.control.import` (defensible — it *is* the import meta-property keyword) and `meta`/`dirname` as properties, with no breakage; the reporter wants `import` non-keyworded. Left until the intended scope is settled.
 - `#1048` multiline `extends` in a generic with split parens; `#857` multiple `export default` overloads; `#497` `import` declaration / semicolon scoping; `#810` trailing newline scope in a line comment; `#1039` `String.raw` escape-token visibility.
 
-**Contextual keywords (the `#891` class).** A word that is a keyword in some positions but a valid identifier elsewhere (`from`, `as`, `of`, …) was mis-scoped as a keyword *everywhere* by the flat global keyword match. Fixed generically for the always-before-a-fixed-token case: a scope-keyword the grammar *always* places immediately before the string token (only `from`: `'from' String_`) is now emitted with a `(?=\s*["'])` lookahead, so `const from = 1` / `from()` / the `import from from "x"` binding scope as `variable`/`entity.name.function` (matching the official grammar) while the import-source `from` stays a keyword. **Still open:** `as` as a plain identifier (`const as = 1`) — official scopes it `variable`, we still over-scope it (it's entangled with the `expr as Type` cast and the `x is T` type-predicate rules); `of` as an identifier (`const of = 1`) — **the official grammar mis-scopes this too**, so it's a both-wrong case, not a gap. Closing `as` needs the same positional treatment the cast/predicate rules already use.
+**Contextual keywords (the `#891` class).** A word that is a keyword in some positions but a valid identifier elsewhere (`from`, `as`, `of`, …) was mis-scoped as a keyword *everywhere* by the flat global keyword match. **Fixed** for the always-before-a-fixed-token case: a scope-keyword the grammar *always* places immediately before the string token (only `from`: `'from' String_`) is emitted with a `(?=\s*["'])` lookahead, so `const from = 1` / `from()` / the `import from from "x"` binding scope as `variable`/`entity.name.function` (matching official) while the import-source `from` stays a keyword.
+
+**Still open — `as` (attempted, reverted, deferred).** Generalizing the `from` guard to `as`/`keyof`/`is`/`infer`/`satisfies` (all "keyword only before a type/value") *failed*: unlike `from`, these are scoped by **four mechanisms at once** — the flat keyword group, a per-keyword `keyword.operator.expression.as` rule, the `type-inner` injection, and the structural type rules. De-keywording from the flat group alone both (a) *didn't* fix `const as = 1` (the per-keyword rule still fired) and (b) regressed `keyof`/`is`/`infer` in type position to `entity.name.type` (coverage 99.3%→99.2%). A correct fix must reconcile all four mechanisms positionally — real work, deferred. `of` as an identifier (`const of = 1`) — **the official grammar mis-scopes it too**, so it's a both-wrong case, not a gap.
 
 > Action: run each through `test/test-issues.ts` to confirm before claiming. Listing here ≠ "breaks in Monogram" — it means "not yet correct-and-tested."
 

src/gen-tm.ts

@@ -2260,13 +2260,15 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
         keywordGroups.get(scope)!.push(ident);
       }
     }
-    // A contextual keyword that the grammar ALWAYS places immediately before the
-    // string token (e.g. `'from' String_` in every import/export rule) is a keyword
-    // ONLY in that position — everywhere else it is a plain identifier (`const from = 1`,
-    // `from()`). Matching it globally mis-scopes those identifier uses, so emit it with a
-    // lookahead for a following string literal and let other uses fall through to
-    // identifier scoping. Structural + agnostic: keyed on "always-before-the-string-token",
-    // never on the word itself.
+    // A contextual keyword that the grammar ALWAYS places immediately before the string
+    // token (e.g. `'from' String_` in every import/export rule) is a keyword ONLY in that
+    // position — everywhere else it is a plain identifier (`const from = 1`, `from()`).
+    // Matching it globally mis-scopes those identifier uses, so emit it with a lookahead
+    // for a following string literal and let other uses fall through to identifier scoping.
+    // Structural + agnostic: keyed on "always-before-the-string-token", never on the word.
+    // (Only `from` qualifies. Other contextual keywords — `as`, `keyof`, `is`, … — are
+    // scoped by several mechanisms at once here, NOT just this flat group, so they can't be
+    // de-keyworded from one place; see docs/upstream-issues.md.)
     const stringTokName = grammar.tokens.find(t => t.string)?.name;
     const alwaysBeforeString = (lit: string): boolean => {
       if (!stringTokName) return false;