@shapeshift-labs/frontier-lang-parser 0.3.36 → 0.3.37

package/dist/conversion-constraint-record.js

@@ -133,13 +133,15 @@ export const FAMILIES = Object.freeze(Object.fromEntries(FAMILY_ROWS.flatMap(([n
   return [name, ...aliases].map((alias) => [alias, config]);
 })));
 
-export function parseConstraintRecord(name, text, role) {
+export function parseConstraintRecord(name, text, role, context = {}) {
   const kind = wordAny(text, 'kind', 'constraintKind');
   return cleanRecord({
     id: wordAny(text, 'recordId') ?? idFrom(text, `constraint_record_${name}`),
     role,
     kind,
     name: wordAny(text, 'name') ?? name,
+    sourceSpan: context.sourceSpan,
+    authoredSourceSpan: context.authoredSourceSpan,
     constraintKind: wordAny(text, 'constraintKind'),
     constraintKinds: listAny(text, 'constraint', 'constraints', 'constraintKind', 'constraintKinds') ?? (kind ? [kind] : undefined),
     ...readMapped(text, WORD_FIELDS, wordAny),

package/dist/conversion.js

@@ -3,8 +3,8 @@ import { FAMILIES, parseConstraintRecord } from './conversion-constraint-record.
 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();
+  for (const authoredLine of readAuthoredLines(block)) {
+    const line = authoredLine.text;
     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];
@@ -21,7 +21,7 @@ export function parseConversionBlock(block) {
     else if (runtimeRequirement) addRuntimeRequirement(plan, runtimeRequirement[1], runtimeRequirement[2]);
     else if (dialect) addDialectRecord(plan, dialect[1], dialect[2], false);
     else if (extern) addDialectRecord(plan, extern[1], extern[2], true);
-    else if (constraint) addConstraint(plan, constraint[1], constraint[2], constraint[3]);
+    else if (constraint) addConstraint(plan, constraint[1], constraint[2], constraint[3], authoredLine);
   }
   return cleanRecord({ ...plan, targets: unique(plan.targets) });
 }
@@ -79,15 +79,19 @@ function addDialectRecord(plan, name, text, isExtern) {
   }
 }
 
-function addConstraint(plan, family, name, text) {
+function addConstraint(plan, family, name, text, authoredLine = {}) {
   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 explicitSourceSpan = parseSpan(readInlineWord('sourceSpan', text), readInlineWord('sourcePath', text) ?? readInlineWord('path', text));
+  const sourceSpan = explicitSourceSpan ?? authoredLine.sourceSpan;
+  const record = parseConstraintRecord(name, text, role, { sourceSpan, authoredSourceSpan: authoredLine.sourceSpan });
   const entry = cleanRecord({
     id: idFrom(text, `${config.field}_${name}`),
     sourceLanguage: readInlineWord('sourceLanguage', text) ?? plan.sourceLanguage,
     target: readInlineWord('targetLanguage', text) ?? plan.targets[0],
     mode: readInlineWord('mode', text),
+    sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
     sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMaps', 'sourceMapId', 'sourceMapIds'),
     sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingId', 'sourceMapMappingIds'),
     proofObligationIds: readInlineList(text, 'proofObligation', 'proofObligations', 'proofObligationId', 'proofObligationIds', 'obligation', 'obligations'),
@@ -111,12 +115,16 @@ function resourceGraphFromRecord(record, entry) {
   const tokens = lowerTokens(record);
   const resourceId = record.resourceId ?? record.symbolId ?? `${record.id}_resource`;
   const evidenceIds = record.evidenceIds ?? entry.evidenceIds;
+  const sourceSpan = record.sourceSpan ?? entry.sourceSpan;
+  const authoredSourceSpan = record.authoredSourceSpan ?? entry.authoredSourceSpan;
   return cleanRecord({
     id: `${record.id}_resource_graph`,
     sourceLanguage: entry.sourceLanguage,
     target: entry.target,
     sourcePath: record.sourcePath,
     sourceHash: record.sourceHash,
+    sourceSpan,
+    authoredSourceSpan,
     evidenceIds,
     sourceMapIds: record.sourceMapIds ?? entry.sourceMapIds,
     sourceMapMappingIds: record.sourceMapMappingIds ?? entry.sourceMapMappingIds,
@@ -129,6 +137,8 @@ function resourceGraphFromRecord(record, entry) {
       resourceKind: record.resourceKind ?? record.kind ?? record.constraintKind,
       sourcePath: record.sourcePath,
       sourceHash: record.sourceHash,
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds,
       metadata: { factKinds: record.factKinds, constraintKinds: record.constraintKinds }
     }],
@@ -137,6 +147,8 @@ function resourceGraphFromRecord(record, entry) {
       resourceId,
       ownerId: record.ownerId ?? record.symbolId ?? `${resourceId}:owner`,
       ownerKind: record.ownerKind ?? tokenKind(tokens, /owner|single-owner/) ?? 'owner',
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined,
     loans: needsLoan(tokens, record) ? [{
@@ -144,30 +156,40 @@ function resourceGraphFromRecord(record, entry) {
       resourceId,
       mode: record.mode ?? loanMode(tokens),
       lifetimeRegionId: record.lifetimeRegionId,
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined,
     aliases: tokenMatches(tokens, /alias/) ? [{
       id: `${record.id}_alias`,
       resourceId,
       aliasKind: record.aliasKind ?? tokenKind(tokens, /alias/) ?? 'alias',
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined,
     moves: tokenMatches(tokens, /move|transfer/) ? [{
       id: `${record.id}_move`,
       resourceId,
       moveKind: record.moveKind ?? tokenKind(tokens, /move|transfer/) ?? 'move',
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined,
     drops: tokenMatches(tokens, /drop/) ? [{
       id: `${record.id}_drop`,
       resourceId,
       dropKind: record.dropKind ?? tokenKind(tokens, /drop/) ?? 'drop',
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined,
     lifetimeRegions: record.lifetimeKind || record.lifetimeRegionId || tokenMatches(tokens, /lifetime/) ? [{
       id: record.lifetimeRegionId ?? `${record.id}_lifetime`,
       resourceId,
       lifetimeKind: record.lifetimeKind ?? tokenKind(tokens, /lifetime/) ?? record.regionKind,
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined,
     borrowScopes: needsLoan(tokens, record) || record.scopeKind ? [{
@@ -176,17 +198,42 @@ function resourceGraphFromRecord(record, entry) {
       scopeKind: record.scopeKind ?? record.kind,
       lifetimeRegionId: record.lifetimeRegionId,
       constraintKinds: record.constraintKinds,
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined,
     unsafeBoundaries: tokenMatches(tokens, /unsafe|raw/) ? [{
       id: `${record.id}_unsafe`,
       resourceId,
       kind: tokenKind(tokens, /unsafe|raw/) ?? 'unsafe-boundary',
+      sourceSpan,
+      authoredSourceSpan,
       evidenceIds
     }] : undefined
   });
 }
 
+function readAuthoredLines(block) {
+  const lines = block.body.split('\n');
+  const records = [];
+  let lineStart = block.syntax?.bodyStartOffset ?? 0;
+  for (const rawLine of lines) {
+    const rawEnd = lineStart + rawLine.length;
+    const leading = /^\s*/.exec(rawLine)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(rawLine)?.[0].length ?? 0;
+    const startOffset = lineStart + leading;
+    const endOffset = Math.max(startOffset, rawEnd - trailing);
+    records.push({
+      text: rawLine.trim(),
+      startOffset,
+      endOffset,
+      sourceSpan: typeof block.sourceSpan === 'function' ? block.sourceSpan(startOffset, endOffset) : undefined
+    });
+    lineStart = rawEnd + 1;
+  }
+  return records;
+}
+
 function lowerTokens(record) {
   return unique([record.kind, record.constraintKind, record.scopeKind, record.resourceKind, record.ownerKind, record.mode, record.aliasKind, record.moveKind, record.dropKind, record.lifetimeKind, record.regionKind, record.flowKind, record.controlFlowKind, ...(record.constraintKinds ?? []), ...(record.factKinds ?? [])].filter(Boolean).map((value) => String(value).toLowerCase()));
 }
@@ -213,6 +260,18 @@ function readInlineList(text, ...labels) {
   }
   return undefined;
 }
+function parseSpan(value, fallbackPath) {
+  if (!value) return undefined;
+  const match = /^(.+):(\d+):(\d+)-(\d+):(\d+)$/.exec(value);
+  if (!match) return undefined;
+  return cleanRecord({
+    path: match[1] || fallbackPath,
+    startLine: Number(match[2]),
+    startColumn: Number(match[3]),
+    endLine: Number(match[4]),
+    endColumn: Number(match[5])
+  });
+}
 function cleanRecord(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
 }

package/dist/index.d.ts

@@ -1,10 +1,43 @@
 import type { FrontierLangDocument } from '@shapeshift-labs/frontier-lang-kernel';
-export interface ParseFrontierOptions { readonly id?: string; readonly name?: string; }
+export interface ParseFrontierOptions { readonly id?: string; readonly name?: string; readonly sourcePath?: string; }
 export declare const FrontierSourceBlockKinds: readonly string[];
+export interface FrontierSourcePosition {
+  readonly line: number;
+  readonly column: number;
+  readonly offset: number;
+}
+export interface FrontierSourceSpan {
+  readonly sourceId?: string;
+  readonly path?: string;
+  readonly blockId?: string;
+  readonly blockKind?: string;
+  readonly startOffset: number;
+  readonly endOffset: number;
+  readonly start: FrontierSourcePosition;
+  readonly end: FrontierSourcePosition;
+}
 export interface FrontierSourceSyntaxDiagnostic {
   readonly reason: 'unterminated-block' | 'unmatched-close-brace';
   readonly message: string;
-  readonly location: { readonly line: number; readonly column: number; readonly offset: number };
+  readonly location: FrontierSourcePosition;
+}
+export interface FrontierSourceChildSyntaxRecord {
+  readonly kind: 'conversionConstraint';
+  readonly name: string;
+  readonly id?: string;
+  readonly family?: string;
+  readonly role?: string;
+  readonly header: string;
+  readonly startOffset: number;
+  readonly endOffset: number;
+  readonly location: FrontierSourcePosition;
+  readonly parentKind?: string;
+  readonly parentId?: string;
+  readonly parentName?: string;
+  readonly moduleId?: string;
+  readonly moduleName?: string;
+  readonly sourceSpan?: FrontierSourceSpan;
+  readonly recognized: boolean;
 }
 export interface FrontierSourceBlockSyntaxRecord {
   readonly kind: string;
@@ -15,12 +48,13 @@ export interface FrontierSourceBlockSyntaxRecord {
   readonly endOffset: number;
   readonly bodyStartOffset: number;
   readonly bodyEndOffset: number;
-  readonly location: { readonly line: number; readonly column: number; readonly offset: number };
+  readonly location: FrontierSourcePosition;
   readonly moduleId?: string;
   readonly moduleName?: string;
   readonly recognized: boolean;
   readonly malformed?: boolean;
   readonly diagnostics?: readonly FrontierSourceSyntaxDiagnostic[];
+  readonly children?: readonly FrontierSourceChildSyntaxRecord[];
 }
 export interface FrontierUnknownSourceBlockSyntaxRecord extends FrontierSourceBlockSyntaxRecord {
   readonly recognized: false;
@@ -39,8 +73,11 @@ export interface FrontierSourceSyntaxReport {
     readonly recognizedBlockCount: number;
     readonly unknownBlockCount: number;
     readonly malformedBlockCount: number;
+    readonly childCount: number;
+    readonly recognizedChildCount: number;
     readonly diagnosticCount: number;
     readonly recognizedKinds: readonly string[];
+    readonly recognizedChildKinds: readonly string[];
     readonly unknownKinds: readonly string[];
     readonly failClosed: boolean;
     readonly unsupportedSyntax: boolean;

package/dist/index.js

@@ -72,7 +72,7 @@ export function parseFrontierSource(source, options = {}) {
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
-export function parseFrontierFile(name, source) { return parseFrontierSource(source, { name: name.replace(/\.frontier$/, '') }); }
+export function parseFrontierFile(name, source) { return parseFrontierSource(source, { name: name.replace(/\.frontier$/, ''), sourcePath: name }); }
 
 function readName(source) { return /module\s+([A-Za-z_$][\w$]*)/.exec(source)?.[1]; }
 function readId(source) { return /module\s+[A-Za-z_$][\w$]*\s+@id\(\s*["']([^"']+)["']\s*\)/.exec(source)?.[1]; }

package/dist/source-block-kinds.js

@@ -0,0 +1,44 @@
+export const FrontierSourceBlockKinds = Object.freeze([
+  'entity',
+  'state',
+  'action',
+  'view',
+  'migration',
+  'capability',
+  'effect',
+  'type',
+  'extern',
+  'lattice',
+  'nativeSource',
+  'target',
+  'proof',
+  'paradigm',
+  'paradigmSemantics',
+  'operations',
+  'semanticOperations',
+  'conversion',
+  'universalConversionPlan',
+  'constraintSpace',
+  'possibilitySpace',
+  'decisionGraph',
+  'admissionGraph',
+  'dialectRegistry',
+  'universalDialectRegistry',
+  'interlingua',
+  'universalInterlingua',
+  'resourceGraph',
+  'semanticResourceGraph',
+  'packageManifest',
+  'packageGraph',
+  'packageSurface',
+  'canvasSurface',
+  'canvasGraph',
+  'applicationSurface',
+  'appHost',
+  'plugin',
+  'pluginSurface',
+  'pluginContract',
+  'runtimeCapabilities',
+  'runtimeCapabilityMatrix',
+  'runtimeHosts'
+]);

package/dist/source-syntax-children.js

@@ -0,0 +1,77 @@
+export function readSourceSyntaxChildren(source, block, options = {}) {
+  if (block.malformed) return [];
+  if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') {
+    return readConversionSyntaxChildren(source, block, options);
+  }
+  return [];
+}
+
+function readConversionSyntaxChildren(source, block, options) {
+  const children = [];
+  for (const line of readBodyLines(source, block)) {
+    if (!line.text || line.text.startsWith('#')) continue;
+    const constraint = /^constraint\s+([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line.text);
+    if (!constraint) continue;
+    const [, family, name, rest] = constraint;
+    children.push(cleanRecord({
+      kind: 'conversionConstraint',
+      name,
+      id: idFrom(rest, `conversion_constraint_${family}_${name}`),
+      family,
+      role: readInlineWord('role', rest) ?? 'source',
+      header: line.text,
+      startOffset: line.startOffset,
+      endOffset: line.endOffset,
+      location: sourcePosition(source, line.startOffset),
+      parentKind: block.kind,
+      parentId: block.id,
+      parentName: block.name,
+      moduleId: block.moduleId,
+      moduleName: block.moduleName,
+      sourceSpan: sourceSpan(source, block, line.startOffset, line.endOffset, options),
+      recognized: true
+    }));
+  }
+  return children;
+}
+
+function readBodyLines(source, block) {
+  const body = source.slice(block.bodyStartOffset, block.bodyEndOffset);
+  const lines = body.split('\n');
+  const records = [];
+  let lineStart = block.bodyStartOffset;
+  for (const rawLine of lines) {
+    const rawEnd = lineStart + rawLine.length;
+    const leading = /^\s*/.exec(rawLine)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(rawLine)?.[0].length ?? 0;
+    const startOffset = lineStart + leading;
+    const endOffset = Math.max(startOffset, rawEnd - trailing);
+    records.push({ text: rawLine.trim(), startOffset, endOffset });
+    lineStart = rawEnd + 1;
+  }
+  return records;
+}
+
+function sourcePosition(source, offset) {
+  const lines = source.slice(0, offset).split('\n');
+  return { line: lines.length, column: lines[lines.length - 1].length + 1, offset };
+}
+
+function sourceSpan(source, block, startOffset, endOffset, options = {}) {
+  return cleanRecord({
+    sourceId: options.documentId,
+    path: options.sourcePath,
+    blockId: block.id,
+    blockKind: block.kind,
+    startOffset,
+    endOffset,
+    start: sourcePosition(source, startOffset),
+    end: sourcePosition(source, endOffset)
+  });
+}
+
+function idFrom(header, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1] ?? fallback; }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/source-syntax-report.js

@@ -1,47 +1,7 @@
-export const FrontierSourceBlockKinds = Object.freeze([
-  'entity',
-  'state',
-  'action',
-  'view',
-  'migration',
-  'capability',
-  'effect',
-  'type',
-  'extern',
-  'lattice',
-  'nativeSource',
-  'target',
-  'proof',
-  'paradigm',
-  'paradigmSemantics',
-  'operations',
-  'semanticOperations',
-  'conversion',
-  'universalConversionPlan',
-  'constraintSpace',
-  'possibilitySpace',
-  'decisionGraph',
-  'admissionGraph',
-  'dialectRegistry',
-  'universalDialectRegistry',
-  'interlingua',
-  'universalInterlingua',
-  'resourceGraph',
-  'semanticResourceGraph',
-  'packageManifest',
-  'packageGraph',
-  'packageSurface',
-  'canvasSurface',
-  'canvasGraph',
-  'applicationSurface',
-  'appHost',
-  'plugin',
-  'pluginSurface',
-  'pluginContract',
-  'runtimeCapabilities',
-  'runtimeCapabilityMatrix',
-  'runtimeHosts'
-]);
+import { readSourceSyntaxChildren } from './source-syntax-children.js';
+import { FrontierSourceBlockKinds } from './source-block-kinds.js';
+
+export { FrontierSourceBlockKinds };
 
 const FrontierSourceBlockKindSet = new Set(FrontierSourceBlockKinds);
 
@@ -51,13 +11,18 @@ export function inspectFrontierSourceSyntax(source, options = {}) {
   const structure = scanFrontierStructure(source);
   const blocks = readCandidateDeclarationBlocks(source, structure).map((block) => ({
     ...block,
-    recognized: FrontierSourceBlockKindSet.has(block.kind)
+    recognized: FrontierSourceBlockKindSet.has(block.kind),
+    children: readSourceSyntaxChildren(source, block, { ...options, documentId })
   }));
+  for (const block of blocks) {
+    if (!block.children.length) delete block.children;
+  }
   const recognizedBlocks = blocks.filter((block) => block.recognized);
   const unknownBlocks = blocks.filter((block) => !block.recognized).map((block) => ({
     ...block,
     reason: 'unsupported-top-level-block'
   }));
+  const childRecords = blocks.flatMap((block) => block.children ?? []);
   const malformedBlockOpenOffsets = new Set(blocks.filter((block) => block.malformed).map((block) => block.bodyStartOffset - 1));
   const diagnostics = [
     ...blocks.flatMap((block) => block.diagnostics ?? []),
@@ -87,8 +52,11 @@ export function inspectFrontierSourceSyntax(source, options = {}) {
       recognizedBlockCount: recognizedBlocks.length,
       unknownBlockCount: unknownBlocks.length,
       malformedBlockCount: malformedBlocks.length,
+      childCount: childRecords.length,
+      recognizedChildCount: childRecords.filter((child) => child.recognized).length,
       diagnosticCount: diagnostics.length,
       recognizedKinds: unique(recognizedBlocks.map((block) => block.kind)),
+      recognizedChildKinds: unique(childRecords.filter((child) => child.recognized).map((child) => child.kind)),
       unknownKinds: unique(unknownBlocks.map((block) => block.kind)),
       failClosed,
       unsupportedSyntax: unknownBlocks.length > 0
@@ -108,7 +76,8 @@ export function readFrontierSourceBlocks(source, options = {}) {
     kind: block.kind,
     header: block.header,
     body: source.slice(block.bodyStartOffset, block.bodyEndOffset),
-    syntax: block
+    syntax: block,
+    sourceSpan: (startOffset, endOffset) => sourceSpan(source, block, startOffset, endOffset, { ...options, documentId: report.documentId })
   }));
 }
 
@@ -310,9 +279,25 @@ function sourcePosition(source, offset) {
   return { line: lines.length, column: lines[lines.length - 1].length + 1, offset };
 }
 
+function sourceSpan(source, block, startOffset, endOffset, options = {}) {
+  return cleanRecord({
+    sourceId: options.documentId,
+    path: options.sourcePath,
+    blockId: block.id,
+    blockKind: block.kind,
+    startOffset,
+    endOffset,
+    start: sourcePosition(source, startOffset),
+    end: sourcePosition(source, endOffset)
+  });
+}
+
 function readName(source) { return /module\s+([A-Za-z_$][\w$]*)/.exec(source)?.[1]; }
 function readId(source) { return /module\s+[A-Za-z_$][\w$]*\s+@id\(\s*["']([^"']+)["']\s*\)/.exec(source)?.[1]; }
-function idFrom(header) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1]; }
+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 unique(values) { return [...new Set(values.filter(Boolean))]; }
 function escapeRegExp(value) { return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/package.json

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