tricu

compiler.test.mjs (4361B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import {createHash} from 'node:crypto';
 import {Graph} from '../dist/graph.js';
 import {natural,text,list,readText} from '../dist/codecs.js';
 import {compiledDefinitions,sourceLiteral,sourceText,SOURCE_LIMIT} from '../dist/compiler.js';
 test('compiler shipped pin matches authenticated reference and Haskell golden provenance',async()=>{
   const descriptor=JSON.parse(await readFile(new URL('../compiler.json',import.meta.url)));
   const goldens=JSON.parse(await readFile(new URL('./compiler-conformance.json',import.meta.url)));
   const shipped=await readFile(new URL('../bundles/'+descriptor.hash+'.arboricx',import.meta.url));
   assert.equal(createHash('sha256').update(shipped).digest('hex'),descriptor.hash);
   assert.equal(goldens.compilerBundleSha256,descriptor.hash);
   assert.match(descriptor.referenceCommit,/^[0-9a-f]{40}$/);
   // The site's accepted compiler is intentionally pinned independently of HEAD.
   // Authenticate it against its retained publication metadata below, not the
   // current compiler-library fixture. Never ask assert to diff megabyte buffers.
   const metadata=(await readFile(new URL('../compiler-reference.v1',import.meta.url),'utf8')).trim().split('\n');
   assert.equal(metadata[0],'tricu.compiler-library-fixture.v1');
   const fixtureDigest=createHash('sha256').update('tricu.compiler-library-fixture.v1\0').update(shipped).digest('hex');
   assert.deepEqual(metadata.filter(row=>row.startsWith('bundle\t')),['bundle\t'+fixtureDigest]);
   const sources=metadata.filter(row=>row.startsWith('module\t'));
   assert.equal(sources.length,28);
   assert.ok(sources.every(row=>row.split('\t')[2]!=='patterns'));
   for(const row of sources){
     const pin=row.split('\t')[4];assert.match(pin,/^[0-9a-f]{64}$/);
     const source=await readFile(new URL('../../../test/fixtures/reference-source/'+pin+'.tri',import.meta.url));
     assert.equal(createHash('sha256').update('arboricx.source.v1\0').update(source).digest('hex'),pin);
   }
   assert.equal(descriptor.export,'source_unit.compileStableModuleDefinitions');
 });
 test('bounded compiler result decoder preserves lazy program handles',()=>{
   const g=new Graph({fuel:5000}),q=g.fromTernary('212110021100'),loop=g.app(q,q);
   const binding=g.fork(text(g,'loop'),loop);
   const success=defs=>g.fork(g.stem(g.leaf),g.fork(defs,g.leaf));
   const exports=compiledDefinitions(g,success(list(g,[binding])));
   assert.equal(exports.get('loop'),loop); // No forcing/expansion of code to name exports.
   assert.throws(()=>compiledDefinitions(g,success(list(g,[binding,binding]))),/duplicate/);
   assert.throws(()=>compiledDefinitions(g,success(list(g,Array(17).fill(binding)))),/limit/);
   assert.throws(()=>compiledDefinitions(g,success(g.leaf)),/no definitions/);
   assert.throws(()=>compiledDefinitions(g,g.fork(g.stem(g.stem(g.leaf)),g.leaf)),/tag/);
   assert.throws(()=>sourceLiteral(g,'x'.repeat(SOURCE_LIMIT+1)),/limit/);
   assert.throws(()=>sourceLiteral(g,''),/Enter/);
   assert.throws(()=>sourceLiteral(g,'\ud800'),/surrogate/);
 });
 test('structured compiler diagnostics ignore arbitrary found/context/remainder trees',()=>{
   const g=new Graph({fuel:5000}),q=g.fromTernary('212110021100'),loop=g.app(q,q);
   const location=g.fork(natural(g,2n),g.fork(natural(g,3n),loop));
   const diagnostic=g.fork(natural(g,2n),g.fork(natural(g,7n),g.fork(loop,g.fork(location,loop))));
   const failure=g.fork(g.leaf,g.fork(diagnostic,loop));
   assert.throws(()=>compiledDefinitions(g,failure),/^Error: Compiler diagnostic 2 at 2:3: expected token kind 7$/);
   assert.ok(g.stats.work<1000);
 });
 
 test('16,384 scalar source validation and Worker encoding have no hidden 256/main-heap cap',()=>{
  assert.equal(SOURCE_LIMIT,16384);
  const ascii='x'.repeat(SOURCE_LIMIT), unicode='🙂'.repeat(SOURCE_LIMIT);
  assert.equal(sourceText(ascii),ascii);assert.equal(sourceText(unicode),unicode);
  assert.throws(()=>sourceText(unicode+'x'),/limit/);
  assert.throws(()=>sourceText(ascii+'x'),/limit/);
  assert.throws(()=>sourceText(' \n '),/Enter/);
  assert.throws(()=>sourceText('x\udc00'),/surrogate/);
  const g=new Graph({nodes:1_000_000,fuel:2_000_000});
  const encoded=sourceLiteral(g,unicode);
  assert.ok(g.stats.nodes>250000);assert.equal(readText(g,encoded,SOURCE_LIMIT),unicode);
 });