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

package/dist/conversion.js

@@ -0,0 +1,121 @@
+const FAMILIES = {
+  type: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
+  typeConstraint: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
+  controlFlow: { field: 'controlFlowConstraints', sourceKey: 'sourceControlFlows', targetKey: 'targetControlFlows' },
+  controlFlowConstraint: { field: 'controlFlowConstraints', sourceKey: 'sourceControlFlows', targetKey: 'targetControlFlows' },
+  lifetime: { field: 'lifetimeConstraints', sourceKey: 'sourceLifetimeConstraints', targetKey: 'targetLifetimeConstraints' },
+  lifetimeConstraint: { field: 'lifetimeConstraints', sourceKey: 'sourceLifetimeConstraints', targetKey: 'targetLifetimeConstraints' },
+  callableBoundary: { field: 'callableBoundaryConstraints', sourceKey: 'sourceCallables', targetKey: 'targetCallables' },
+  adtPattern: { field: 'adtPatternConstraints', sourceKey: 'sourcePatterns', targetKey: 'targetPatterns' },
+  dataLayout: { field: 'dataLayoutConstraints', sourceKey: 'sourceLayouts', targetKey: 'targetLayouts' },
+  effect: { field: 'effectConstraints', sourceKey: 'sourceEffects', targetKey: 'targetEffects' },
+  concurrencyModel: { field: 'concurrencyModelConstraints', sourceKey: 'sourceConcurrencyModels', targetKey: 'targetConcurrencyModels' },
+  errorModel: { field: 'errorModelConstraints', sourceKey: 'sourceErrors', targetKey: 'targetErrors' },
+  evaluationModel: { field: 'evaluationModelConstraints', sourceKey: 'sourceEvaluations', targetKey: 'targetEvaluations' },
+  hostEnvironment: { field: 'hostEnvironmentConstraints', sourceKey: 'sourceHosts', targetKey: 'targetHosts' },
+  memoryModel: { field: 'memoryModelConstraints', sourceKey: 'sourceMemoryModels', targetKey: 'targetMemoryModels' },
+  metaprogramming: { field: 'metaprogrammingConstraints', sourceKey: 'sourceMetaprograms', targetKey: 'targetMetaprograms' },
+  module: { field: 'moduleConstraints', sourceKey: 'sourceModules', targetKey: 'targetModules' },
+  scopeBinding: { field: 'scopeBindingConstraints', sourceKey: 'sourceBindings', targetKey: 'targetBindings' },
+  numericSemantics: { field: 'numericSemanticsConstraints', sourceKey: 'sourceNumerics', targetKey: 'targetNumerics' },
+  textSemantics: { field: 'textSemanticsConstraints', sourceKey: 'sourceTexts', targetKey: 'targetTexts' },
+  collectionSemantics: { field: 'collectionSemanticsConstraints', sourceKey: 'sourceCollections', targetKey: 'targetCollections' },
+  serializationSemantics: { field: 'serializationSemanticsConstraints', sourceKey: 'sourceSerializations', targetKey: 'targetSerializations' },
+  dependencySemantics: { field: 'dependencySemanticsConstraints', sourceKey: 'sourceDependencies', targetKey: 'targetDependencies' },
+  objectModel: { field: 'objectModelConstraints', sourceKey: 'sourceObjects', targetKey: 'targetObjects' },
+  protocol: { field: 'protocolConstraints', sourceKey: 'sourceProtocols', targetKey: 'targetProtocols' }
+};
+
+export function parseConversionBlock(block) {
+  const name = nameFrom(block.header);
+  const plan = { id: idFrom(block.header, `conversion_${name}`), targets: [], metadata: { name } };
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const target = /^target\s+([^\s,]+)/.exec(line)?.[1];
+    const sourceLanguage = /^sourceLanguage\s+([^\s,]+)/.exec(line)?.[1] ?? /^source\s+([^\s,]+)/.exec(line)?.[1];
+    const constraint = /^constraint\s+([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (target) plan.targets.push(target);
+    else if (sourceLanguage) plan.sourceLanguage = sourceLanguage;
+    else if (constraint) addConstraint(plan, constraint[1], constraint[2], constraint[3]);
+  }
+  return cleanRecord({ ...plan, targets: unique(plan.targets) });
+}
+
+function addConstraint(plan, family, name, text) {
+  const config = FAMILIES[family] ?? { field: family.endsWith('s') ? family : `${family}Constraints`, sourceKey: 'sourceRecords', targetKey: 'targetRecords' };
+  const role = readInlineWord('role', text) ?? 'source';
+  const record = parseConstraintRecord(name, text, role);
+  const entry = cleanRecord({
+    id: idFrom(text, `${config.field}_${name}`),
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? plan.sourceLanguage,
+    target: readInlineWord('target', text) ?? plan.targets[0],
+    mode: readInlineWord('mode', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence'),
+    blockers: readInlineList(text, 'blocker', 'blockers'),
+    review: readInlineList(text, 'review'),
+    metadata: { name, family, authoredConversionBlockId: plan.id }
+  });
+  const recordKey = role === 'target' ? config.targetKey : config.sourceKey;
+  entry[recordKey] = [record];
+  plan[config.field] = [...(plan[config.field] ?? []), entry];
+}
+
+function parseConstraintRecord(name, text, role) {
+  const kind = readInlineWord('kind', text) ?? readInlineWord('constraintKind', text);
+  return cleanRecord({
+    id: readInlineWord('recordId', text) ?? idFrom(text, `constraint_record_${name}`),
+    role,
+    kind,
+    name: readInlineWord('name', text) ?? name,
+    constraintKind: readInlineWord('constraintKind', text),
+    constraintKinds: readInlineList(text, 'constraint', 'constraints', 'constraintKind', 'constraintKinds') ?? (kind ? [kind] : undefined),
+    factKinds: readInlineList(text, 'fact', 'facts', 'factKind', 'factKinds'),
+    symbolId: readInlineWord('symbol', text) ?? readInlineWord('symbolId', text),
+    symbolName: readInlineWord('symbolName', text),
+    localName: readInlineWord('localName', text),
+    typeKind: readInlineWord('typeKind', text),
+    signatureHash: readInlineWord('signatureHash', text),
+    contractHash: readInlineWord('contractHash', text),
+    typeHash: readInlineWord('typeHash', text),
+    flowKind: readInlineWord('flowKind', text),
+    sourceId: readInlineWord('from', text) ?? readInlineWord('sourceId', text),
+    targetId: readInlineWord('to', text) ?? readInlineWord('targetId', text),
+    label: readInlineWord('label', text),
+    conditionHash: readInlineWord('conditionHash', text),
+    orderingKey: readInlineWord('orderingKey', text) ?? readInlineWord('orderKey', text),
+    lifetimeKind: readInlineWord('lifetimeKind', text),
+    regionKind: readInlineWord('regionKind', text),
+    predicate: readInlineQuoted('predicate', text) ?? readInlineWord('predicate', text),
+    resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    sourceHash: readInlineWord('sourceHash', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    nullable: readInlineFlag('nullable', text),
+    optional: readInlineFlag('optional', text),
+    publicContract: readInlineFlag('publicContract', text),
+    async: readInlineFlag('async', text),
+    generator: readInlineFlag('generator', text),
+    exceptional: readInlineFlag('exceptional', text),
+    cancellable: readInlineFlag('cancellable', 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] ?? 'Conversion'; }
+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)));
+}
+function unique(values) { return [...new Set(values.filter(Boolean))]; }

package/dist/index.js

@@ -1,17 +1,5 @@
-import {
-  actionNode,
-  capabilityNode,
-  createDocument,
-  effectNode,
-  entityNode,
-  externNode,
-  latticeNode,
-  migrationNode,
-  nativeSourceNode,
-  stateNode,
-  targetNode,
-  typeNode
-} from '@shapeshift-labs/frontier-lang-kernel';
+import { actionNode, capabilityNode, createDocument, effectNode, entityNode, externNode, latticeNode, migrationNode, nativeSourceNode, stateNode, targetNode, typeNode } from '@shapeshift-labs/frontier-lang-kernel';
+import { parseConversionBlock } from './conversion.js';
 import { createParsedMetadata } from './metadata.js';
 import { parseSemanticOperationsBlock } from './operations.js';
 import { parseParadigmBlock } from './paradigm.js';
@@ -23,6 +11,7 @@ export function parseFrontierSource(source, options = {}) {
   const proofBlocks = [];
   const paradigmBlocks = [];
   const operationBlocks = [];
+  const conversionBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
   for (const block of readBlocks(source)) {
@@ -41,8 +30,9 @@ export function parseFrontierSource(source, options = {}) {
     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));
+    if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') conversionBlocks.push(parseConversionBlock(block));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -52,7 +42,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|paradigm|paradigmSemantics|operations|semanticOperations)\s+([^{}]+)\{/g;
+  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -21,11 +21,12 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
   if (operationBlocks.length) metadata.semanticOperations = mergeOperationBlocks(operationBlocks);
+  if (conversionBlocks.length) metadata.universalConversionPlan = mergeConversionBlocks(conversionBlocks);
   return Object.keys(metadata).length ? metadata : undefined;
 }
 
@@ -54,3 +55,18 @@ function mergeOperationBlocks(blocks) {
     metadata: { authoredSemanticOperationBlockIds: blocks.map((block) => block.id) }
   };
 }
+
+function mergeConversionBlocks(blocks) {
+  const plan = {
+    id: blocks.length === 1 ? blocks[0].id : 'universalConversionPlan:source',
+    targets: [...new Set(blocks.flatMap((block) => block.targets ?? []))],
+    metadata: { authoredConversionBlockIds: blocks.map((block) => block.id) }
+  };
+  for (const block of blocks) {
+    if (block.sourceLanguage && !plan.sourceLanguage) plan.sourceLanguage = block.sourceLanguage;
+    for (const [key, value] of Object.entries(block)) {
+      if (Array.isArray(value) && key !== 'targets') plan[key] = [...(plan[key] ?? []), ...value];
+    }
+  }
+  return plan;
+}

package/package.json

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