@shapeshift-labs/frontier-lang-compiler 0.2.103 → 0.2.105

package/dist/js-ts-safe-merge-parse-declarations.js

@@ -0,0 +1,210 @@
+import { JsTsSafeMergeConflictCodes, identifierRegExp } from './js-ts-safe-merge-constants.js';
+
+export function classifyStatement(text, start, end) {
+  const importInfo = parseImportInfo(text);
+  if (importInfo) {
+    return {
+      kind: 'import',
+      key: importLedgerKey(importInfo),
+      text,
+      start,
+      end,
+      importInfo,
+      names: importInfo.specifiers.map((specifier) => specifier.localName).filter(Boolean)
+    };
+  }
+  const declarationInfo = parseDeclarationInfo(text);
+  if (declarationInfo) {
+    const unsupported = unsupportedDeclarationPolicy(text, declarationInfo);
+    if (unsupported) return { unsupported, text, start, end };
+    return {
+      kind: declarationInfo.kind,
+      key: `${declarationInfo.kind}:${declarationInfo.names.join('|')}`,
+      text,
+      start,
+      end,
+      declarationInfo,
+      names: declarationInfo.names
+    };
+  }
+  return undefined;
+}
+
+function parseImportInfo(text) {
+  const trimmed = text.trim();
+  const sideEffect = trimmed.match(/^import\s+(['"])([^'"]+)\1\s*;?$/s);
+  if (sideEffect) {
+    return {
+      moduleSpecifier: sideEffect[2],
+      quote: sideEffect[1],
+      typeOnly: false,
+      sideEffectOnly: true,
+      defaultLocalName: undefined,
+      namespaceLocalName: undefined,
+      specifiers: []
+    };
+  }
+
+  const match = trimmed.match(/^import\s+(type\s+)?([\s\S]+?)\s+from\s+(['"])([^'"]+)\3\s*;?$/s);
+  if (!match) return undefined;
+  const typeOnly = Boolean(match[1]);
+  const clause = match[2].trim();
+  const parsedClause = parseImportClause(clause, { typeOnly });
+  if (!parsedClause) return undefined;
+  return {
+    moduleSpecifier: match[4],
+    quote: match[3],
+    typeOnly,
+    sideEffectOnly: false,
+    ...parsedClause
+  };
+}
+
+function parseImportClause(clause, options) {
+  const namespace = clause.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+  if (namespace) {
+    return {
+      defaultLocalName: undefined,
+      namespaceLocalName: namespace[1],
+      specifiers: []
+    };
+  }
+
+  const named = clause.match(/\{([\s\S]*)\}/);
+  if (!named) {
+    if (!identifierRegExp.test(clause)) return undefined;
+    return {
+      defaultLocalName: clause,
+      namespaceLocalName: undefined,
+      specifiers: []
+    };
+  }
+
+  const beforeNamed = clause.slice(0, named.index).trim();
+  const afterNamed = clause.slice(named.index + named[0].length).trim();
+  if (afterNamed) return undefined;
+  let defaultLocalName;
+  if (beforeNamed) {
+    const defaultText = beforeNamed.replace(/,$/, '').trim();
+    if (!identifierRegExp.test(defaultText)) return undefined;
+    defaultLocalName = defaultText;
+  }
+
+  const specifiers = splitCommaList(named[1]).map((part) => parseImportSpecifier(part, options)).filter(Boolean);
+  if (splitCommaList(named[1]).filter((part) => part.trim()).length !== specifiers.length) return undefined;
+  return {
+    defaultLocalName,
+    namespaceLocalName: undefined,
+    specifiers
+  };
+}
+
+function parseImportSpecifier(raw, options) {
+  let text = String(raw ?? '').trim();
+  if (!text) return undefined;
+  let typeOnly = Boolean(options.typeOnly);
+  if (text.startsWith('type ')) {
+    typeOnly = true;
+    text = text.slice(5).trim();
+  }
+  const match = text.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+  if (!match) return undefined;
+  const importedName = match[1];
+  const localName = match[2] ?? importedName;
+  return {
+    importedName,
+    localName,
+    typeOnly,
+    canonical: importSpecifierCanonical({ importedName, localName, typeOnly })
+  };
+}
+
+function parseDeclarationInfo(text) {
+  const trimmed = text.trim();
+  const defaultFunction = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?(?:\s+([A-Za-z_$][\w$]*))?\b/);
+  if (defaultFunction) return { kind: 'declaration', names: ['default'], declarationKind: 'function', exported: true, defaultExport: true };
+  const defaultClass = trimmed.match(/^export\s+default\s+(?:abstract\s+)?class(?:\s+([A-Za-z_$][\w$]*))?\b/);
+  if (defaultClass) return { kind: 'declaration', names: ['default'], declarationKind: 'class', exported: true, defaultExport: true };
+
+  const namedExport = trimmed.match(/^export\s+(type\s+)?\{([\s\S]+)\}\s*;?$/);
+  if (namedExport) {
+    const names = splitCommaList(namedExport[2]).map((part) => parseExportSpecifierName(part)).filter(Boolean);
+    const expectedCount = splitCommaList(namedExport[2]).filter((part) => part.trim()).length;
+    if (names.length !== expectedCount || names.length === 0) return undefined;
+    return { kind: 'export', names, declarationKind: 'export-list', exported: true, typeOnly: Boolean(namedExport[1]) };
+  }
+
+  const source = trimmed
+    .replace(/^export\s+/, '')
+    .replace(/^declare\s+/, '');
+  const functionMatch = source.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)\b/);
+  if (functionMatch) return { kind: 'declaration', names: [functionMatch[1]], declarationKind: 'function', exported: trimmed.startsWith('export ') };
+  const classMatch = source.match(/^(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)\b/);
+  if (classMatch) return { kind: 'declaration', names: [classMatch[1]], declarationKind: 'class', exported: trimmed.startsWith('export ') };
+  const interfaceMatch = source.match(/^interface\s+([A-Za-z_$][\w$]*)\b/);
+  if (interfaceMatch) return { kind: 'declaration', names: [interfaceMatch[1]], declarationKind: 'interface', exported: trimmed.startsWith('export ') };
+  const typeMatch = source.match(/^type\s+([A-Za-z_$][\w$]*)\b/);
+  if (typeMatch) return { kind: 'declaration', names: [typeMatch[1]], declarationKind: 'type', exported: trimmed.startsWith('export ') };
+  const enumMatch = source.match(/^(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)\b/);
+  if (enumMatch) return { kind: 'declaration', names: [enumMatch[1]], declarationKind: 'enum', exported: trimmed.startsWith('export ') };
+  const moduleMatch = source.match(/^(?:namespace|module)\s+([A-Za-z_$][\w$.]*)\b/);
+  if (moduleMatch) return { kind: 'declaration', names: [moduleMatch[1]], declarationKind: 'module', exported: trimmed.startsWith('export ') };
+  const variableMatch = source.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\b/);
+  if (variableMatch) return { kind: 'declaration', names: [variableMatch[1]], declarationKind: 'variable', exported: trimmed.startsWith('export ') };
+  return undefined;
+}
+
+function unsupportedDeclarationPolicy(text, declarationInfo) {
+  const trimmed = text.trim();
+  if (/^\s*@/m.test(text)) {
+    return {
+      code: JsTsSafeMergeConflictCodes.unsupportedDecorator,
+      details: { reasonCode: 'unsupported-decorator-merge-anchor', declarationKind: declarationInfo.declarationKind }
+    };
+  }
+  if (declarationInfo.declarationKind === 'function' && !trimmed.includes('{') && /;\s*$/.test(trimmed)) {
+    return {
+      code: JsTsSafeMergeConflictCodes.unsupportedOverload,
+      details: { reasonCode: 'unsupported-overload-merge-anchor', names: declarationInfo.names }
+    };
+  }
+  if (hasComputedMemberKey(text)) {
+    return {
+      code: JsTsSafeMergeConflictCodes.computedKey,
+      details: { reasonCode: 'computed-key', declarationKind: declarationInfo.declarationKind, names: declarationInfo.names }
+    };
+  }
+  return undefined;
+}
+
+function hasComputedMemberKey(text) {
+  return /(?:^|[\n{,;])\s*(?:readonly\s+)?\[[^\]\n]+\]\??\s*(?::|\()/m.test(text);
+}
+
+function parseExportSpecifierName(raw) {
+  let text = String(raw ?? '').trim();
+  if (!text) return undefined;
+  if (text.startsWith('type ')) text = text.slice(5).trim();
+  const match = text.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+  if (!match) return undefined;
+  return match[2] ?? match[1];
+}
+
+function splitCommaList(raw) {
+  return String(raw ?? '').split(',');
+}
+
+function importLedgerKey(importInfo) {
+  if (importInfo.sideEffectOnly) return `import:side-effect:${importInfo.moduleSpecifier}`;
+  return [
+    'import:named',
+    importInfo.moduleSpecifier,
+    importInfo.typeOnly ? 'type' : 'value',
+    importInfo.defaultLocalName ?? '',
+    importInfo.namespaceLocalName ?? ''
+  ].join(':');
+}
+
+export function importSpecifierCanonical(specifier) {
+  return `${specifier.typeOnly ? 'type ' : ''}${specifier.importedName}${specifier.localName === specifier.importedName ? '' : ` as ${specifier.localName}`}`;
+}

package/dist/js-ts-safe-merge-parse-statements.js

@@ -0,0 +1,155 @@
+export function skipTopLevelTrivia(sourceText, offset) {
+  let index = offset;
+  while (index < sourceText.length) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (/\s/.test(char)) {
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      index = consumeLineComment(sourceText, index + 2);
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      const end = sourceText.indexOf('*/', index + 2);
+      if (end === -1) return { offset: index, error: 'unterminated-block-comment' };
+      index = end + 2;
+      continue;
+    }
+    break;
+  }
+  return { offset: index };
+}
+
+function consumeLineComment(sourceText, offset) {
+  const lineEnd = sourceText.indexOf('\n', offset);
+  return lineEnd === -1 ? sourceText.length : lineEnd + 1;
+}
+
+export function findStatementEnd(sourceText, start) {
+  const text = sourceText.slice(start);
+  const endOnBalancedBlock = statementCanEndOnBalancedBlock(text);
+  let braceDepth = 0;
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let openedBrace = false;
+  let quote;
+  let inTemplate = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escaped = false;
+
+  for (let index = start; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+
+    if (inLineComment) {
+      if (char === '\n') inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === '*' && next === '/') {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (inTemplate) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '`') {
+        inTemplate = false;
+      }
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === '`') {
+      inTemplate = true;
+      continue;
+    }
+    if (char === '(') {
+      parenDepth += 1;
+      continue;
+    }
+    if (char === ')') {
+      parenDepth -= 1;
+      if (parenDepth < 0) return { error: 'unbalanced-paren' };
+      continue;
+    }
+    if (char === '[') {
+      bracketDepth += 1;
+      continue;
+    }
+    if (char === ']') {
+      bracketDepth -= 1;
+      if (bracketDepth < 0) return { error: 'unbalanced-bracket' };
+      continue;
+    }
+    if (char === '{') {
+      braceDepth += 1;
+      openedBrace = true;
+      continue;
+    }
+    if (char === '}') {
+      braceDepth -= 1;
+      if (braceDepth < 0) return { error: 'unbalanced-brace' };
+      if (endOnBalancedBlock && openedBrace && braceDepth === 0 && parenDepth === 0 && bracketDepth === 0) {
+        return { offset: consumeOptionalSameLineSemicolon(sourceText, index + 1) };
+      }
+      continue;
+    }
+    if (char === ';' && braceDepth === 0 && parenDepth === 0 && bracketDepth === 0) {
+      return { offset: index + 1 };
+    }
+  }
+
+  if (quote || inTemplate || inBlockComment || braceDepth !== 0 || parenDepth !== 0 || bracketDepth !== 0) {
+    return { error: 'unterminated-statement' };
+  }
+  return { error: 'missing-top-level-statement-terminator' };
+}
+
+function consumeOptionalSameLineSemicolon(sourceText, offset) {
+  let index = offset;
+  while (index < sourceText.length && (sourceText[index] === ' ' || sourceText[index] === '\t')) index += 1;
+  if (sourceText[index] === ';') return index + 1;
+  return offset;
+}
+
+function statementCanEndOnBalancedBlock(text) {
+  const trimmed = text.trimStart();
+  return new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:async\\s+)?function\\*?\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:abstract\\s+)?class\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?interface\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:const\\s+)?enum\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:namespace|module)\\b`).test(trimmed)
+    || new RegExp(`^export\\s+default\\s+(?:async\\s+)?function\\*?\\b`).test(trimmed)
+    || new RegExp(`^export\\s+default\\s+(?:abstract\\s+)?class\\b`).test(trimmed);
+}

package/dist/js-ts-safe-merge-plan.js

@@ -0,0 +1,190 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict, detectLineEnding, normalizeLineEndings } from './js-ts-safe-merge-context.js';
+import { importSpecifierCanonical } from './js-ts-safe-merge-ledger.js';
+
+export function createSourceMergePlan(base, worker, head, workerPlan, headPlan, context) {
+  const edits = [];
+  let importSpecifierAdditions = 0;
+  for (const baseEntry of base.entries.filter((entry) => entry.kind === 'import')) {
+    const workerAdditions = workerPlan.importAdditions.get(baseEntry.key) ?? [];
+    const headAdditions = headPlan.importAdditions.get(baseEntry.key) ?? [];
+    if (!workerAdditions.length && !headAdditions.length) continue;
+    importSpecifierAdditions += workerAdditions.length + headAdditions.length;
+    const headEntry = head.entries.find((entry) => entry.key === baseEntry.key);
+    if (!headEntry) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
+        gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
+        side: 'head',
+        message: 'Head source is missing a base import anchor.',
+        details: { key: baseEntry.key }
+      });
+      continue;
+    }
+    edits.push({
+      kind: 'replace-import',
+      start: headEntry.start,
+      end: headEntry.end,
+      text: renderImportStatement(baseEntry.importInfo, mergedImportSpecifiers(baseEntry.importInfo.specifiers, workerAdditions, headAdditions))
+    });
+  }
+
+  const insertionGroups = variantInsertionGroups(worker, workerPlan.baseKeys, 'worker', context);
+  const headInsertionGroups = variantInsertionGroups(head, headPlan.baseKeys, 'head', context);
+  const headInsertionGroupsByAnchor = new Map(headInsertionGroups.map((group) => [insertionGroupKey(group), group]));
+  const headEntriesByKey = new Map(head.entries.map((entry) => [entry.key, entry]));
+  let topLevelDeclarationAdditions = 0;
+  for (const group of insertionGroups) {
+    const anchor = headEntriesByKey.get(group.anchorKey);
+    if (!anchor) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
+        gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
+        side: 'head',
+        message: 'Head source is missing a declaration insertion anchor.',
+        details: { anchorKey: group.anchorKey, mode: group.mode }
+      });
+      continue;
+    }
+    const headGroup = headInsertionGroupsByAnchor.get(insertionGroupKey(group));
+    const insertionSpan = declarationInsertionSpan(head.sourceText, anchor, group.mode, headGroup);
+    const entries = mergedDeclarationEntries(group.entries, headGroup?.entries ?? []);
+    edits.push({
+      kind: 'insert-declarations',
+      start: insertionSpan.start,
+      end: insertionSpan.end,
+      text: declarationInsertionText(entries, detectLineEnding(head.sourceText))
+    });
+    topLevelDeclarationAdditions += group.entries.length;
+  }
+
+  return {
+    edits,
+    importSpecifierAdditions,
+    topLevelDeclarationAdditions
+  };
+}
+
+function variantInsertionGroups(variant, baseKeys, side, context) {
+  const groups = [];
+  let index = 0;
+  while (index < variant.entries.length) {
+    const entry = variant.entries[index];
+    if (baseKeys.has(entry.key)) {
+      index += 1;
+      continue;
+    }
+    const start = index;
+    while (index < variant.entries.length && !baseKeys.has(variant.entries[index].key)) index += 1;
+    const entries = variant.entries.slice(start, index);
+    const previousBase = findPreviousBaseEntry(variant.entries, start, baseKeys);
+    const nextBase = findNextBaseEntry(variant.entries, index, baseKeys);
+    if (!previousBase && !nextBase) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.ambiguousInsertionPoint,
+        gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
+        side,
+        message: `${side} additions have no stable base declaration or import anchor.`,
+        details: { entries: entries.map((item) => item.names?.[0] ?? item.key) }
+      });
+      continue;
+    }
+    groups.push(previousBase
+      ? { mode: 'after', anchorKey: previousBase.key, entries }
+      : { mode: 'before', anchorKey: nextBase.key, entries });
+  }
+  return groups;
+}
+
+function insertionGroupKey(group) {
+  return `${group.mode}:${group.anchorKey}`;
+}
+
+function findPreviousBaseEntry(entries, startIndex, baseKeys) {
+  for (let index = startIndex - 1; index >= 0; index -= 1) {
+    if (baseKeys.has(entries[index].key)) return entries[index];
+  }
+  return undefined;
+}
+
+function findNextBaseEntry(entries, startIndex, baseKeys) {
+  for (let index = startIndex; index < entries.length; index += 1) {
+    if (baseKeys.has(entries[index].key)) return entries[index];
+  }
+  return undefined;
+}
+
+export function applySourceMergePlan(sourceText, mergePlan) {
+  return [...mergePlan.edits]
+    .sort((left, right) => right.start - left.start || right.end - left.end)
+    .reduce((current, edit) => `${current.slice(0, edit.start)}${edit.text}${current.slice(edit.end)}`, sourceText);
+}
+
+function mergedImportSpecifiers(baseSpecifiers, workerAdditions, headAdditions) {
+  const seen = new Set(baseSpecifiers.map((specifier) => specifier.canonical));
+  const additions = [];
+  for (const specifier of [...workerAdditions, ...headAdditions]) {
+    if (seen.has(specifier.canonical)) continue;
+    seen.add(specifier.canonical);
+    additions.push(specifier);
+  }
+  additions.sort((left, right) => left.canonical.localeCompare(right.canonical));
+  return [...baseSpecifiers, ...additions];
+}
+
+function renderImportStatement(importInfo, specifiers) {
+  const clause = [];
+  if (importInfo.defaultLocalName) clause.push(importInfo.defaultLocalName);
+  if (importInfo.namespaceLocalName) clause.push(`* as ${importInfo.namespaceLocalName}`);
+  if (specifiers.length) clause.push(`{ ${specifiers.map(importSpecifierCanonical).join(', ')} }`);
+  const importType = importInfo.typeOnly ? 'type ' : '';
+  return `import ${importType}${clause.join(', ')} from ${importInfo.quote}${importInfo.moduleSpecifier}${importInfo.quote};`;
+}
+
+function declarationInsertionText(entries, lineEnding) {
+  return entries
+    .map((entry) => normalizeLineEndings(entry.text.trimEnd(), lineEnding))
+    .map((text) => text.endsWith(lineEnding) ? text : `${text}${lineEnding}`)
+    .join('');
+}
+
+function mergedDeclarationEntries(workerEntries, headEntries) {
+  const entriesByKey = new Map();
+  for (const entry of [...workerEntries, ...headEntries]) {
+    const key = `${entry.kind}:${entry.key}:${entry.text.trim()}`;
+    if (!entriesByKey.has(key)) entriesByKey.set(key, entry);
+  }
+  return [...entriesByKey.values()].sort((left, right) => {
+    const keyOrder = left.key.localeCompare(right.key);
+    if (keyOrder !== 0) return keyOrder;
+    return left.text.trim().localeCompare(right.text.trim());
+  });
+}
+
+function declarationInsertionSpan(sourceText, anchor, mode, headGroup) {
+  if (!headGroup?.entries.length) {
+    const offset = mode === 'after'
+      ? offsetAfterEntryLine(sourceText, anchor)
+      : offsetBeforeEntryLine(sourceText, anchor);
+    return { start: offset, end: offset };
+  }
+  if (mode === 'after') {
+    return {
+      start: offsetAfterEntryLine(sourceText, anchor),
+      end: offsetAfterEntryLine(sourceText, headGroup.entries[headGroup.entries.length - 1])
+    };
+  }
+  return {
+    start: offsetBeforeEntryLine(sourceText, headGroup.entries[0]),
+    end: offsetBeforeEntryLine(sourceText, anchor)
+  };
+}
+
+function offsetAfterEntryLine(sourceText, entry) {
+  const lineEnd = sourceText.indexOf('\n', entry.end);
+  return lineEnd === -1 ? sourceText.length : lineEnd + 1;
+}
+
+function offsetBeforeEntryLine(sourceText, entry) {
+  return sourceText.lastIndexOf('\n', Math.max(0, entry.start - 1)) + 1;
+}