@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/dist/internal/index-impl/semanticEditCallsiteArgumentMerge.js

@@ -0,0 +1,319 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { sourceTextForSpan } from './sourceTextForSpan.js';
+
+export function callsiteArgumentAppendMergeClassification(input) {
+  if (input.region?.regionKind !== 'call') return undefined;
+  if (!input.baseSymbol || !input.workerSymbol || !input.headSymbol) return undefined;
+  const baseText = symbolSourceText(input.context.base, input.baseSymbol, input.region);
+  const workerText = symbolSourceText(input.context.worker, input.workerSymbol, input.region);
+  const headText = symbolSourceText(input.context.head, input.headSymbol, input.region);
+  const parsed = [baseText, workerText, headText].map(parseSimpleCallsite);
+  if (parsed.some((entry) => !entry.ok)) return undefined;
+  const [base, worker, head] = parsed.map((entry) => entry.value);
+  if (base.callee !== worker.callee || base.callee !== head.callee) return undefined;
+  if (!hasBaseArgumentPrefix(worker.args, base.args) || !hasBaseArgumentPrefix(head.args, base.args)) return undefined;
+  const workerTail = worker.args.slice(base.args.length);
+  const headTail = head.args.slice(base.args.length);
+  if (!workerTail.length || !headTail.length) return undefined;
+  if (!callsiteTargetHasRestParameter(input, base.callee)) return undefined;
+  if (![...workerTail, ...headTail].every(isPureAppendArgument)) return undefined;
+  if (duplicateArgumentHashes(workerTail, headTail).length) return undefined;
+
+  const sourceReplacementText = `${base.callee}(${[...base.args, ...workerTail, ...headTail].join(', ')})`;
+  return {
+    sourceBackprojection: {
+      mode: 'same-language-callsite-argument-append',
+      sourceEditSpan: input.headSymbol.sourceSpan,
+      sourceEditTextHash: hashSemanticValue(headText),
+      sourceReplacementText,
+      sourceReplacementTextHash: hashSemanticValue(sourceReplacementText),
+      lineEndingStable: true,
+      callsite: {
+        callee: base.callee,
+        baseArgumentCount: base.args.length,
+        workerAppendedArgumentCount: workerTail.length,
+        headAppendedArgumentCount: headTail.length,
+        mergedArgumentCount: base.args.length + workerTail.length + headTail.length
+      }
+    },
+    reasonCodes: uniqueStrings([
+      'callsite-argument-append-rest-callee-signature-evidence',
+      'callsite-argument-append-pure-argument-effect-evidence',
+      'callsite-argument-append-order-evidence'
+    ]),
+    evidenceIds: [`evidence_${idFragment(input.anchorKey ?? base.callee)}_callsite_argument_append`]
+  };
+}
+
+function parseSimpleCallsite(text) {
+  const source = String(text ?? '').trim().replace(/;$/, '');
+  const open = source.indexOf('(');
+  if (open <= 0 || !source.endsWith(')')) return { ok: false };
+  const callee = source.slice(0, open).trim();
+  if (!/^[A-Za-z_$][\w$]*$/.test(callee)) return { ok: false };
+  const args = splitTopLevelComma(source.slice(open + 1, -1));
+  if (!args.ok) return { ok: false };
+  return { ok: true, value: { callee, args: args.items } };
+}
+
+function splitTopLevelComma(text) {
+  const items = [];
+  let start = 0;
+  let depth = 0;
+  let quote;
+  let comment;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (comment === 'line') {
+      if (char === '\n' || char === '\r') comment = undefined;
+      continue;
+    }
+    if (comment === 'block') {
+      if (char === '*' && next === '/') {
+        index += 1;
+        comment = undefined;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      index += 1;
+      comment = 'line';
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      index += 1;
+      comment = 'block';
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth -= 1;
+    else if (char === ',' && depth === 0) {
+      items.push(text.slice(start, index).trim());
+      start = index + 1;
+    }
+    if (depth < 0) return { ok: false };
+  }
+  if (quote || comment || depth !== 0) return { ok: false };
+  const tail = text.slice(start).trim();
+  if (tail) items.push(tail);
+  return { ok: true, items };
+}
+
+function hasBaseArgumentPrefix(args, baseArgs) {
+  if (args.length < baseArgs.length) return false;
+  return baseArgs.every((arg, index) => args[index] === arg);
+}
+
+function callsiteTargetHasRestParameter(input, callee) {
+  const symbolName = input.region?.symbolName ?? input.baseSymbol?.name ?? '';
+  const targetName = symbolName.includes('->') ? symbolName.split('->').pop() : callee;
+  if (!targetName || targetName !== callee) return false;
+  const sourceText = nativeImportSourceText(input.context.base);
+  return topLevelFunctionDeclarationHasRestParameter(String(sourceText ?? ''), targetName);
+}
+
+function isPureAppendArgument(argument) {
+  const text = String(argument ?? '').trim();
+  if (!text) return false;
+  if (/^(true|false|null|undefined|\d+(?:\.\d+)?|['"][^'"]*['"])$/.test(text)) return true;
+  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(text)) return true;
+  if (text.startsWith('{') && text.endsWith('}')) {
+    if (text.includes('`')) return false;
+    const codeText = maskNonCodeCharacters(text);
+    return !/[()=]|\.\.\.|=>|\b(await|new|yield|delete|throw|function|class)\b/.test(codeText);
+  }
+  return false;
+}
+
+function duplicateArgumentHashes(left, right) { const rightHashes = new Set(right.map(argumentIdentityHash)); return left.map(argumentIdentityHash).filter((hash) => rightHashes.has(hash)); }
+
+function argumentIdentityHash(argument) { return hashSemanticValue(canonicalArgumentText(argument)); }
+
+function canonicalArgumentText(argument) {
+  const source = String(argument ?? '').trim();
+  let result = '';
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (quote) {
+      result += char;
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      index += 1;
+      while (index + 1 < source.length && source[index + 1] !== '\n' && source[index + 1] !== '\r') index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      index += 1;
+      while (index + 1 < source.length && !(source[index] === '*' && source[index + 1] === '/')) index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      result += char;
+      continue;
+    }
+    if (/\s/.test(char)) continue;
+    result += char;
+  }
+  return result;
+}
+
+function topLevelFunctionDeclarationHasRestParameter(sourceText, targetName) {
+  const codeText = maskNonCodeCharacters(sourceText);
+  const pattern = new RegExp(`\\bfunction\\s*\\*?\\s*(${identifierPatternSource()})\\s*\\(`, 'g');
+  const matches = [];
+  for (let match = pattern.exec(codeText); match; match = pattern.exec(codeText)) {
+    if (match[1] !== targetName) continue;
+    if (braceDepthAt(codeText, match.index) !== 0) continue;
+    if (!hasDeclarationPrefix(codeText, match.index)) continue;
+    const open = codeText.indexOf('(', match.index + match[0].indexOf('('));
+    const close = matchingParen(codeText, open);
+    if (!Number.isFinite(close)) return false;
+    matches.push(/(?:^|,)\s*\.\.\.\s*[A-Za-z_$]/.test(codeText.slice(open + 1, close)));
+  }
+  return matches.length === 1 && matches[0] === true;
+}
+
+function maskNonCodeCharacters(value) {
+  const source = String(value ?? '');
+  let result = '';
+  let state = 'code';
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (state === 'line-comment') {
+      result += maskedChar(char);
+      if (char === '\n' || char === '\r') state = 'code';
+      continue;
+    }
+    if (state === 'block-comment') {
+      result += maskedChar(char);
+      if (char === '*' && next === '/') {
+        result += ' ';
+        index += 1;
+        state = 'code';
+      }
+      continue;
+    }
+    if (state === 'single' || state === 'double' || state === 'template') {
+      result += maskedChar(char);
+      if (char === '\\') {
+        if (index + 1 < source.length) {
+          result += maskedChar(source[index + 1]);
+          index += 1;
+        }
+        continue;
+      }
+      if ((state === 'single' && char === "'") || (state === 'double' && char === '"') || (state === 'template' && char === '`')) {
+        state = 'code';
+      }
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      result += '  ';
+      index += 1;
+      state = 'line-comment';
+    } else if (char === '/' && next === '*') {
+      result += '  ';
+      index += 1;
+      state = 'block-comment';
+    } else if (char === "'") {
+      result += ' ';
+      state = 'single';
+    } else if (char === '"') {
+      result += ' ';
+      state = 'double';
+    } else if (char === '`') {
+      result += ' ';
+      state = 'template';
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+
+function maskedChar(char) { return char === '\n' || char === '\r' ? char : ' '; }
+
+function braceDepthAt(codeText, endIndex) {
+  let depth = 0;
+  for (let index = 0; index < endIndex; index += 1) {
+    if (codeText[index] === '{') depth += 1;
+    else if (codeText[index] === '}') depth = Math.max(0, depth - 1);
+  }
+  return depth;
+}
+
+function hasDeclarationPrefix(codeText, functionIndex) {
+  const allowedModifiers = new Set(['export', 'default', 'async', 'declare']);
+  let index = functionIndex;
+  const seen = new Set();
+  for (;;) {
+    index = skipWhitespaceBackward(codeText, index);
+    const word = wordBefore(codeText, index);
+    if (!word || !allowedModifiers.has(word.value)) break;
+    if (seen.has(word.value)) return false;
+    seen.add(word.value);
+    index = word.start;
+  }
+  index = skipWhitespaceBackward(codeText, index);
+  if (index === 0) return true;
+  const previous = codeText[index - 1];
+  return previous === ';' || previous === '{' || previous === '}';
+}
+
+function skipWhitespaceBackward(text, endIndex) {
+  let index = endIndex;
+  while (index > 0 && /\s/.test(text[index - 1])) index -= 1;
+  return index;
+}
+
+function wordBefore(text, endIndex) {
+  let index = endIndex;
+  while (index > 0 && /[A-Za-z0-9_$]/.test(text[index - 1])) index -= 1;
+  if (index === endIndex) return undefined;
+  const value = text.slice(index, endIndex);
+  if (!/^[A-Za-z_$][\w$]*$/.test(value)) return undefined;
+  return { value, start: index };
+}
+
+function matchingParen(codeText, open) {
+  if (open < 0 || codeText[open] !== '(') return undefined;
+  let depth = 0;
+  for (let index = open; index < codeText.length; index += 1) {
+    if (codeText[index] === '(') depth += 1;
+    else if (codeText[index] === ')') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return undefined;
+}
+
+function identifierPatternSource() { return '[A-Za-z_$][\\w$]*'; }
+
+function symbolSourceText(imported, symbol, region) {
+  const span = symbol?.sourceSpan ?? region?.metadata?.changedRegionProjection?.before?.sourceSpan ?? region?.sourceSpan;
+  return sourceTextForSpan(nativeImportSourceText(imported), span);
+}

package/dist/internal/index-impl/semanticEditExplicitSourceReplacement.js

@@ -1,9 +1,14 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { spanOffsets } from './semanticEditSourceRanges.js';
 
+const explicitSourceReplacementModes = new Set([
+  'cross-language-explicit-source-replacement',
+  'same-language-callsite-argument-append'
+]);
+
 export function explicitSourceReplacementEditForOperation(operation, identity, headSourceText, order) {
   const backprojection = operation.metadata?.sourceBackprojection;
-  if (backprojection?.mode !== 'cross-language-explicit-source-replacement') return undefined;
+  if (!explicitSourceReplacementModes.has(backprojection?.mode)) return undefined;
   const replacement = backprojection.sourceReplacementText;
   const range = spanOffsets(headSourceText, backprojection.sourceEditSpan ?? operation.spans?.head ?? operation.spans?.base);
   const anchorRange = spanOffsets(headSourceText, operation.anchor?.sourceSpan);
@@ -27,7 +32,7 @@ export function explicitSourceReplacementEditForOperation(operation, identity, h
       order,
       ...identity,
       editKind: 'replace',
-      sourceRangeKind: 'cross-language-explicit-source-replacement',
+      sourceRangeKind: backprojection.mode,
       start: range.start,
       end: range.end,
       headAnchorStart: anchorRange?.start,

package/dist/internal/index-impl/semanticEditProjectionRecord.js

@@ -29,12 +29,20 @@ export function projectionEditRecord(edit) {
     ...identity,
     ...sourceIdentity,
     operationContentHash: edit.operationContentHash,
+    structuralEditId: edit.structuralEditId,
+    structuralEditHash: edit.structuralEditHash,
+    structuralKind: edit.structuralKind,
+    structuralActions: edit.structuralActions,
     editContentHash: hashSemanticValue(compactRecord({
       semanticIdentityHash: identity.semanticIdentityHash,
       sourceIdentityHash: identity.sourceIdentityHash,
       sourceIdentityStatus: sourceIdentity.sourceIdentityStatus,
       sourceIdentityAnchorKey: sourceIdentity.sourceIdentityAnchorKey,
       targetIdentityAnchorKey: sourceIdentity.targetIdentityAnchorKey,
+      structuralEditId: edit.structuralEditId,
+      structuralEditHash: edit.structuralEditHash,
+      structuralKind: edit.structuralKind,
+      structuralActions: edit.structuralActions,
       sourceRangeKind: edit.sourceRangeKind,
       deletedTextHash,
       replacementTextHash,

package/dist/internal/index-impl/semanticEditReplayDiagnostics.js

@@ -23,13 +23,14 @@ export function replayEditDiagnostics(edit, status, range, reasonCodes, sourceTe
 export function replayEditsWithOverlapDiagnostics(edits) {
   const overlapDiagnostics = new Map();
   const ordered = edits
-    .filter((edit) => edit.status === 'applied' && hasNumericReplayRange(edit))
+    .filter((edit) => replayOverlapParticipant(edit) && hasNumericReplayRange(edit))
     .sort((left, right) => left.start - right.start || left.end - right.end || (left.editOrder ?? 0) - (right.editOrder ?? 0));
   for (let leftIndex = 0; leftIndex < ordered.length; leftIndex += 1) {
     for (let rightIndex = leftIndex + 1; rightIndex < ordered.length; rightIndex += 1) {
       const left = ordered[leftIndex];
       const right = ordered[rightIndex];
       if (!rangesOverlap(left, right)) continue;
+      if (left.status !== 'applied' && right.status !== 'applied') continue;
       const operationIds = [left.operationId, right.operationId].filter(Boolean);
       const fallbackId = `${left.editOrder ?? leftIndex}:${right.editOrder ?? rightIndex}`;
       const code = `replay-edit-overlap:${operationIds.join(':') || fallbackId}`;
@@ -79,7 +80,7 @@ function appendOverlapDiagnostic(overlapDiagnostics, edit, code, operationIds) {
 function appendReplayEditDiagnostic(edit, diagnostic) {
   return compactRecord({
     ...edit,
-    status: edit.status === 'applied' ? 'conflict' : edit.status,
+    status: replayOverlapParticipant(edit) ? 'conflict' : edit.status,
     reasonCodes: reasonList([...(edit.reasonCodes ?? []), diagnostic.code]),
     diagnostics: uniqueDiagnostics([...(edit.diagnostics ?? []), diagnostic])
   });
@@ -202,5 +203,9 @@ function hasNumericReplayRange(edit) {
   return typeof edit.start === 'number' && typeof edit.end === 'number';
 }
 
+function replayOverlapParticipant(edit) {
+  return edit.status === 'applied' || edit.status === 'already-applied';
+}
+
 function reasonList(values) { return uniqueStrings((values ?? []).filter(Boolean)); }
 function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

package/dist/internal/index-impl/semanticEditReplayOutputBinding.js

@@ -0,0 +1,61 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+function replayOutputBinding(input, outputSourceText, outputHash, options = {}) {
+  const expectedOutputSourceText = firstString(input.expectedOutputSourceText, input.outputSourceText);
+  const expectedOutputHash = firstString(
+    input.expectedOutputHash,
+    input.outputHash,
+    typeof expectedOutputSourceText === 'string' ? hashSemanticValue(expectedOutputSourceText) : undefined
+  );
+  if (typeof expectedOutputSourceText !== 'string' && typeof expectedOutputHash !== 'string') {
+    return { status: undefined, reasonCodes: [] };
+  }
+  if (options.replayStatus === 'stale' && typeof outputSourceText !== 'string' && typeof outputHash !== 'string') {
+    return compactRecord({
+      status: 'skipped',
+      reasonCodes: [],
+      expectedOutputHash,
+      replayedOutputHash: outputHash,
+      skippedReason: 'stale-current-source-requires-rerun'
+    });
+  }
+  const reasonCodes = [];
+  if (typeof expectedOutputSourceText === 'string') {
+    if (typeof outputSourceText !== 'string') reasonCodes.push('semantic-edit-replay-output-source-missing');
+    else if (outputSourceText !== expectedOutputSourceText) reasonCodes.push('semantic-edit-replay-output-source-mismatch');
+  }
+  if (typeof expectedOutputHash === 'string') {
+    if (typeof outputHash !== 'string') reasonCodes.push('semantic-edit-replay-output-hash-missing');
+    else if (outputHash !== expectedOutputHash) reasonCodes.push('semantic-edit-replay-output-hash-mismatch');
+  }
+  return compactRecord({
+    status: reasonCodes.length ? 'failed' : 'bound',
+    reasonCodes,
+    expectedOutputHash,
+    replayedOutputHash: outputHash
+  });
+}
+
+function replayOutputSource(status, sourceText, edits) {
+  if (typeof sourceText !== 'string') return undefined;
+  if (status === 'already-applied') return sourceText;
+  if (status !== 'accepted-clean') return undefined;
+  return edits.filter((edit) => edit.status === 'applied')
+    .sort(replaySourceEditSort)
+    .reduce((text, edit) => text.slice(0, edit.start) + editReplacement(edit, edits) + text.slice(edit.end), sourceText);
+}
+
+function replaySourceEditSort(left, right) {
+  return right.start - left.start || right.end - left.end || (right.editOrder ?? 0) - (left.editOrder ?? 0);
+}
+
+function editReplacement(edit, edits) {
+  return edits.find((candidate) => candidate.operationId === edit.operationId)?.replacementText ?? '';
+}
+
+function firstString(...values) { return values.find((value) => typeof value === 'string'); }
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}
+
+export { replayOutputBinding, replayOutputSource };

package/dist/internal/index-impl/semanticEditReplayRerunRoute.js

@@ -0,0 +1,27 @@
+function replayRerunRoute(status, reasonCodes, input, currentHash) {
+  const staleReasons = reasonList(reasonCodes.filter(isRerunnableStaleReasonCode));
+  return status === 'stale' && staleReasons.length ? compactRecord({
+    routeId: 'rerun-semantic-edit-replay-current-head',
+    routeLane: 'source-files',
+    routeNext: 'rerun-semantic-edit-replay-on-current-head',
+    action: 'rerun',
+    reasonCodes: staleReasons,
+    expectedCurrentHash: input.currentSourceHash,
+    observedCurrentHash: currentHash,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  }) : undefined;
+}
+
+function isRerunnableStaleReasonCode(code) {
+  return code === 'current-source-hash-mismatch';
+}
+
+function reasonList(values) {
+  return [...new Set((values ?? []).filter((value) => typeof value === 'string' && value.length > 0))];
+}
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}
+
+export { isRerunnableStaleReasonCode, replayRerunRoute };

package/dist/internal/index-impl/semanticEditReplaySourceReplacement.js

@@ -1,5 +1,5 @@
 export function explicitSourceReplacementReplayRange(edit, symbolRange, sourceText) {
-  if (edit.sourceRangeKind !== 'cross-language-explicit-source-replacement' || !symbolRange || typeof sourceText !== 'string') {
+  if (!explicitSourceReplacementMode(edit.sourceRangeKind) || !symbolRange || typeof sourceText !== 'string') {
     return undefined;
   }
   const deleted = uniqueTextRange(sourceText, symbolRange, edit.deletedText, 'deleted-text');
@@ -13,6 +13,11 @@ export function explicitSourceReplacementReplayRange(edit, symbolRange, sourceTe
   };
 }
 
+function explicitSourceReplacementMode(mode) {
+  return mode === 'cross-language-explicit-source-replacement'
+    || mode === 'same-language-callsite-argument-append';
+}
+
 function uniqueTextRange(sourceText, symbolRange, needle, label) {
   if (typeof needle !== 'string' || needle.length === 0) {
     return { status: 'missing', reasonCode: `current-symbol-explicit-source-replacement-${label}-missing` };