diff --git a/KNOWN-GAPS.md b/KNOWN-GAPS.md index 4860456..611bfd0 100644 --- a/KNOWN-GAPS.md +++ b/KNOWN-GAPS.md @@ -14,7 +14,7 @@ commits) so the ledger is deterministic and commit-trackable. Regenerate: `node test/gap-ledger.ts --write` · verify up-to-date: `node test/gap-ledger.ts --check`. -**0 gaps** across 7 grammars · 0 dropped. +**0 gaps** across 6 grammars · 0 dropped. _No gaps currently surface._ The generative check reports no valid-input flat-highlighter divergence on the derived corpus. (This is the ledger MECHANISM; it lists what the check finds.) diff --git a/README.md b/README.md index cddff8c..658cbae 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,15 @@ Write a language's grammar **once**, as an executable definition. Monogram runs - **TypeScript** ([`typescript.ts`](typescript.ts)) — mature: 100% valid-code coverage, 97.8% bidirectional vs `tsc`. - **JavaScript** ([`javascript.ts`](javascript.ts)) — the standalone ECMAScript base TypeScript [builds on](#adding-a-language) (subset → superset); parses real-world JS, with less conformance-corpus depth than TS so far. - **HTML** ([`html.ts`](html.ts)) — the engine reaching *past token streams into markup*; ~95 lines, validated against [`parse5`](https://github.com/inikulin/parse5). -- **Vue** ([`vue.ts`](vue.ts)) — a dialect of `html.ts`: SFC blocks that embed Monogram's own TS/JS/CSS, plus directives and `{{ }}` interpolation. +- **YAML** ([`yaml.ts`](yaml.ts)) — indentation-sensitive markup on the shared engine; validated against the maintained [RedCMD/YAML-Syntax-Highlighter](https://github.com/RedCMD/YAML-Syntax-Highlighter). + +## Used by + +Projects shipping Monogram-derived grammars: + +- [**vuejs/language-tools**](https://github.com/vuejs/language-tools) — the Vue TextMate grammars + VS Code language configuration ([vuejs/language-tools#6085](https://github.com/vuejs/language-tools/pull/6085)). + +Using Monogram in your project? Open a PR to add it here. ## Quick start @@ -77,7 +85,6 @@ This matters because `tsc`'s *parser* is not the same thing as the language. It | TSX | 96.7% · 65.7% | 95.6% vs 95.4% | | HTML | 95.3% · 49.3% | 100.0% vs 98.8% | | YAML | 100.0% · 73.9% | 100.0% vs 99.5% | -| Vue | — | 98.0% vs 98.0% | Measured against the *maintained* official grammar where it matters, not a dead bundle: JS/TS use Microsoft's maintained [TypeScript-TmLanguage](https://github.com/microsoft/TypeScript-TmLanguage); YAML uses the maintained [RedCMD/YAML-Syntax-Highlighter](https://github.com/RedCMD/YAML-Syntax-Highlighter) that VS Code switched to ([microsoft/vscode#232244](https://github.com/microsoft/vscode/pull/232244)); only HTML's baseline is the unmaintained [textmate/html.tmbundle](https://github.com/textmate/html.tmbundle) — the #203212 case Monogram targets. @@ -88,7 +95,7 @@ Take the bugs reported against each *hand-written* official grammar and ask whet -_Each hand-written **official** grammar vs Monogram's **derived** one, on the bugs filed against it: **TypeScript 26/26** (official 8/26) · **TSX 11/11** (official 5/11) · **HTML 20/20** (official 13/20) · **Vue 23/23** (official 18/23) · **YAML 8/8** (official 8/8). Per-issue detail below — auto-generated by `npm run bench:issues`._ +_Each hand-written **official** grammar vs Monogram's **derived** one, on the bugs filed against it: **TypeScript 26/26** (official 8/26) · **TSX 11/11** (official 5/11) · **HTML 20/20** (official 13/20) · **YAML 8/8** (official 8/8). Per-issue detail below — auto-generated by `npm run bench:issues`._ #### TypeScript | issue | Monogram | official | @@ -180,40 +187,6 @@ _Each hand-written **official** grammar vs Monogram's **derived** one, on the bu -#### Vue -| issue | Monogram | official | -|---|:--:|:--:| -| [#6007](https://github.com/vuejs/language-tools/issues/6007)/[#2096](https://github.com/vuejs/language-tools/issues/2096)/[#520](https://github.com/vuejs/language-tools/issues/520) — `as` type assertion in directive value | ✓ | · | -| [#2060](https://github.com/vuejs/language-tools/issues/2060)-inline — `` const a = 1; `` (content on the close line) embeds + clean close | ✓ | · | -| [#2060](https://github.com/vuejs/language-tools/issues/2060)-inline-adjacent — an unterminated union before a same-line `` ``, then a second ` `` | ✓ | ✓ | -| [#3999](https://github.com/vuejs/language-tools/issues/3999) — a force-wrapped multi-line ``, - ``, - ``, - ``, - ``, - ``, - `\n`, - ``, - `\n`, - ``, - ``, - ``, - `\n`, -]; - -const corpus = [ - ...CORE.map((text, i) => ({ name: `core#${i}`, text })), - ...vueIssueCases.map((c) => ({ name: `issue:${c.id}`, text: c.src })), -]; - -// ── tokenize via the faithful (injection-aware) harness; grade via the FROZEN table ────────── -// Return the FULL scope CHAIN (not just the innermost) so grading is STACK-AWARE, identical to -// scope-gap.ts's run(): a role correctly nested as an ancestor of a refinement is credited. -type ScopeAt = (offset: number) => string[]; -async function lookupFor(which: 'mono' | 'off', src: string): Promise { - const at = await scopeLookup(which, src); // offset → scopes[] (deepest last) - return (offset: number) => at(offset); -} - -const tally = { oCorrect: 0, oExact: 0, mCorrect: 0, mExact: 0, total: 0 }; -const perRole = new Map(); -const onlyMono: { text: string; role: RoleName; o: string; m: string }[] = []; -const onlyOff: { text: string; role: RoleName; o: string; m: string }[] = []; -const snip = { o: 0, m: 0, n: 0 }; -let nFiles = 0; - -for (const { text } of corpus) { - let gold: GoldToken[], oAt: ScopeAt, mAt: ScopeAt; - try { - gold = vueOracle(text); - oAt = await lookupFor('off', text); - mAt = await lookupFor('mono', text); - } catch { continue; } - nFiles++; - let okO = true, okM = true, gradedHere = 0; - for (const t of gold) { - const tier = ROLE_SPEC[t.role]?.tier; - if (!tier || tier === 'lexical') continue; // lexical floor: excluded from the headline - const so = oAt(t.start), sm = mAt(t.start); // full scope CHAINS - const vo = gradeScopeStack(t.role, so), vm = gradeScopeStack(t.role, sm); - const oc = isCorrect(vo), mc = isCorrect(vm); - tally.total++; gradedHere++; - if (oc) tally.oCorrect++; if (vo === 'exact') tally.oExact++; - if (mc) tally.mCorrect++; if (vm === 'exact') tally.mExact++; - const pr = perRole.get(t.role) ?? { n: 0, oC: 0, mC: 0 }; pr.n++; if (oc) pr.oC++; if (mc) pr.mC++; perRole.set(t.role, pr); - if (!oc) okO = false; if (!mc) okM = false; - const inner = (s: string[]) => s.length ? s[s.length - 1] : '(none)'; - if (mc && !oc && onlyMono.length < 40) onlyMono.push({ text: t.text, role: t.role, o: inner(so), m: inner(sm) }); - if (oc && !mc && onlyOff.length < 40) onlyOff.push({ text: t.text, role: t.role, o: inner(so), m: inner(sm) }); - } - if (gradedHere) { snip.n++; if (okO) snip.o++; if (okM) snip.m++; } -} - -const pct = (n: number, d = tally.total) => (d ? (100 * n / d).toFixed(1) : 'n/a'); -const gap = tally.total ? (100 * (tally.mCorrect - tally.oCorrect) / tally.total).toFixed(1) : 'n/a'; -console.log('='.repeat(78)); -console.log(' Scope-gap vs the PARSER oracle — Vue (vscode#203212)'); -console.log(' official: test/fixtures/vue-official/vue.tmLanguage.json monogram: vue.tmLanguage.json'); -console.log(' oracle: @vue/compiler-sfc split + parse5 (template) + tsc (script/expr)'); -console.log(' tokenized via vscode-tmlanguage-snapshot (injection-aware, vuejs/language-tools\' own tool)'); -console.log('='.repeat(78)); -console.log(` ${nFiles} files · ${tally.total} graded tokens (lexical-floor roles + directive names excluded)`); -console.log(` OFFICIAL correct ${pct(tally.oCorrect)}% (exact ${pct(tally.oExact)}%)`); -console.log(` MONOGRAM correct ${pct(tally.mCorrect)}% (exact ${pct(tally.mExact)}%)`); -console.log(` ══ GAP (Monogram − official) = ${gap} pts ══`); -console.log(` per-snippet all-tokens-correct: official ${pct(snip.o, snip.n)}% monogram ${pct(snip.m, snip.n)}% (n=${snip.n})`); - -const rows = [...perRole.entries()] - .map(([role, r]) => ({ role, n: r.n, o: r.oC, m: r.mC, d: r.mC - r.oC })) - .sort((a, b) => Math.abs(b.d) - Math.abs(a.d) || b.n - a.n); -console.log(`\n per-role correctness (official→monogram correct / occurrences):`); -for (const r of rows) console.log(` ${r.role.padEnd(16)} ${String(r.o).padStart(5)} →${String(r.m).padStart(5)} / ${r.n} ${r.d > 0 ? '+' : ''}${r.d || ''}`); - -if (onlyMono.length) { - console.log(`\n only-Monogram-correct tokens (official wrong vs the parser) — ${onlyMono.length} shown:`); - for (const x of onlyMono.slice(0, 12)) console.log(` «${x.text.slice(0, 18)}» ${x.role}: official «${x.o}» → monogram «${x.m}»`); -} -if (onlyOff.length) { - console.log(`\n only-official-correct tokens (Monogram wrong) — ${onlyOff.length} shown:`); - for (const x of onlyOff.slice(0, 12)) console.log(` «${x.text.slice(0, 18)}» ${x.role}: official «${x.o}» → monogram «${x.m}»`); -} -// Machine-readable summary (same shape as scope-gap.ts's ##SCOPEGAP## line) for any table generator. -console.log('##SCOPEGAP## ' + JSON.stringify({ - name: 'Vue', official: 'vue.tmLanguage.json', tokens: tally.total, - officialPct: tally.total ? (100 * tally.oCorrect) / tally.total : null, - monogramPct: tally.total ? (100 * tally.mCorrect) / tally.total : null, -})); -console.log('\nDone.'); diff --git a/test/scope-roles.ts b/test/scope-roles.ts index 3f0752f..882ecb6 100644 --- a/test/scope-roles.ts +++ b/test/scope-roles.ts @@ -507,8 +507,6 @@ if (import.meta.url === `file://${process.argv[1]}`) { [R.litString, ['source.yaml', 'keyword.control.flow.block-scalar.yaml'], 'exact', 'block-scalar indicator as scalar literal'], // HTML tag name correctly nested under an invalid.illegal overlay region. [R.tagName, ['text.html', 'meta.tag.metadata.svg', 'entity.name.tag.svg', 'invalid.illegal.unrecognized-tag.html'], 'exact', 'svg tag name with an illegal overlay innermost'], - // a Vue cast leak: the value `msg` correctly painted, deeper scope is just a meta wrapper. - [R.valueRef, ['text.html.vue', 'source.ts', 'meta.cast.expr.ts', 'variable.other.readwrite.ts'], 'family', 'value under a cast meta wrapper'], // THE GUARD: a value mis-painted as a generic — innermost is the type-name scope and the // only matching ancestors are COARSE region markers (meta.type.parameters, source). Nothing // role-bearing rescues it → still WRONG. (This is exactly #978/#859.) diff --git a/test/vue-bench.ts b/test/vue-bench.ts deleted file mode 100644 index b6b642a..0000000 --- a/test/vue-bench.ts +++ /dev/null @@ -1,182 +0,0 @@ -// ───────────────────────────────────────────────────────────────────────────── -// vue-bench.ts — Monogram's DERIVED Vue grammar vs the hand-written official one -// (vuejs/language-tools: vue.tmLanguage.json + vue-directives.json + vue-interpolations.json), -// graded by a NEUTRAL oracle (@vue/compiler-sfc for block structure + boundaries, -// @vue/compiler-dom for directives + interpolations) — the same shape as the scope-gap benches -// (both engines vs tsc) and html-bench (both vs parse5). -// -// Both grammars are tokenized through `vscode-tmlanguage-snapshot` — vuejs/language-tools' -// OWN grammar-test tool (see test/vue-grammar-harness.ts) — which resolves grammars + -// injections from a package.json `contributes`/`injectTo` descriptor exactly as VS Code -// does, so the head-to-head is faithful to how the official grammar is actually tested. -// -// Fairness: BOTH grammars embed Monogram's OWN source.ts / source.js / text.html.basic, so -// the script/template body tokenizes identically and only the VUE LAYER (block regions, -// embed boundaries, directives, interpolation) differs. -// -// This is NOT a coverage race — Monogram's Vue is a focused core; the official covers far -// more breadth (every lang=, modifiers, slots). The corpus is the SHARED CORE both target, -// and we grade per-construct correctness on it. Official grammars are dev-only fixtures -// (your own MIT work) under test/fixtures/vue-official; the bench skips if absent. -// -// Run: node test/vue-bench.ts -// ───────────────────────────────────────────────────────────────────────────── -import sfc from '@vue/compiler-sfc'; -import * as dom from '@vue/compiler-dom'; -import { scopeLookup, officialAvailable } from './vue-grammar-harness.ts'; - -if (!officialAvailable) { - console.log('⊘ Skipped: official Vue grammars not found under test/fixtures/vue-official.'); - console.log(' Fetch with: base=https://raw.githubusercontent.com/vuejs/language-tools/master/extensions/vscode/syntaxes'); - console.log(' curl -fsSL "$base/{vue.tmLanguage.json,vue-directives.json,vue-interpolations.json}" -O (into that dir)'); - process.exit(0); -} - -const familyOf = (sc: string[]): string => { - const s = sc.join(' '); - if (s.includes('source.ts')) return 'ts'; - if (s.includes('source.js')) return 'js'; - if (s.includes('source.css')) return 'css'; - if (s.includes('text.html')) return 'html'; - return 'other'; -}; - -// ── oracle facts (neutral: @vue) ── -interface Fact { cat: string; offset: number; test: (sc: string[]) => boolean; label: string } -function oracleFacts(src: string): Fact[] { - const facts: Fact[] = []; - const { descriptor } = sfc.parse(src); - const scriptFam = (lang?: string) => (lang === 'ts' || lang === 'tsx' ? 'ts' : 'js'); - const addBlock = (block: any, fam: string, label: string) => { - if (!block || block.loc.end.offset <= block.loc.start.offset) return; - // Sample the FIRST non-whitespace char of the body — representative of the embed, and it - // never lands on a nested interpolation/directive (which a midpoint could, giving 'ts'). - let off = block.loc.start.offset; - while (off < block.loc.end.offset && /\s/.test(src[off])) off++; - facts.push({ cat: 'block-embed', offset: off, test: sc => familyOf(sc) === fam, label }); - }; - addBlock(descriptor.template, 'html', 'template'); - addBlock(descriptor.script, scriptFam(descriptor.script?.lang), 'script' + (descriptor.script?.lang ? '/' + descriptor.script.lang : '')); - addBlock(descriptor.scriptSetup, scriptFam(descriptor.scriptSetup?.lang), 'script-setup' + (descriptor.scriptSetup?.lang ? '/' + descriptor.scriptSetup.lang : '')); - for (const st of descriptor.styles) addBlock(st, 'css', 'style' + (st.lang ? '/' + st.lang : '')); - // embed boundary: a script/style CLOSE tag must NOT be inside its embed (the #1666 class) - for (const m of src.matchAll(/<\/(script|style)\s*>/g)) { - const nameOff = m.index! + 2; // first char of the close-tag name - facts.push({ cat: 'embed-boundary', offset: nameOff, test: sc => { const f = familyOf(sc); return m[1] === 'style' ? f !== 'css' : (f !== 'ts' && f !== 'js'); }, label: `` }); - } - // directives + interpolations (neutral: @vue/compiler-dom over the template content) - if (descriptor.template) { - const base = descriptor.template.loc.start.offset; - const mid = (l: any) => base + Math.floor((l.start.offset + l.end.offset) / 2); - try { - const walk = (n: any) => { - if (n.type === 1) for (const p of n.props ?? []) { - if (p.type === 7) { - facts.push({ cat: 'directive-name', offset: base + p.loc.start.offset, label: 'v-' + p.name, test: sc => { const s = sc.join(' '); return s.includes('attribute-name') || s.includes('keyword') || s.includes('.vue'); } }); - if (p.exp?.loc) facts.push({ cat: 'directive-value', offset: mid(p.exp.loc), label: p.name + '=', test: sc => { const f = familyOf(sc); return f === 'ts' || f === 'js'; } }); - } - } - if (n.type === 5 && n.content?.loc) facts.push({ cat: 'interpolation', offset: mid(n.content.loc), label: 'interp', test: sc => { const f = familyOf(sc); return f === 'ts' || f === 'js'; } }); - for (const c of n.children ?? []) walk(c); - }; - walk(dom.parse(descriptor.template.content)); - } catch { /* invalid template expression (e.g. the over-permissive showcase) — skipped */ } - } - return facts; -} - -// ── corpus: the SHARED CORE both grammars target ── -const corpus: string[] = [ - ``, - ``, - ``, - ``, - `
{{ msg }}
\n`, - ``, - ``, - ``, - `\n`, - ``, - `\n`, - ``, - // harder cases — probe where a DERIVED grammar might fall short of the hand-written one - ``, // event modifiers - ``, // destructure + member - ``, // scoped slot - ``, // multi-line interpolation - ``, // generic call in script -]; - -// ── grade ── -const cats = ['block-embed', 'embed-boundary', 'interpolation', 'directive-name', 'directive-value']; -const tally: Record = {}; -for (const c of cats) tally[c] = { mono: 0, off: 0, n: 0 }; -const wins: string[] = []; -for (const src of corpus) { - const facts = oracleFacts(src); - const mAt = await scopeLookup('mono', src), oAt = await scopeLookup('off', src); - for (const f of facts) { - const t = tally[f.cat]; if (!t) continue; - const m = f.test(mAt(f.offset)), o = f.test(oAt(f.offset)); - t.n++; if (m) t.mono++; if (o) t.off++; - if (m !== o) wins.push(` ${f.cat} ${f.label}: ${m ? 'Monogram ✓ / official ✗' : 'official ✓ / Monogram ✗'}`); - } -} - -// ── special showcases (Monogram's derived fixes) ── -const overPermSrc = ``; -const mConst = (await scopeLookup('mono', overPermSrc))(overPermSrc.indexOf('const') + 2).join(' '); -const oConst = (await scopeLookup('off', overPermSrc))(overPermSrc.indexOf('const') + 2).join(' '); - -console.log('\n══════════════════════════════════════════════════════════════════════'); -console.log(' Monogram (derived) vs official vue.tmLanguage.json (hand-written)'); -console.log(' Graded by @vue/compiler-sfc + @vue/compiler-dom (neutral oracle).'); -console.log(' Tokenized via vscode-tmlanguage-snapshot (vuejs/language-tools\' own tool).'); -console.log('══════════════════════════════════════════════════════════════════════'); -console.log(' category Monogram official'); -let mAll = 0, oAll = 0, nAll = 0; -for (const c of cats) { - const t = tally[c]; if (!t.n) continue; - mAll += t.mono; oAll += t.off; nAll += t.n; - console.log(` ${c.padEnd(18)} ${(`${t.mono}/${t.n}`).padEnd(13)} ${t.off}/${t.n}`); -} -console.log(' ' + '─'.repeat(50)); -console.log(` ${'OVERALL'.padEnd(18)} ${(`${mAll}/${nAll} (${(100 * mAll / nAll).toFixed(1)}%)`).padEnd(13)} ${oAll}/${nAll} (${(100 * oAll / nAll).toFixed(1)}%)`); -if (wins.length) { console.log('\n per-fact disagreements:'); for (const w of wins) console.log(w); } - -// How close are the two grammars OVERALL (beyond the oracle points)? Char-level family agreement. -let same = 0, total = 0; const div: Record = {}; const divEx: Record = {}; -for (const src of corpus) { - const mAt = await scopeLookup('mono', src), oAt = await scopeLookup('off', src); - for (let i = 0; i < src.length; i++) { - if (/\s/.test(src[i])) continue; - const mf = familyOf(mAt(i)), of = familyOf(oAt(i)); - total++; - if (mf === of) { same++; continue; } - const k = `${mf}≠${of}`; div[k] = (div[k] ?? 0) + 1; - (divEx[k] ??= []); if (divEx[k].length < 3) divEx[k].push(JSON.stringify(src.slice(Math.max(0, i - 5), i + 6))); - } -} -console.log(`\n char-level family agreement (whole corpus): ${(100 * same / total).toFixed(1)}% (${same}/${total})`); -for (const [k, v] of Object.entries(div).sort((a, b) => b[1] - a[1]).slice(0, 5)) - console.log(` divergence ${k} ×${v} — e.g. ${divEx[k].join(' ')}`); - -console.log('\n ── shared MECHANISMS (Monogram derives what the official hand-wrote) ──'); -console.log(` begin/while embed boundary (#1666): both use it — Monogram derives it, official hand-wrote it.`); -console.log(` source.ts#expression interpolation embed: both use it — \`{{ const z = 1 }}\` →`); -console.log(` Monogram: const ${mConst.includes('storage.type') ? 'is storage.type' : 'NOT a keyword ✓'}; official: const ${oConst.includes('storage.type') ? 'is storage.type' : 'NOT a keyword ✓'}`); -console.log(` (the official's #vue-interpolations ALSO embeds source.ts#expression — Monogram DERIVES the same.)`); - -console.log('\n Honest reading:'); -console.log(' • This is the SHARED CORE. The official covers far more breadth (every lang= dialect,'); -console.log(' directive modifiers, pug/markdown, slot scoping) — not a coverage race.'); -console.log(' • On the neutral oracle facts the two grammars TIE. The char-level divergences are all'); -console.log(' the #6007/#5012 intra-line `as` case (e.g. `:value="msg as string"`): Monogram bounds'); -console.log(' the directive value with a capture-embed, so the closing `"` and everything after'); -console.log(' recover to HTML; the official begin/end region lets the cast\'s type eat the quote and'); -console.log(' leak TS across the rest of the tag. Here the DERIVED grammar is correct and the'); -console.log(' hand-written one is not — the one reported issue (#6007) the official still fails.'); -console.log(' • So: "derived MATCHES hand-written on the core, and is strictly more correct on `as`".'); -// Gate: on the shared core, the derived grammar must stay competitive with the hand-written one. -if (mAll < oAll * 0.9) { console.log(`\n✗ Monogram (${mAll}) fell below 90% of official (${oAll}) on the shared core`); process.exit(1); } -console.log(`\n✓ Derived Vue grammar is competitive with the hand-written official on the shared core.`); diff --git a/test/vue-directives.ts b/test/vue-directives.ts deleted file mode 100644 index e55f32b..0000000 --- a/test/vue-directives.ts +++ /dev/null @@ -1,59 +0,0 @@ -// ───────────────────────────────────────────────────────────────────────────── -// vue-directives.ts — gates Vue increment 2: the DERIVED injection grammar -// (vue.directives.json / vue.interpolations.json) adds directives (v-for / v-if / :bind / @event / -// #slot) and {{ }} interpolation ONTO the HTML scopes inside a