@shapeshift-labs/frontier-lang-compiler 0.2.143 → 0.2.144

package/dist/js-ts-safe-merge-enum-member-fallback.js

@@ -0,0 +1,225 @@
+import { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semantic-artifacts.js';
+import { uniqueStrings } from './js-ts-safe-merge-context.js';
+import { semanticFallbackChangedExistingDeclarations } from './js-ts-safe-merge-semantic-edit-fallback-utils.js';
+import {
+  enumDeclarationsByName,
+  sameEnumMemberText,
+  sameEnumShell
+} from './js-ts-safe-merge-enum-member-parser.js';
+
+function createEnumMemberSemanticFallbackResult(input, topLevelResult, stagedFallback) {
+  const currentSourceText = fallbackCurrentSourceText(input, stagedFallback);
+  const merge = mergeEnumMemberSources({
+    baseSourceText: input.baseSourceText,
+    workerSourceText: input.workerSourceText,
+    headSourceText: input.headSourceText,
+    currentSourceText
+  });
+  if (!merge.ok || merge.sourceText === currentSourceText) return undefined;
+  const resultBase = stagedFallback?.stagedTopLevelResult ?? topLevelResult;
+  const language = input.language ?? topLevelResult.language ?? 'typescript';
+  const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
+  const phase = stagedFallback
+    ? 'staged-top-level-enum-member-semantic-fallback'
+    : 'enum-member-semantic-fallback';
+  const artifacts = createJsTsSafeMergeSemanticArtifacts({
+    ...input,
+    id: `${String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge')}_enum_member`,
+    language,
+    sourcePath,
+    headSourceText: currentSourceText,
+    headHash: undefined,
+    currentSourceHash: undefined
+  }, {
+    ...resultBase,
+    id: `${String(input.id ?? resultBase.id ?? 'js_ts_safe_merge')}_enum_member`,
+    language,
+    sourcePath,
+    mergedSourceText: merge.sourceText,
+    outputSourceText: merge.sourceText
+  });
+  if (artifacts.status !== 'verified') return undefined;
+  const gates = semanticArtifactGates(artifacts);
+  return {
+    ...resultBase,
+    id: String(input.id ?? resultBase.id ?? topLevelResult.id),
+    status: JsTsSafeMergeStatuses.merged,
+    mergedSourceText: merge.sourceText,
+    outputSourceText: merge.sourceText,
+    conflicts: [],
+    gates,
+    admission: {
+      status: 'auto-merge-candidate',
+      action: 'apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    summary: {
+      ...resultBase.summary,
+      changedExistingDeclarations: semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback),
+      conflicts: 0,
+      gatesPassed: gates.filter((gate) => gate.status === 'passed').length,
+      semanticEditOperations: artifacts.script.summary.operations,
+      semanticEditAppliedOperations: artifacts.replay.summary.applied,
+      semanticEditReplayStatus: artifacts.replay.status,
+      enumMemberDeclarations: merge.summary.declarations,
+      enumMemberEdits: merge.summary.edits,
+      enumMemberAdditions: merge.summary.additions,
+      composedPhases: 2
+    },
+    metadata: {
+      ...resultBase.metadata,
+      composed: {
+        phase,
+        phases: stagedFallback
+          ? ['top-level-neutralization', 'top-level-ledger', 'enum-member']
+          : ['top-level-ledger', 'enum-member'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+        stagedTopLevelSummary: stagedFallback?.stagedTopLevelResult?.summary,
+        neutralization: stagedFallback?.neutralization?.summary,
+        enumMemberFallback: merge.summary
+      }
+    },
+    semanticArtifacts: artifacts
+  };
+}
+
+function fallbackCurrentSourceText(input, stagedFallback) {
+  return stagedFallback?.directReplayCurrentSourceText
+    ?? stagedFallback?.replayCurrentSourceText
+    ?? input.headSourceText;
+}
+
+function mergeEnumMemberSources(input) {
+  if (![input.baseSourceText, input.workerSourceText, input.headSourceText, input.currentSourceText].every(isString)) {
+    return blocked('missing-source-text');
+  }
+  const base = enumDeclarationsByName(input.baseSourceText);
+  const worker = enumDeclarationsByName(input.workerSourceText);
+  const head = enumDeclarationsByName(input.headSourceText);
+  const current = enumDeclarationsByName(input.currentSourceText);
+  if ([base, worker, head, current].some((source) => source.reasonCodes.length)) {
+    return blocked('enum-member-parse-blocked');
+  }
+  const edits = [];
+  const summary = { declarations: 0, edits: 0, additions: 0 };
+  for (const declaration of base.declarations) {
+    const workerDeclaration = worker.byName.get(declaration.name);
+    const headDeclaration = head.byName.get(declaration.name);
+    const currentDeclaration = current.byName.get(declaration.name);
+    if (!workerDeclaration || !headDeclaration || !currentDeclaration) continue;
+    const merged = mergeEnumDeclaration(declaration, workerDeclaration, headDeclaration, currentDeclaration);
+    if (merged.status === 'blocked') return blocked(...merged.reasonCodes);
+    if (!merged.replacement || sameEnumMemberText(merged.replacement, currentDeclaration.text)) continue;
+    edits.push({ start: currentDeclaration.start, end: currentDeclaration.end, replacement: merged.replacement });
+    summary.declarations += 1;
+    summary.edits += 1;
+    summary.additions += merged.additions;
+  }
+  if (!edits.length) return blocked('no-enum-member-merge-candidate');
+  const sourceText = edits.sort((left, right) => right.start - left.start)
+    .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), input.currentSourceText);
+  return { ok: true, sourceText, summary };
+}
+
+function mergeEnumDeclaration(base, worker, head, current) {
+  if (!sameEnumShell(base, worker) || !sameEnumShell(base, head) || !sameEnumShell(base, current)) {
+    return blockedDeclaration('enum-member-shell-changed');
+  }
+  const baseNames = base.members.map((member) => member.name);
+  if (![worker, head, current].every((declaration) => containsBaseMembersInOrder(declaration, baseNames))) {
+    return blockedDeclaration('enum-member-base-order-changed');
+  }
+  const memberMaps = [base, worker, head, current].map(membersByName);
+  if (memberMaps.some((map) => map.reasonCodes.length)) return blockedDeclaration('duplicate-enum-member-name');
+  const [baseMembers, workerMembers, headMembers, currentMembers] = memberMaps.map((map) => map.byName);
+  const mergedByName = new Map();
+  for (const name of baseNames) {
+    const merged = mergeExistingMember(name, baseMembers, workerMembers, headMembers, currentMembers);
+    if (merged.status === 'blocked') return merged;
+    mergedByName.set(name, merged.text);
+  }
+  const workerAdditions = new Map();
+  for (const member of worker.members.filter((entry) => !baseMembers.has(entry.name))) {
+    const currentMember = currentMembers.get(member.name);
+    if (currentMember && !sameEnumMemberText(currentMember.text, member.text)) {
+      return blockedDeclaration('enum-member-addition-conflict');
+    }
+    if (!currentMember) workerAdditions.set(member.name, member.text);
+  }
+  const outputMembers = [];
+  for (const member of current.members) outputMembers.push(mergedByName.get(member.name) ?? member.text);
+  for (const text of workerAdditions.values()) outputMembers.push(text);
+  const replacement = `${current.prefix}${outputMembers.join(',')}${current.tail}${current.suffix}`;
+  return {
+    status: 'merged',
+    replacement,
+    additions: workerAdditions.size
+  };
+}
+
+function mergeExistingMember(name, baseMembers, workerMembers, headMembers, currentMembers) {
+  const base = baseMembers.get(name);
+  const worker = workerMembers.get(name);
+  const head = headMembers.get(name);
+  const current = currentMembers.get(name);
+  if (!base || !worker || !head || !current) return blockedDeclaration('enum-member-removed');
+  const workerChanged = !sameEnumMemberText(base.text, worker.text);
+  const headChanged = !sameEnumMemberText(base.text, head.text);
+  if (workerChanged && headChanged && !sameEnumMemberText(worker.text, head.text)) {
+    return blockedDeclaration('enum-member-conflict');
+  }
+  if (!sameEnumMemberText(current.text, head.text) && !sameEnumMemberText(current.text, worker.text)) {
+    return blockedDeclaration('enum-member-current-diverged');
+  }
+  return { status: 'merged', text: workerChanged ? worker.text : current.text };
+}
+
+function containsBaseMembersInOrder(declaration, baseNames) {
+  let index = 0;
+  for (const member of declaration.members) {
+    if (member.name === baseNames[index]) index += 1;
+  }
+  return index === baseNames.length;
+}
+
+function membersByName(declaration) {
+  const byName = new Map();
+  const reasonCodes = [];
+  for (const member of declaration.members) {
+    if (byName.has(member.name)) reasonCodes.push('duplicate-enum-member-name');
+    byName.set(member.name, member);
+  }
+  return { byName, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function semanticArtifactGates(artifacts) {
+  return [
+    gate('semantic-edit-script', artifacts.script?.admission?.status === 'auto-merge-candidate', artifacts.script?.admission?.reasonCodes),
+    gate('semantic-edit-projection', artifacts.projection?.status === 'projected', artifacts.projection?.admission?.reasonCodes),
+    gate('semantic-edit-replay', artifacts.replay?.status === 'accepted-clean', artifacts.replay?.admission?.reasonCodes),
+    gate('semantic-edit-already-applied', artifacts.alreadyAppliedReplay?.status === 'already-applied', artifacts.alreadyAppliedReplay?.admission?.reasonCodes)
+  ];
+}
+
+function gate(id, passed, reasonCodes = []) {
+  return { id, status: passed ? 'passed' : 'blocked', reasonCodes: passed ? [] : uniqueStrings(reasonCodes) };
+}
+
+function blocked(...reasonCodes) {
+  return { ok: false, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function blockedDeclaration(...reasonCodes) {
+  return { status: 'blocked', reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function isString(value) {
+  return typeof value === 'string';
+}
+
+export { createEnumMemberSemanticFallbackResult };

package/dist/js-ts-safe-merge-enum-member-parser.js

@@ -0,0 +1,185 @@
+import { normalizeLineEndings, uniqueStrings } from './js-ts-safe-merge-context.js';
+
+function enumDeclarationsByName(sourceText) {
+  const reasonCodes = [];
+  const declarations = topLevelEnumDeclarations(sourceText)
+    .map((declaration) => parseEnumDeclaration(sourceText, declaration))
+    .filter(Boolean);
+  const byName = new Map();
+  for (const declaration of declarations) {
+    if (byName.has(declaration.name)) reasonCodes.push('duplicate-enum-declaration-name');
+    byName.set(declaration.name, declaration);
+  }
+  return { declarations, byName, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function parseEnumDeclaration(sourceText, match) {
+  const header = sourceText.slice(match.start, match.bodyStart);
+  const nameMatch = /\benum\s+([A-Za-z_$][\w$]*)\s*$/u.exec(header);
+  if (!nameMatch) return undefined;
+  const body = sourceText.slice(match.bodyStart + 1, match.bodyEnd);
+  const members = splitEnumMembers(body, match.bodyStart + 1);
+  if (!members.length || members.some((member) => !member.name)) return undefined;
+  const tailStart = members.at(-1).end;
+  return {
+    name: nameMatch[1],
+    start: match.start,
+    end: match.end,
+    text: sourceText.slice(match.start, match.end),
+    prefix: sourceText.slice(match.start, match.bodyStart + 1),
+    tail: sourceText.slice(tailStart, match.bodyEnd),
+    suffix: sourceText.slice(match.bodyEnd, match.end),
+    members
+  };
+}
+
+function topLevelEnumDeclarations(sourceText) {
+  const declarations = [];
+  let state = 'code';
+  let depth = 0;
+  for (let index = 0; index < sourceText.length; index += 1) {
+    const nextIndex = advanceState(sourceText, index, state);
+    if (nextIndex.state !== state || nextIndex.index !== index) {
+      state = nextIndex.state;
+      index = nextIndex.index;
+      continue;
+    }
+    if (state !== 'code') continue;
+    const char = sourceText[index];
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth -= 1;
+    if (depth !== 0 || !wordAt(sourceText, index, 'enum')) continue;
+    const bodyStart = sourceText.indexOf('{', index);
+    if (bodyStart === -1) continue;
+    const bodyEnd = matchingBrace(sourceText, bodyStart);
+    if (bodyEnd === -1) continue;
+    declarations.push({
+      start: enumDeclarationStart(sourceText, index),
+      bodyStart,
+      bodyEnd,
+      end: enumDeclarationEnd(sourceText, bodyEnd + 1)
+    });
+    index = bodyEnd;
+  }
+  return declarations;
+}
+
+function splitEnumMembers(body, offset) {
+  const members = [];
+  let start = 0;
+  let state = 'code';
+  let depth = 0;
+  for (let index = 0; index < body.length; index += 1) {
+    const nextIndex = advanceState(body, index, state);
+    if (nextIndex.state !== state || nextIndex.index !== index) {
+      state = nextIndex.state;
+      index = nextIndex.index;
+      continue;
+    }
+    if (state !== 'code') continue;
+    const char = body[index];
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth -= 1;
+    else if (char === ',' && depth === 0) {
+      pushEnumMember(members, body, start, index, offset);
+      start = index + 1;
+    }
+    if (depth < 0) return [];
+  }
+  if (state !== 'code' || depth !== 0) return [];
+  pushEnumMember(members, body, start, body.length, offset);
+  return members;
+}
+
+function pushEnumMember(members, body, start, end, offset) {
+  let localStart = start;
+  let localEnd = end;
+  while (localStart < localEnd && /\s/u.test(body[localStart])) localStart += 1;
+  while (localEnd > localStart && /\s/u.test(body[localEnd - 1])) localEnd -= 1;
+  if (localStart === localEnd) return;
+  const text = body.slice(start, localEnd);
+  const trimmed = body.slice(localStart, localEnd);
+  const name = enumMemberName(trimmed);
+  members.push({ name, text, start: offset + start, end: offset + localEnd });
+}
+
+function enumMemberName(text) {
+  const identifier = /^[A-Za-z_$][\w$]*/u.exec(text)?.[0];
+  if (identifier) return identifier;
+  const quoted = /^(["'])(.*?)\1/u.exec(text);
+  return quoted ? quoted[2] : undefined;
+}
+
+function matchingBrace(sourceText, bodyStart) {
+  let state = 'code';
+  let depth = 0;
+  for (let index = bodyStart; index < sourceText.length; index += 1) {
+    const nextIndex = advanceState(sourceText, index, state);
+    if (nextIndex.state !== state || nextIndex.index !== index) {
+      state = nextIndex.state;
+      index = nextIndex.index;
+      continue;
+    }
+    if (state !== 'code') continue;
+    if (sourceText[index] === '{') depth += 1;
+    else if (sourceText[index] === '}') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function enumDeclarationStart(sourceText, enumOffset) {
+  let start = sourceText.lastIndexOf('\n', enumOffset) + 1;
+  const leading = sourceText.slice(start, enumOffset);
+  if (/\b(?:export|declare|const)\s+$/u.test(leading)) return start;
+  const exportIndex = leading.search(/\bexport\b/u);
+  return exportIndex === -1 ? enumOffset : start + exportIndex;
+}
+
+function enumDeclarationEnd(sourceText, bodyCloseEnd) {
+  let end = bodyCloseEnd;
+  while (end < sourceText.length && /[ \t]/u.test(sourceText[end])) end += 1;
+  if (sourceText[end] === ';') end += 1;
+  if (sourceText[end] === '\r' && sourceText[end + 1] === '\n') return end + 2;
+  if (sourceText[end] === '\n') return end + 1;
+  return end;
+}
+
+function advanceState(sourceText, index, state) {
+  const char = sourceText[index];
+  const next = sourceText[index + 1];
+  if (state === 'line-comment') return char === '\n' ? { state: 'code', index } : { state, index };
+  if (state === 'block-comment') {
+    return char === '*' && next === '/' ? { state: 'code', index: index + 1 } : { state, index };
+  }
+  if (state !== 'code') {
+    if (char === '\\') return { state, index: index + 1 };
+    return char === state ? { state: 'code', index } : { state, index };
+  }
+  if (char === '/' && next === '/') return { state: 'line-comment', index: index + 1 };
+  if (char === '/' && next === '*') return { state: 'block-comment', index: index + 1 };
+  if (char === '"' || char === "'" || char === '`') return { state: char, index };
+  return { state, index };
+}
+
+function wordAt(sourceText, index, word) {
+  return sourceText.slice(index, index + word.length) === word
+    && !/[A-Za-z0-9_$]/u.test(sourceText[index - 1] ?? '')
+    && !/[A-Za-z0-9_$]/u.test(sourceText[index + word.length] ?? '');
+}
+
+function sameEnumMemberText(left, right) {
+  return normalizeLineEndings(String(left ?? '').trim(), '\n') === normalizeLineEndings(String(right ?? '').trim(), '\n');
+}
+
+function sameEnumShell(left, right) {
+  return sameEnumMemberText(left.prefix, right.prefix) && sameEnumMemberText(left.suffix, right.suffix);
+}
+
+export {
+  enumDeclarationsByName,
+  sameEnumMemberText,
+  sameEnumShell
+};

package/dist/js-ts-safe-merge-semantic-artifact-ledger.js

@@ -174,6 +174,7 @@ function entryName(entry) {
 
 function entrySymbolKind(entry) {
   if (entry.kind === 'import') return 'import';
+  if (entry.declarationInfo?.declarationKind === 'enum') return 'type';
   return entry.declarationInfo?.declarationKind ?? entry.kind;
 }
 

package/dist/js-ts-safe-merge-semantic-edit-fallback.js

@@ -15,7 +15,7 @@ import {
   createStagedDeclarationReplayRecord
 } from './js-ts-safe-merge-staged-declaration-replay.js';
 import { createStagedTopLevelSemanticFallback } from './js-ts-safe-merge-staged-top-level-fallback.js';
-import { createVariableDeclaratorSemanticFallbackResult } from './js-ts-safe-merge-variable-declarator-fallback.js';
+import { createSourceShapeSemanticFallbackResult } from './js-ts-safe-merge-source-shape-fallbacks.js';
 import { idFragment, uniqueStrings } from './native-import-utils.js';
 
 function semanticEditFallbackResult(input, topLevelResult) {
@@ -31,8 +31,8 @@ function semanticEditFallbackResult(input, topLevelResult) {
     artifacts = nextArtifacts.status === 'verified' ? nextArtifacts : artifacts;
   }
   if (artifacts.status !== 'verified') {
-    const variableDeclaratorResult = createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, stagedFallback);
-    if (variableDeclaratorResult) return variableDeclaratorResult;
+    const sourceShapeResult = createSourceShapeSemanticFallbackResult(input, topLevelResult, stagedFallback);
+    if (sourceShapeResult) return sourceShapeResult;
     return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
   }
   const resultBase = selectedFallback?.stagedTopLevelResult ?? topLevelResult;

package/dist/js-ts-safe-merge-source-shape-fallbacks.js

@@ -0,0 +1,9 @@
+import { createEnumMemberSemanticFallbackResult } from './js-ts-safe-merge-enum-member-fallback.js';
+import { createVariableDeclaratorSemanticFallbackResult } from './js-ts-safe-merge-variable-declarator-fallback.js';
+
+function createSourceShapeSemanticFallbackResult(input, topLevelResult, stagedFallback) {
+  return createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, stagedFallback)
+    ?? createEnumMemberSemanticFallbackResult(input, topLevelResult, stagedFallback);
+}
+
+export { createSourceShapeSemanticFallbackResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.143",
+  "version": "0.2.144",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",