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

package/dist/js-ts-safe-member-class-invariants.js

@@ -0,0 +1,247 @@
+import { normalizeKind, uniqueStrings } from './js-ts-semantic-merge-parse.js';
+
+export function classBodyInvariantReasons(region, side, body) {
+  const reasonCodes = [];
+  for (const segment of splitClassElementSegments(body)) {
+    const text = segment.text.trim();
+    if (!text) continue;
+    if (hasClassDecorator(text)) reasonCodes.push(regionReason(region, `decorator-member:${side}`));
+    if (hasStaticBlock(text)) reasonCodes.push(regionReason(region, `static-block-ordering:${side}`));
+  }
+  return uniqueStrings(reasonCodes);
+}
+
+export function classPrivateScopeReasons(region, side, baseMembers, sideMembers, sideAddedKeys) {
+  const reasonCodes = [];
+  const basePrivateNames = privateDeclarationNames(baseMembers);
+  const sidePrivateNames = privateDeclarationNames(sideMembers);
+  for (const name of duplicatePrivateDeclarationNames(sideMembers)) {
+    reasonCodes.push(regionReason(region, `private-name-scope:${side}:${name}`));
+  }
+  for (const key of sideAddedKeys) {
+    const member = sideMembers.find((candidate) => candidate.key === key);
+    if (!member) continue;
+    const declaredName = privateNameFromKey(member.key);
+    if (declaredName && basePrivateNames.has(declaredName)) {
+      reasonCodes.push(regionReason(region, `private-name-scope:${side}:${declaredName}`));
+    }
+    for (const name of privateReferences(member)) {
+      if (!basePrivateNames.has(name) && !sidePrivateNames.has(name)) {
+        reasonCodes.push(regionReason(region, `private-name-scope:${side}:${name}`));
+      }
+    }
+  }
+  return uniqueStrings(reasonCodes);
+}
+
+export function classPrivateAddedCollisionReasons(region, workerAddedKeys, headAddedKeys, workerByKey, headByKey) {
+  const workerNames = privateNamesForKeys(workerAddedKeys, workerByKey);
+  const headNames = privateNamesForKeys(headAddedKeys, headByKey);
+  return [...workerNames].filter((name) => headNames.has(name))
+    .map((name) => regionReason(region, `private-name-scope:worker-head:${name}`));
+}
+
+export function isAccessorMember(member) {
+  return member?.memberKind === 'accessor';
+}
+
+export function isPrivateMemberKey(key) {
+  return Boolean(privateNameFromKey(key));
+}
+
+export function privateNameFromKey(key) {
+  const normalized = String(key ?? '').replace(/^static\./, '');
+  return normalized.startsWith('#') ? normalized : undefined;
+}
+
+function regionReason(region, reason) {
+  return `${reason}:${normalizeKind(region.kind)}:${region.name}`;
+}
+
+function privateNamesForKeys(keys, byKey) {
+  const names = new Set();
+  for (const key of keys) {
+    const name = privateNameFromKey(byKey.get(key)?.key);
+    if (name) names.add(name);
+  }
+  return names;
+}
+
+function privateDeclarationNames(members) {
+  const names = new Set();
+  for (const member of members) {
+    const name = privateNameFromKey(member.key);
+    if (name) names.add(name);
+  }
+  return names;
+}
+
+function duplicatePrivateDeclarationNames(members) {
+  const namesByPrivateName = new Map();
+  for (const member of members) {
+    const name = privateNameFromKey(member.key);
+    if (!name) continue;
+    const keys = namesByPrivateName.get(name) ?? new Set();
+    keys.add(member.key);
+    namesByPrivateName.set(name, keys);
+  }
+  return [...namesByPrivateName]
+    .filter(([, keys]) => keys.size > 1)
+    .map(([name]) => name);
+}
+
+function privateReferences(member) {
+  const declarations = new Set();
+  const declaredName = privateNameFromKey(member?.key);
+  if (declaredName) declarations.add(declaredName);
+  return privateNameTokens(member?.text).filter((name) => !declarations.has(name));
+}
+
+function privateNameTokens(text) {
+  const names = [];
+  const source = String(text ?? '');
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '#' && /[A-Za-z_$]/.test(next ?? '')) {
+      let end = index + 2;
+      while (/[\w$]/.test(source[end] ?? '')) end += 1;
+      names.push(source.slice(index, end));
+      index = end - 1;
+    }
+  }
+  return uniqueStrings(names);
+}
+
+function hasClassDecorator(text) {
+  return String(text ?? '').trimStart().startsWith('@');
+}
+
+function hasStaticBlock(text) {
+  return /^static\s*\{/.test(String(text ?? '').trimStart());
+}
+
+function splitClassElementSegments(body) {
+  const entries = [];
+  const text = String(body ?? '');
+  let start = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') {
+      depth += 1;
+      continue;
+    }
+    if (char === '}' || char === ']' || char === ')') {
+      depth -= 1;
+      if (depth === 0 && char === '}') {
+        const nextIndex = nextSignificantIndex(text, index + 1);
+        if (text[nextIndex] !== ';') {
+          entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+          start = index + 1;
+        }
+      }
+      continue;
+    }
+    if (char === ';' && depth === 0) {
+      entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+      start = index + 1;
+    }
+  }
+  entries.push({ text: text.slice(start), start, end: text.length });
+  return entries.filter((entry) => entry.text.trim());
+}
+
+function nextSignificantIndex(text, offset) {
+  let index = offset;
+  while (index < text.length) {
+    if (/\s/.test(text[index])) {
+      index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '/') {
+      index += 2;
+      while (index < text.length && text[index] !== '\n' && text[index] !== '\r') index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '*') {
+      index += 2;
+      while (index < text.length && !(text[index] === '*' && text[index + 1] === '/')) index += 1;
+      index += 2;
+      continue;
+    }
+    break;
+  }
+  return index;
+}

package/dist/js-ts-safe-member-merge-result.js

@@ -91,6 +91,10 @@ function memberConflictForReason(reason, input, index) {
 
 function blockedReasonCode(reason) {
   if (reason.includes('computed-key')) return 'computed-key';
+  if (reason.includes('decorator-member')) return 'decorator-member';
+  if (reason.includes('static-block-ordering')) return 'static-block-ordering';
+  if (reason.includes('accessor-pairing')) return 'accessor-pairing';
+  if (reason.includes('private-name-scope')) return 'private-name-scope';
   if (reason.includes('spread-like-member') || reason.includes('spread-member')) return 'spread-like-member';
   if (reason.includes('overload-collision')) return 'overload-collision';
   if (reason.includes('type-alias-conflict')) return 'type-alias-conflict';
@@ -109,6 +113,9 @@ function blockedReasonCode(reason) {
 
 function conflictCodeForReason(reasonCode) {
   if (reasonCode === 'computed-key') return JsTsSafeMergeConflictCodes.computedKey;
+  if (reasonCode === 'decorator-member') return JsTsSafeMergeConflictCodes.unsupportedDecorator;
+  if (reasonCode === 'static-block-ordering') return JsTsSafeMergeConflictCodes.topLevelOrderChanged;
+  if (reasonCode === 'accessor-pairing' || reasonCode === 'private-name-scope') return JsTsSafeMergeConflictCodes.duplicateName;
   if (reasonCode === 'overload-collision') return JsTsSafeMergeConflictCodes.unsupportedOverload;
   if (reasonCode === 'type-alias-conflict') return JsTsSafeMergeConflictCodes.typeAliasConflict;
   if (reasonCode === 'duplicate-member-name') return JsTsSafeMergeConflictCodes.duplicateName;
@@ -122,11 +129,15 @@ function conflictCodeForReason(reasonCode) {
 }
 
 function gateIdForReason(reasonCode) {
-  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision') return JsTsSafeMergeGateIds.uniqueNames;
+  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision' || reasonCode === 'accessor-pairing' || reasonCode === 'private-name-scope') {
+    return JsTsSafeMergeGateIds.uniqueNames;
+  }
   if (reasonCode === 'changed-existing-member' || reasonCode === 'removed-existing-member' || reasonCode === 'non-policy-source-change') {
     return JsTsSafeMergeGateIds.stableExistingDeclarations;
   }
-  if (reasonCode === 'existing-member-order-changed' || reasonCode === 'order-sensitive-region-kind') return JsTsSafeMergeGateIds.preserveBaseOrder;
+  if (reasonCode === 'existing-member-order-changed' || reasonCode === 'order-sensitive-region-kind' || reasonCode === 'static-block-ordering') {
+    return JsTsSafeMergeGateIds.preserveBaseOrder;
+  }
   return JsTsSafeMergeGateIds.parseLedger;
 }
 
@@ -137,13 +148,22 @@ function reasonDetails(reason, reasonCode) {
   if (['base', 'worker', 'head'].includes(parts[2])) details.side = parts[2];
   const kind = parts.find((part) => ['interface', 'type', 'class', 'object'].includes(part));
   if (kind) details.regionKind = kind;
-  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision') details.memberName = parts.at(-3) ?? parts.at(-1);
+  if (reasonCode === 'duplicate-member-name'
+    || reasonCode === 'overload-collision'
+    || reasonCode === 'accessor-pairing'
+    || reasonCode === 'private-name-scope') {
+    details.memberName = parts.at(-3) ?? parts.at(-1);
+  }
   if (reasonCode === 'changed-existing-member' || reasonCode === 'removed-existing-member') details.memberName = parts.at(-3);
   return details;
 }
 
 function memberConflictMessage(reasonCode, details) {
   if (reasonCode === 'computed-key') return 'Computed member keys are not safe for automatic member merge.';
+  if (reasonCode === 'decorator-member') return 'Decorated class members are not safe for automatic unordered member merge.';
+  if (reasonCode === 'static-block-ordering') return 'Class static blocks make member order observable and block unordered member merge.';
+  if (reasonCode === 'accessor-pairing') return 'Getter/setter member pairs are not safe for automatic unordered member merge.';
+  if (reasonCode === 'private-name-scope') return 'Private class names must remain scoped to one class element declaration set.';
   if (reasonCode === 'spread-like-member') return 'Spread-like member syntax makes object member merge ambiguous.';
   if (reasonCode === 'overload-collision') return 'Member overloads or duplicate method signatures collide in an unordered member region.';
   if (reasonCode === 'changed-existing-member') return 'An existing member changed inside a safe member-addition region.';

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

@@ -9,6 +9,14 @@ import {
   removePreparedMemberAdditions,
   uniqueStrings
 } from './js-ts-semantic-merge-parse.js';
+import {
+  classBodyInvariantReasons,
+  classPrivateAddedCollisionReasons,
+  classPrivateScopeReasons,
+  isAccessorMember,
+  isPrivateMemberKey,
+  privateNameFromKey
+} from './js-ts-safe-member-class-invariants.js';
 import { mergeResult } from './js-ts-safe-member-merge-result.js';
 
 const NonSemanticRegionKinds = new Set(['property', 'type', 'config', 'content']);
@@ -155,6 +163,11 @@ function prepareRegion(input) {
   const baseMembers = parseMembers(base.value.body, kind);
   const workerMembers = parseMembers(worker.value.body, kind);
   const headMembers = parseMembers(head.value.body, kind);
+  if (kind === 'class') {
+    reasonCodes.push(...classBodyInvariantReasons(input.region, 'base', base.value.body));
+    reasonCodes.push(...classBodyInvariantReasons(input.region, 'worker', worker.value.body));
+    reasonCodes.push(...classBodyInvariantReasons(input.region, 'head', head.value.body));
+  }
   reasonCodes.push(...regionParseReasons(input.region, 'base', baseMembers));
   reasonCodes.push(...regionParseReasons(input.region, 'worker', workerMembers));
   reasonCodes.push(...regionParseReasons(input.region, 'head', headMembers));
@@ -170,6 +183,11 @@ function prepareRegion(input) {
   const workerAddedKeys = workerMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
   const headAddedKeys = headMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
   reasonCodes.push(...duplicateAddedReasons(input.region, workerAddedKeys, workerByKey, headByKey));
+  if (kind === 'class') {
+    reasonCodes.push(...classPrivateScopeReasons(input.region, 'worker', baseMembers.members, workerMembers.members, workerAddedKeys));
+    reasonCodes.push(...classPrivateScopeReasons(input.region, 'head', baseMembers.members, headMembers.members, headAddedKeys));
+    reasonCodes.push(...classPrivateAddedCollisionReasons(input.region, workerAddedKeys, headAddedKeys, workerByKey, headByKey));
+  }
   if (reasonCodes.length) return { ok: false, reasonCodes };
   return {
     ok: true,
@@ -209,7 +227,11 @@ function duplicateReasons(region, side, members) {
     }
   }
   return [...duplicateGroups].map(([key, group]) => {
-    const reason = group.some(isOverloadLikeMember) ? `overload-collision:${side}:${key}` : `duplicate-key:${side}:${key}`;
+    let reason;
+    if (group.some(isOverloadLikeMember)) reason = `overload-collision:${side}:${key}`;
+    else if (group.every(isAccessorMember)) reason = `accessor-pairing:${side}:${key}`;
+    else if (isPrivateMemberKey(key)) reason = `private-name-scope:${side}:${privateNameFromKey(key)}`;
+    else reason = `duplicate-key:${side}:${key}`;
     return regionReason(region, reason);
   });
 }
@@ -239,9 +261,11 @@ function duplicateAddedReasons(region, workerAddedKeys, workerByKey, headByKey)
   return duplicateAddedKeys.map((key) => {
     const workerMember = workerByKey.get(key);
     const headMember = headByKey.get(key);
-    const reason = isOverloadLikeMember(workerMember) || isOverloadLikeMember(headMember)
-      ? `overload-collision:worker-head:${key}`
-      : `duplicate-added-key:${key}`;
+    let reason;
+    if (isOverloadLikeMember(workerMember) || isOverloadLikeMember(headMember)) reason = `overload-collision:worker-head:${key}`;
+    else if (isAccessorMember(workerMember) || isAccessorMember(headMember)) reason = `accessor-pairing:worker-head:${key}`;
+    else if (isPrivateMemberKey(key)) reason = `private-name-scope:worker-head:${privateNameFromKey(key)}`;
+    else reason = `duplicate-added-key:${key}`;
     return regionReason(region, reason);
   });
 }

package/dist/js-ts-safe-merge-binding-patterns.js

@@ -0,0 +1,170 @@
+import { uniqueStrings } from './js-ts-safe-merge-context.js';
+
+function analyzeJsTsBindingPattern(patternText, patternKind) {
+  const reasonCodes = [];
+  const inner = patternText.slice(1, -1);
+  if (patternKind === 'array') reasonCodes.push('binding-pattern-array-order-blocked');
+  if (containsJsTsCodeToken(patternText, '...')) reasonCodes.push('binding-pattern-rest-spread-blocked');
+  if (containsJsTsCodeToken(patternText, '=')) reasonCodes.push('binding-pattern-default-initializer-blocked');
+  if (patternKind === 'object' && containsJsTsCodeToken(patternText, ':')) reasonCodes.push('binding-pattern-rename-blocked');
+  const entries = splitJsTsTopLevelCommaText(inner).filter((part) => part.trim());
+  const bindingNames = patternKind === 'object' && reasonCodes.length === 0
+    ? entries.map((part) => simpleIdentifier(part.trim())).filter(Boolean)
+    : [];
+  if (patternKind === 'object' && reasonCodes.length === 0 && bindingNames.length !== entries.length) {
+    reasonCodes.push('binding-pattern-unsupported-shape-blocked');
+  }
+  if (patternKind === 'object' && reasonCodes.length === 0 && bindingNames.length === 0) {
+    reasonCodes.push('binding-pattern-empty-object-blocked');
+  }
+  return {
+    patternKind,
+    bindingNames,
+    reasonCodes: uniqueStrings([
+      ...reasonCodes,
+      ...(reasonCodes.length ? ['binding-pattern-merge-requires-binding-use-evidence'] : [])
+    ])
+  };
+}
+
+function jsTsFunctionParameterBindingPatternReasonCodes(baseText, workerText) {
+  const baseParameters = functionParameterText(baseText);
+  const workerParameters = functionParameterText(workerText);
+  if (baseParameters === undefined || workerParameters === undefined) return [];
+  if (sameParameterText(baseParameters, workerParameters)) return [];
+  const base = bindingPatternParameterAnalysis(baseParameters);
+  const worker = bindingPatternParameterAnalysis(workerParameters);
+  if (!base.hasBindingPattern && !worker.hasBindingPattern) return [];
+  return uniqueStrings([
+    ...base.reasonCodes,
+    ...worker.reasonCodes,
+    'binding-pattern-parameter-merge-requires-binding-use-evidence'
+  ]);
+}
+
+function bindingPatternParameterAnalysis(parameters) {
+  const reasonCodes = [];
+  let hasBindingPattern = false;
+  for (const parameter of splitJsTsTopLevelCommaText(parameters).map((part) => part.trim()).filter(Boolean)) {
+    const text = parameter.startsWith('...') ? parameter.slice(3).trim() : parameter;
+    if (parameter.startsWith('...')) reasonCodes.push('binding-pattern-rest-spread-blocked');
+    if (!text.startsWith('{') && !text.startsWith('[')) continue;
+    hasBindingPattern = true;
+    const patternKind = text[0] === '{' ? 'object' : 'array';
+    const patternText = leadingJsTsBindingPatternText(text, patternKind);
+    if (!patternText) {
+      reasonCodes.push('binding-pattern-unsupported-shape-blocked');
+      continue;
+    }
+    reasonCodes.push(...analyzeJsTsBindingPattern(patternText, patternKind).reasonCodes);
+  }
+  return { hasBindingPattern, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function leadingJsTsBindingPatternText(text, patternKind) {
+  const open = patternKind === 'object' ? '{' : '[';
+  const close = patternKind === 'object' ? '}' : ']';
+  if (text[0] !== open) return undefined;
+  const end = matchingJsTsBracketEnd(text, 0, open, close);
+  return end === undefined ? undefined : text.slice(0, end + 1);
+}
+
+function matchingJsTsBracketEnd(text, start, open, close) {
+  let state = 'code';
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    const step = scanStep(text, index, state);
+    state = step.state;
+    if (step.skipTo !== undefined) {
+      index = step.skipTo;
+      continue;
+    }
+    if (state !== 'code') continue;
+    const char = text[index];
+    if (char === open || char === '{' || char === '[') depth += 1;
+    else if (char === close || char === '}' || char === ']') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+    if (depth < 0) return undefined;
+  }
+  return undefined;
+}
+
+function functionParameterText(text) {
+  const source = String(text ?? '');
+  const open = source.indexOf('(');
+  if (open < 0) return undefined;
+  const end = matchingJsTsBracketEnd(source, open, '(', ')');
+  return end === undefined ? undefined : source.slice(open + 1, end);
+}
+
+function splitJsTsTopLevelCommaText(text) {
+  const parts = [];
+  let start = 0;
+  let state = 'code';
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const step = scanStep(text, index, state);
+    state = step.state;
+    if (step.skipTo !== undefined) {
+      index = step.skipTo;
+      continue;
+    }
+    if (state !== 'code') continue;
+    const char = text[index];
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth -= 1;
+    else if (char === ',' && depth === 0) {
+      parts.push(text.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+
+function containsJsTsCodeToken(text, token) {
+  let state = 'code';
+  for (let index = 0; index < text.length; index += 1) {
+    const step = scanStep(text, index, state);
+    state = step.state;
+    if (step.skipTo !== undefined) {
+      index = step.skipTo;
+      continue;
+    }
+    if (state === 'code' && text.startsWith(token, index)) return true;
+  }
+  return false;
+}
+
+function scanStep(text, index, state) {
+  const char = text[index];
+  const next = text[index + 1];
+  if (state === 'line-comment') return { state: char === '\n' ? 'code' : state };
+  if (state === 'block-comment') {
+    return char === '*' && next === '/' ? { state: 'code', skipTo: index + 1 } : { state };
+  }
+  if (state !== 'code') {
+    if (char === '\\') return { state, skipTo: index + 1 };
+    return { state: char === state ? 'code' : state };
+  }
+  if (char === '/' && next === '/') return { state: 'line-comment', skipTo: index + 1 };
+  if (char === '/' && next === '*') return { state: 'block-comment', skipTo: index + 1 };
+  if (char === '"' || char === "'" || char === '`') return { state: char };
+  return { state };
+}
+
+function sameParameterText(left, right) {
+  return String(left ?? '').replace(/\s+/g, ' ').trim() === String(right ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function simpleIdentifier(text) {
+  return /^[A-Za-z_$][\w$]*$/u.test(text) ? text : undefined;
+}
+
+export {
+  analyzeJsTsBindingPattern,
+  jsTsFunctionParameterBindingPatternReasonCodes,
+  leadingJsTsBindingPatternText
+};