@shapeshift-labs/frontier-lang-compiler 0.2.102 → 0.2.104

package/dist/native-region-scanner-swift.js

@@ -0,0 +1,155 @@
+import { upperFirst } from './native-import-utils.js';
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters, splitTypeParameters } from './native-region-scanner-core.js';
+import { braceBlockSpan } from './native-region-scanner-spans.js';
+
+function scanSwift(input) {
+  const declarations = [];
+  const protocols = new Set();
+  const blockStack = [];
+  const lines = sourceLines(input.sourceText);
+  let braceDepth = 0;
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    const declarationLine = trimmed.replace(/^(?:@[A-Za-z_][\w.]+(?:\([^)]*\))?\s+)*/, '');
+    const lineStartDepth = depthAfterLeadingClosers(declarationLine, braceDepth);
+    while (blockStack.length && blockStack[blockStack.length - 1].bodyDepth > lineStartDepth) blockStack.pop();
+
+    let match;
+    if ((match = declarationLine.match(/^import\s+(?:(?:struct|class|enum|protocol|func|var)\s+)?([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDecl', 'module'));
+    } else if ((match = declarationLine.match(/^((?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open|final|indirect)\s+)*)(struct|class|enum|protocol|actor)\s+([A-Za-z_]\w*)/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      if (match[2] === 'protocol') protocols.add(name);
+      const hasBody = declarationLine.includes('{');
+      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[2])}Decl`, swiftSymbolKind(match[2]), name, {
+        modifiers: swiftModifiers(match[1]),
+        ...(owner ? { owner: owner.name } : {})
+      }, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: swiftTypeStackKind(match[2]), name, bodyDepth: braceDepth + 1 });
+    } else if ((match = declarationLine.match(/^((?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open)\s+)*)extension\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)(.*)$/))) {
+      const extensionFields = parseSwiftExtensionTail(match[3]);
+      const isProtocolExtension = protocols.has(match[2]) || /Protocol$/.test(match[2]);
+      const receiverKind = isProtocolExtension ? 'protocolExtension' : 'extension';
+      const name = `${match[2]}.${receiverKind}`;
+      const hasBody = declarationLine.includes('{');
+      declarations.push(nativeDeclaration(input, number, isProtocolExtension ? 'ProtocolExtensionDecl' : 'ExtensionDecl', 'implementation', name, {
+        modifiers: swiftModifiers(match[1]),
+        extendedType: match[2],
+        receiverKind,
+        ...extensionFields
+      }, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: 'extension', name, receiverKind, receiverType: match[2], bodyDepth: braceDepth + 1 });
+    } else if ((match = declarationLine.match(/^((?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open|static|class|mutating|nonmutating|override|required|convenience|isolated|nonisolated)\s+)*)(?:func\s+)([A-Za-z_]\w*|`[^`]+`)(?:\s*<([^>]+)>)?\s*\(([^)]*)\)/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const target = swiftMemberTarget(owner, match[1], unquoteSwiftIdentifier(match[2]));
+      const hasBody = declarationLine.includes('{');
+      declarations.push(nativeDeclaration(input, number, 'FunctionDecl', target.owner ? 'method' : 'function', target.name, {
+        methodName: unquoteSwiftIdentifier(match[2]),
+        modifiers: swiftModifiers(match[1]),
+        typeParameters: splitTypeParameters(match[3]),
+        parameters: splitParameters(match[4]),
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind, receiverType: target.receiverType } : {})
+      }, hasBody, memberSpanOptions(input, lines, index, hasBody, target, unquoteSwiftIdentifier(match[2]), match[1])));
+      if (hasBody) blockStack.push({ kind: 'method', name: target.name, bodyDepth: braceDepth + 1 });
+    } else if ((match = declarationLine.match(/^((?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open|static|class|final|lazy|weak|unowned|override|required|nonisolated)\s+)*)(let|var)\s+([A-Za-z_]\w*)\b(?::\s*([^={]+))?/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const target = swiftMemberTarget(owner, match[1], match[3]);
+      const hasBody = declarationLine.includes('{') || declarationLine.includes('=>');
+      declarations.push(nativeDeclaration(input, number, 'PropertyDecl', 'property', target.name, {
+        binding: match[2],
+        modifiers: swiftModifiers(match[1]),
+        valueType: match[4]?.trim(),
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind, receiverType: target.receiverType } : {})
+      }, hasBody, memberSpanOptions(input, lines, index, hasBody, target, match[3], match[1])));
+    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open)\s+)*typealias\s+([A-Za-z_]\w*)\b(?:\s*=\s*(.+))?/))) {
+      const owner = nearestSwiftOwner(blockStack);
+      const name = owner ? `${owner.name}.${match[1]}` : match[1];
+      declarations.push(nativeDeclaration(input, number, 'TypealiasDecl', 'type', name, {
+        target: match[2]?.trim(),
+        ...(owner ? { owner: owner.name } : {})
+      }, false));
+    }
+    braceDepth = Math.max(0, braceDepth + braceDelta(line));
+  }
+  return declarations;
+}
+
+function spanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
+function memberSpanOptions(input, lines, index, hasBody, target, methodName, modifiers) {
+  return {
+    ...spanOptions(input, lines, index, hasBody),
+    metadata: {
+      methodName,
+      modifiers: swiftModifiers(modifiers),
+      ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind, receiverType: target.receiverType } : {})
+    }
+  };
+}
+
+function depthAfterLeadingClosers(trimmed, depth) {
+  const closers = String(trimmed).match(/^}+/)?.[0].length ?? 0;
+  return Math.max(0, depth - closers);
+}
+
+function nearestSwiftOwner(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'method') return undefined;
+    if (['actor', 'class', 'enum', 'extension', 'protocol', 'struct'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function swiftMemberTarget(owner, modifiers, memberName) {
+  if (!owner) return { name: memberName };
+  if (owner.kind === 'extension') {
+    if (/\b(?:static|class)\b/.test(modifiers)) {
+      return { name: `${owner.name}.static.${memberName}`, owner: owner.name, receiverKind: 'static', receiverType: owner.receiverType };
+    }
+    return { name: `${owner.name}.${memberName}`, owner: owner.name, receiverKind: owner.receiverKind, receiverType: owner.receiverType };
+  }
+  const receiverKind = /\b(?:static|class)\b/.test(modifiers) ? 'static' : 'member';
+  return { name: receiverKind === 'static' ? `${owner.name}.static.${memberName}` : `${owner.name}.${memberName}`, owner: owner.name, receiverKind };
+}
+
+function swiftModifiers(raw) {
+  return splitParameters(String(raw ?? '').trim().replace(/\s+/g, ','));
+}
+
+function swiftTypeStackKind(kind) {
+  return String(kind).replace(/\s+/g, ' ');
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function parseSwiftExtensionTail(rawTail) {
+  let tail = String(rawTail ?? '').split('{')[0].trim();
+  const fields = {};
+  const whereMatch = tail.match(/\bwhere\b(.+)$/);
+  if (whereMatch) {
+    fields.constraints = whereMatch[1].trim();
+    tail = tail.slice(0, whereMatch.index).trim();
+  }
+  if (tail.startsWith(':')) {
+    fields.conformances = tail.slice(1).split(',').map((part) => part.trim()).filter(Boolean);
+  }
+  return fields;
+}
+
+function unquoteSwiftIdentifier(identifier) {
+  return String(identifier).replace(/^`|`$/g, '');
+}
+
+function swiftSymbolKind(kind) {
+  if (kind === 'protocol') return 'protocol';
+  if (kind === 'extension') return 'implementation';
+  if (kind === 'struct' || kind === 'enum' || kind === 'actor') return 'type';
+  return 'class';
+}
+
+export { scanSwift };

package/dist/native-region-scanner.js

@@ -1,24 +1,24 @@
 import { scanJavaScriptLike } from './native-region-scanner-js.js';
 import {
   scanCLike,
-  scanCSharp,
   scanGo,
-  scanJava,
-  scanPython,
-  scanRust,
-  scanSwift
+  scanRust
 } from './native-region-scanner-main.js';
+import { scanJava } from './native-region-scanner-java.js';
+import { scanSwift } from './native-region-scanner-swift.js';
+import { scanCSharp } from './native-region-scanner-csharp.js';
+import { scanPython } from './native-region-scanner-python.js';
+import { scanPhp } from './native-region-scanner-php.js';
+import { scanKotlin } from './native-region-scanner-kotlin.js';
+import { scanScala } from './native-region-scanner-scala.js';
+import { scanDart } from './native-region-scanner-dart.js';
 import {
-  scanDart,
-  scanKotlin,
   scanLua,
-  scanPhp,
-  scanRuby,
-  scanScala,
   scanShell,
   scanSql,
   scanZig
 } from './native-region-scanner-dynamic.js';
+import { scanRuby } from './native-region-scanner-ruby.js';
 import {
   scanElixir,
   scanErlang,
@@ -33,6 +33,10 @@ export {
   scanPreservedSourceDirectives,
   scanPreservedSourceTokens
 } from './native-source-preservation-scanner.js';
+export {
+  isJavaScriptTypeScriptSource,
+  scanJavaScriptTypeScriptSourceLedger
+} from './native-source-ledger.js';
 
 function scanNativeDeclarations(input) {
   const language = normalizeNativeLanguageId(input.language) || String(input.language).toLowerCase();

package/dist/native-source-ledger-helpers.js

@@ -0,0 +1,195 @@
+const regexStartKeywords = new Set(['case', 'delete', 'else', 'in', 'instanceof', 'new', 'return', 'throw', 'typeof', 'void', 'yield']);
+
+export function isSourceMapComment(text) {
+  return /^(?:\/\/|\/\*)[#@]\s*sourceMappingURL=/.test(String(text).trim());
+}
+
+export function readToLineEnd(text, start) {
+  let index = start;
+  while (index < text.length && text[index] !== '\n' && text[index] !== '\r') index += 1;
+  return index;
+}
+
+export function readBlockCommentEnd(text, start) {
+  const end = text.indexOf('*/', start + 2);
+  return end === -1 ? text.length : end + 2;
+}
+
+export function readQuotedEnd(text, start, quote) {
+  let escaped = false;
+  for (let index = start + 1; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+    } else if (char === '\\') {
+      escaped = true;
+    } else if (char === quote) {
+      return index + 1;
+    } else if (char === '\n' || char === '\r') {
+      return index;
+    }
+  }
+  return text.length;
+}
+
+export function readTemplateEnd(text, start) {
+  let escaped = false;
+  for (let index = start + 1; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) escaped = false;
+    else if (char === '\\') escaped = true;
+    else if (char === '`') return index + 1;
+  }
+  return text.length;
+}
+
+export function readRegexEnd(text, start) {
+  let escaped = false;
+  let inClass = false;
+  for (let index = start + 1; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '\n' || char === '\r') return undefined;
+    if (escaped) escaped = false;
+    else if (char === '\\') escaped = true;
+    else if (char === '[') inClass = true;
+    else if (char === ']') inClass = false;
+    else if (char === '/' && !inClass) return readWhile(text, index + 1, (value) => /[A-Za-z]/.test(value));
+  }
+  return undefined;
+}
+
+export function readJsxRegionEnd(text, start) {
+  let index = start;
+  let depth = 0;
+  while (index < text.length) {
+    if (text[index] === '{') {
+      index = readBalancedBraceEnd(text, index);
+      continue;
+    }
+    if (text[index] !== '<') {
+      index += 1;
+      continue;
+    }
+    const tag = readJsxTag(text, index);
+    if (!tag) return index > start ? index : start + 1;
+    if (tag.close) depth -= 1;
+    else if (!tag.selfClosing) depth += 1;
+    index = tag.end;
+    if (depth <= 0) return index;
+  }
+  return text.length;
+}
+
+export function readStatementEnd(text, start) {
+  const end = readToLineEnd(text, start);
+  const semicolon = text.indexOf(';', start);
+  return semicolon !== -1 && semicolon < end ? semicolon + 1 : end;
+}
+
+export function readWhile(text, start, predicate) {
+  let index = start;
+  while (index < text.length && predicate(text[index])) index += 1;
+  return index;
+}
+
+export function endPosition(start, text) {
+  let line = start.line;
+  let column = start.column;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === '\r') {
+      if (text[index + 1] === '\n') index += 1;
+      line += 1;
+      column = 1;
+    } else if (text[index] === '\n') {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { offset: start.offset + text.length, line, column };
+}
+
+export function looksLikeJsxStart(text, offset, previous) {
+  if (text[offset] !== '<' || !(isIdentifierStart(text[offset + 1]) || text[offset + 1] === '>')) return false;
+  if (!previous) return true;
+  if (previous.kind === 'operator' || ['(', '[', '{', ',', ':', '?', '=>'].includes(previous.text)) return true;
+  return previous.kind === 'keyword' && ['return', 'case', 'throw'].includes(previous.text);
+}
+
+export function mayStartRegex(previous) {
+  if (!previous) return true;
+  if (previous.kind === 'operator') return true;
+  if (previous.kind === 'keyword') return regexStartKeywords.has(previous.text);
+  return ['(', '[', '{', ',', ';', ':', '?'].includes(previous.text);
+}
+
+export function braceMetadata(char, stack, tokenId) {
+  const kind = char === '{' || char === '}' ? 'curly' : char === '(' || char === ')' ? 'paren' : 'bracket';
+  if (char === '{' || char === '(' || char === '[') {
+    stack.push({ char, tokenId, kind });
+    return { braceKind: kind, side: 'open', depth: stack.length };
+  }
+  const open = char === '}' ? '{' : char === ')' ? '(' : '[';
+  const matchIndex = stack.map((entry) => entry.char).lastIndexOf(open);
+  const matched = matchIndex >= 0 ? stack.splice(matchIndex, 1)[0] : undefined;
+  return { braceKind: kind, side: 'close', depth: stack.length + 1, openTokenId: matched?.tokenId };
+}
+
+export function isBrace(char) {
+  return char === '{' || char === '}' || char === '(' || char === ')' || char === '[' || char === ']';
+}
+
+export function isHorizontalWhitespace(char) {
+  return char === ' ' || char === '\t' || char === '\v' || char === '\f';
+}
+
+export function isIdentifierStart(char) {
+  return /[A-Za-z_$]/.test(char ?? '');
+}
+
+export function isIdentifierPart(char) {
+  return /[A-Za-z0-9_$]/.test(char ?? '');
+}
+
+function readJsxTag(text, start) {
+  if (text[start + 1] === '!' && text.startsWith('<!--', start)) {
+    const end = text.indexOf('-->', start + 4);
+    return { end: end === -1 ? text.length : end + 3, selfClosing: true, close: false };
+  }
+  let index = start + 1;
+  const close = text[index] === '/';
+  if (close) index += 1;
+  if (text[index] === '>') return { end: index + 1, selfClosing: false, close };
+  if (!isIdentifierStart(text[index])) return undefined;
+  let quote = undefined;
+  for (; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (char === '\\') index += 1;
+      else if (char === quote) quote = undefined;
+    } else if (char === '\'' || char === '"') {
+      quote = char;
+    } else if (char === '>') {
+      return { end: index + 1, selfClosing: text[index - 1] === '/', close };
+    }
+  }
+  return { end: text.length, selfClosing: true, close };
+}
+
+function readBalancedBraceEnd(text, start) {
+  let depth = 1;
+  for (let index = start + 1; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '\'' || char === '"') index = readQuotedEnd(text, index, char) - 1;
+    else if (char === '`') index = readTemplateEnd(text, index) - 1;
+    else if (char === '/' && text[index + 1] === '/') index = readToLineEnd(text, index) - 1;
+    else if (char === '/' && text[index + 1] === '*') index = readBlockCommentEnd(text, index) - 1;
+    else if (char === '{') depth += 1;
+    else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return index + 1;
+    }
+  }
+  return text.length;
+}