@shapeshift-labs/frontier-lang-parser 0.3.9 → 0.3.10

package/dist/index.js

@@ -12,12 +12,17 @@ import {
   targetNode,
   typeNode
 } from '@shapeshift-labs/frontier-lang-kernel';
+import { createParsedMetadata } from './metadata.js';
+import { parseSemanticOperationsBlock } from './operations.js';
+import { parseParadigmBlock } from './paradigm.js';
 import { parseProofBlock } from './proof.js';
 import { parseViewBlock } from './view.js';
 
 export function parseFrontierSource(source, options = {}) {
   const nodes = [];
   const proofBlocks = [];
+  const paradigmBlocks = [];
+  const operationBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
   for (const block of readBlocks(source)) {
@@ -34,8 +39,11 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'nativeSource') nodes.push(parseNativeSource(block));
     if (block.kind === 'target') nodes.push(parseTarget(block));
     if (block.kind === 'proof') proofBlocks.push(parseProofBlock(block));
+    if (block.kind === 'paradigm' || block.kind === 'paradigmSemantics') paradigmBlocks.push(parseParadigmBlock(block));
+    if (block.kind === 'operations' || block.kind === 'semanticOperations') operationBlocks.push(parseSemanticOperationsBlock(block));
   }
-  return createDocument({ id: documentId, name: documentName, nodes, ...(proofBlocks.length ? { metadata: { proof: mergeProofBlocks(proofBlocks) } } : {}) });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks });
+  return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
 export function parseFrontierFile(name, source) { return parseFrontierSource(source, { name: name.replace(/\.frontier$/, '') }); }
@@ -44,7 +52,7 @@ function readName(source) { return /module\s+([A-Za-z_$][\w$]*)/.exec(source)?.[
 function readId(source) { return /module\s+[A-Za-z_$][\w$]*\s+@id\(\s*["']([^"']+)["']\s*\)/.exec(source)?.[1]; }
 function readBlocks(source) {
   const blocks = [];
-  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof)\s+([^{}]+)\{/g;
+  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;
@@ -54,15 +62,6 @@ function readBlocks(source) {
   }
   return blocks;
 }
-const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
-function mergeProofBlocks(blocks) {
-  const proof = {
-    id: blocks.length === 1 ? blocks[0].id : 'proof:source',
-    metadata: { authoredProofBlockIds: blocks.map((block) => block.id) }
-  };
-  for (const group of PROOF_GROUPS) proof[group] = blocks.flatMap((block) => block[group] ?? []);
-  return proof;
-}
 function idFrom(header, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1] ?? fallback; }
 function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Unnamed'; }
 function parseEntity(block) {

package/dist/metadata.js

@@ -0,0 +1,56 @@
+const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
+const PARADIGM_GROUPS = [
+  'bindingScopes',
+  'bindings',
+  'patterns',
+  'typeConstraints',
+  'evaluationModels',
+  'memoryLocations',
+  'effectRegions',
+  'controlRegions',
+  'logicPrograms',
+  'actorSystems',
+  'stackEffects',
+  'arrayShapes',
+  'numericKernels',
+  'dataflowNetworks',
+  'clockModels',
+  'objectModels',
+  'macroExpansions',
+  'reflectionBoundaries',
+  'loweringRecords'
+];
+
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [] } = {}) {
+  const metadata = {};
+  if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
+  if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
+  if (operationBlocks.length) metadata.semanticOperations = mergeOperationBlocks(operationBlocks);
+  return Object.keys(metadata).length ? metadata : undefined;
+}
+
+function mergeProofBlocks(blocks) {
+  const proof = {
+    id: blocks.length === 1 ? blocks[0].id : 'proof:source',
+    metadata: { authoredProofBlockIds: blocks.map((block) => block.id) }
+  };
+  for (const group of PROOF_GROUPS) proof[group] = blocks.flatMap((block) => block[group] ?? []);
+  return proof;
+}
+
+function mergeParadigmBlocks(blocks) {
+  const paradigm = {
+    id: blocks.length === 1 ? blocks[0].id : 'paradigm:source',
+    metadata: { authoredParadigmBlockIds: blocks.map((block) => block.id) }
+  };
+  for (const group of PARADIGM_GROUPS) paradigm[group] = blocks.flatMap((block) => block[group] ?? []);
+  return paradigm;
+}
+
+function mergeOperationBlocks(blocks) {
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'semanticOperations:source',
+    operations: blocks.flatMap((block) => block.operations ?? []),
+    metadata: { authoredSemanticOperationBlockIds: blocks.map((block) => block.id) }
+  };
+}

package/dist/operations.js

@@ -0,0 +1,59 @@
+export function parseSemanticOperationsBlock(block) {
+  const name = nameFrom(block.header);
+  const operationSet = { id: idFrom(block.header, `semanticOperations_${name}`), operations: [], metadata: { name } };
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const match = /^(operation|op)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (match) operationSet.operations.push(parseSemanticOperationRecord(match[2], match[3]));
+  }
+  return operationSet;
+}
+
+function parseSemanticOperationRecord(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `semanticOperation_${name}`),
+    operationKind: readInlineWord('operationKind', text) ?? readInlineWord('op', text) ?? readInlineWord('kind', text),
+    language: readInlineWord('language', text),
+    name,
+    target: readInlineWord('target', text),
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeIds: readInlineList(text, 'nativeAstNode', 'nativeAstNodes', 'nativeAstNodeIds'),
+    semanticNodeIds: readInlineList(text, 'semanticNode', 'semanticNodes', 'semanticNodeIds'),
+    semanticSymbolIds: readInlineList(text, 'semanticSymbol', 'semanticSymbols', 'semanticSymbolIds'),
+    semanticOccurrenceIds: readInlineList(text, 'semanticOccurrence', 'semanticOccurrences', 'semanticOccurrenceIds'),
+    sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMaps', 'sourceMapIds'),
+    sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingIds'),
+    proofObligationIds: readInlineList(text, 'proofObligation', 'proofObligations', 'proofObligationIds'),
+    proofArtifactIds: readInlineList(text, 'proofArtifact', 'proofArtifacts', 'proofArtifactIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    lossIds: readInlineList(text, 'loss', 'lossIds'),
+    reads: readInlineList(text, 'read', 'reads'),
+    writes: readInlineList(text, 'write', 'writes'),
+    effectIds: readInlineList(text, 'effect', 'effects', 'effectIds'),
+    resources: readInlineList(text, 'resource', 'resources'),
+    ownershipKeys: readInlineList(text, 'ownerKey', 'ownershipKey', 'ownershipKeys'),
+    conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'),
+    readiness: readInlineWord('readiness', text),
+    dynamic: readInlineFlag('dynamic', text),
+    opaque: readInlineFlag('opaque', text),
+    summary: readInlineQuoted('summary', text)
+  });
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'SemanticOperations'; }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineQuoted(label, text) { return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim(); }
+function readInlineFlag(label, text) { return new RegExp('(?:^|\\s)' + label + '(?:\\s|$)').test(text) || undefined; }
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/paradigm.js

@@ -0,0 +1,93 @@
+const GROUPS = {
+  bindingScope: 'bindingScopes',
+  binding: 'bindings',
+  pattern: 'patterns',
+  typeConstraint: 'typeConstraints',
+  evaluationModel: 'evaluationModels',
+  memoryLocation: 'memoryLocations',
+  effectRegion: 'effectRegions',
+  controlRegion: 'controlRegions',
+  logicProgram: 'logicPrograms',
+  actorSystem: 'actorSystems',
+  stackEffect: 'stackEffects',
+  arrayShape: 'arrayShapes',
+  numericKernel: 'numericKernels',
+  dataflowNetwork: 'dataflowNetworks',
+  clockModel: 'clockModels',
+  objectModel: 'objectModels',
+  macroExpansion: 'macroExpansions',
+  reflectionBoundary: 'reflectionBoundaries',
+  lowering: 'loweringRecords',
+  loweringRecord: 'loweringRecords'
+};
+
+export function parseParadigmBlock(block) {
+  const name = nameFrom(block.header);
+  const layer = { id: idFrom(block.header, `paradigm_${name}`), metadata: { name } };
+  for (const group of new Set(Object.values(GROUPS))) layer[group] = [];
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const match = /^([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, section, recordName, rest] = match;
+    const group = GROUPS[section];
+    if (group) layer[group].push(parseParadigmRecord(section, recordName, rest));
+  }
+  return omitEmptyArrays(layer);
+}
+
+function parseParadigmRecord(section, name, text) {
+  return cleanRecord({
+    id: idFrom(text, `paradigm_${section}_${name}`),
+    kind: readInlineWord('kind', text) ?? section,
+    subjectKind: readInlineWord('subjectKind', text),
+    subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text),
+    semanticNodeId: readInlineWord('semanticNode', text) ?? readInlineWord('semanticNodeId', text),
+    semanticSymbolId: readInlineWord('semanticSymbol', text) ?? readInlineWord('semanticSymbolId', text),
+    semanticOccurrenceId: readInlineWord('semanticOccurrence', text) ?? readInlineWord('semanticOccurrenceId', text),
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeId: readInlineWord('nativeAstNode', text) ?? readInlineWord('nativeAstNodeId', text),
+    sourceMapId: readInlineWord('sourceMap', text) ?? readInlineWord('sourceMapId', text),
+    sourceMapMappingId: readInlineWord('sourceMapMapping', text) ?? readInlineWord('sourceMapMappingId', text),
+    bindingScopeId: readInlineWord('bindingScope', text) ?? readInlineWord('bindingScopeId', text),
+    parentScopeId: readInlineWord('parentScope', text) ?? readInlineWord('parentScopeId', text),
+    bindingId: readInlineWord('binding', text) ?? readInlineWord('bindingId', text),
+    patternId: readInlineWord('pattern', text) ?? readInlineWord('patternId', text),
+    typeConstraintId: readInlineWord('typeConstraint', text) ?? readInlineWord('typeConstraintId', text),
+    evaluationModelId: readInlineWord('evaluationModel', text) ?? readInlineWord('evaluationModelId', text),
+    memoryLocationId: readInlineWord('memoryLocation', text) ?? readInlineWord('memoryLocationId', text),
+    effectRegionId: readInlineWord('effectRegion', text) ?? readInlineWord('effectRegionId', text),
+    controlRegionId: readInlineWord('controlRegion', text) ?? readInlineWord('controlRegionId', text),
+    loweringRecordId: readInlineWord('lowering', text) ?? readInlineWord('loweringRecordId', text),
+    sourceRecordId: readInlineWord('sourceRecord', text) ?? readInlineWord('sourceRecordId', text),
+    targetRecordId: readInlineWord('targetRecord', text) ?? readInlineWord('targetRecordId', text),
+    effectIds: readInlineList(text, 'effect', 'effects', 'effectIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    lossIds: readInlineList(text, 'loss', 'lossIds'),
+    relatedRecordIds: readInlineList(text, 'related', 'relatedRecordIds'),
+    statement: readInlineQuoted('statement', text),
+    description: readInlineQuoted('description', text),
+    language: readInlineWord('language', text),
+    metadata: { name }
+  });
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Paradigm'; }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineQuoted(label, text) { return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim(); }
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}
+function omitEmptyArrays(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => !Array.isArray(value) || value.length > 0));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.9",
+  "version": "0.3.10",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",