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

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

@@ -1,40 +1,49 @@
 import {
   braceDelta,
-  jsControlKeyword,
-  nativeDeclaration,
-  nativeImportDeclaration,
+  nativeDeclaration, nativeImportDeclaration, nativeSignatureDeclaration,
   sourceLines,
   splitParameters
 } from './native-region-scanner-core.js';
 import {
   jsCommentOnlyLine,
-  jsContainerDelta,
   jsDeclarationScanLine,
-  jsExportAliasDeclaration,
+  jsExportAliasDeclaration, jsExportDeclarations,
   jsExportedContainerDeclaration,
   jsExportedFunctionWrapperDeclaration,
   jsInitializerKind,
   jsImportDeclarations,
-  jsObjectPropertyDeclaration,
   jsObjectRegionContext,
   jsRegionKindForDeclarationName,
-  jsRouteRecordDeclaration,
   jsVariableHasBody,
   jsVariableSymbolKind
 } from './native-region-scanner-js-helpers.js';
+import { jsStructureDelta } from './native-region-scanner-js-structure.js';
 import {
-  jsContextAllowsPropertyScan,
-  jsCurrentObjectContext,
-  jsInlineNestedObjectDeclarations,
-  jsNestedObjectContextFromDeclaration,
-  updateJsObjectContextStack
+  jsCurrentTypeMemberContext,
+  jsNestedTypeMemberContextFromDeclaration,
+  jsTypeMemberDeclaration,
+  jsTypeRegionContext,
+  updateJsTypeRegionContext
+} from './native-region-scanner-js-types.js';
+import {
+  jsArrayObjectContextFromLine, jsContextAllowsPropertyScan, jsCurrentObjectContext,
+  jsInlineNestedObjectDeclarations, jsNestedObjectContextFromDeclaration,
+  jsObjectPropertyDeclaration, jsRouteRecordDeclaration,
+  updateJsArrayObjectContextName, updateJsObjectContextStack
 } from './native-region-scanner-js-nested.js';
+import {
+  jsClassMemberDeclaration,
+  jsInlineClassMemberDeclarations
+} from './native-region-scanner-js-class.js';
 
 function scanJavaScriptLike(input) {
   const declarations = [];
   const lines = sourceLines(input.sourceText);
   const pushDeclaration = (declaration) => {
-    if (declaration) declarations.push(jsDeclarationWithSourceSpan(input, declaration, lines));
+    if (!declaration) return undefined;
+    const declarationWithSpan = jsDeclarationWithSourceSpan(input, declaration, lines);
+    declarations.push(declarationWithSpan);
+    return declarationWithSpan;
   };
   const pushDeclarations = (items) => {
     for (const declaration of items ?? []) pushDeclaration(declaration);
@@ -51,14 +60,22 @@ function scanJavaScriptLike(input) {
     const declarationLine = trimmed.replace(/^(?:export\s+)?(?:declare\s+)?/, '');
     let match;
     if (currentType && number !== currentType.startLine) {
-      pushDeclaration(jsTypeMemberDeclaration(input, number, declarationLine, currentType));
+      const typeContext = jsCurrentTypeMemberContext(currentType);
+      if (!typeContext.suppressMembers) {
+        const typeMember = pushDeclaration(jsTypeMemberDeclaration(input, number, declarationLine, typeContext));
+        const nestedTypeContext = jsNestedTypeMemberContextFromDeclaration(typeMember, number, declarationLine, typeContext);
+        if (nestedTypeContext) currentType.memberStack.push(nestedTypeContext);
+      }
     }
     const currentObject = jsCurrentObjectContext(objectStack);
     if (currentObject) {
+      const arrayItemContext = jsArrayObjectContextFromLine(currentObject, number, trimmed);
+      if (arrayItemContext) objectStack.push(arrayItemContext);
       const routeRecord = jsRouteRecordDeclaration(input, number, trimmed, currentObject);
       if (routeRecord) {
         pushDeclaration(routeRecord);
       } else if (jsContextAllowsPropertyScan(currentObject)) {
+        updateJsArrayObjectContextName(currentObject, trimmed);
         const property = jsObjectPropertyDeclaration(input, number, trimmed, currentObject);
         if (property) {
           pushDeclaration(property);
@@ -74,9 +91,15 @@ function scanJavaScriptLike(input) {
     } else if ((match = trimmed.match(/^import\s*\(\s*['"]([^'"]+)['"]\s*\)/))) {
       pushDeclaration(nativeImportDeclaration(input, number, match[1], 'DynamicImportExpression', 'module'));
     } else if ((match = declarationLine.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?/))) {
-      pushDeclaration(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, declarationLine.includes('{')));
+      const hasBody = declarationLine.includes('{');
+      pushDeclaration((hasBody ? nativeDeclaration : nativeSignatureDeclaration)(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, hasBody));
     } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?/))) {
       pushDeclaration(nativeDeclaration(input, number, 'ExportDefaultFunctionDeclaration', 'function', match[1] ?? 'default', { parameters: splitParameters(match[2]), exportDefault: true }, trimmed.includes('{')));
+    } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'ExportDefaultArrowFunctionDeclaration', 'function', 'default', {
+        parameters: splitParameters(match[1] ?? match[2]),
+        exportDefault: true
+      }, true));
     } else if ((match = declarationLine.match(/^(default\s+)?(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/)) && (match[1] || match[2])) {
       const className = match[2] ?? 'default';
       const exportDefault = Boolean(match[1]);
@@ -121,24 +144,43 @@ function scanJavaScriptLike(input) {
       if (match.context) objectStack.push(match.context);
     } else if ((match = jsExportAliasDeclaration(input, number, trimmed))) {
       pushDeclaration(match);
+    } else if ((match = trimmed.match(/^module\.exports\s*=\s*(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsDefaultFunctionExport', 'function', match[1] ?? 'module.exports', {
+        export: 'commonjs',
+        parameters: splitParameters(match[2])
+      }, true));
+    } else if ((match = trimmed.match(/^module\.exports\s*=\s*(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsDefaultArrowFunctionExport', 'function', 'module.exports', {
+        export: 'commonjs',
+        parameters: splitParameters(match[1] ?? match[2])
+      }, true));
+    } else if ((match = trimmed.match(/^module\.exports\s*=\s*(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/))) {
+      const className = match[1] ?? 'module.exports';
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsDefaultClassExport', 'class', className, { export: 'commonjs' }, trimmed.includes('{')));
+      pushDeclarations(jsInlineClassMemberDeclarations(input, number, trimmed, className));
+      if (jsStructureDelta(trimmed).value > 0) {
+        currentClass = className;
+        classDepth = 0;
+      }
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\*?\s*\(([^)]*)\)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+    } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, true));
+    } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/))) {
+      const className = match[2] ?? match[1];
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsClassExport', 'class', className, { export: 'commonjs', exportName: match[1] }, trimmed.includes('{')));
+      pushDeclarations(jsInlineClassMemberDeclarations(input, number, trimmed, className));
+      if (jsStructureDelta(trimmed).value > 0) {
+        currentClass = className;
+        classDepth = 0;
+      }
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
       const regionKind = jsRegionKindForDeclarationName(match[1], trimmed);
       pushDeclaration(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false, { regionKind }));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
-      pushDeclaration(nativeDeclaration(input, number, 'MethodDefinition', 'method', `${currentClass}.${match[1]}`, {
-        methodName: match[1],
-        owner: currentClass,
-        parameters: splitParameters(match[2])
-      }, declarationLine.includes('{') || declarationLine.includes('=>')));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*(#?[A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
-      pushDeclaration(nativeDeclaration(input, number, 'PropertyDefinition', 'property', `${currentClass}.${match[1]}`, {
-        propertyName: match[1],
-        owner: currentClass,
-        valueType: match[2]?.trim()
-      }, false, { regionKind: 'property' }));
+    } else if (currentClass) {
+      pushDeclaration(jsClassMemberDeclaration(input, number, declarationLine, currentClass));
     }
+    pushDeclarations(jsExportDeclarations(input, number, trimmed));
     if (currentClass) {
       classDepth += braceDelta(trimmed);
       if (classDepth <= 0) {
@@ -147,7 +189,7 @@ function scanJavaScriptLike(input) {
       }
     }
     if (currentType) {
-      if (number !== currentType.startLine) currentType.depth += jsStructureDelta(trimmed).value;
+      if (number !== currentType.startLine) updateJsTypeRegionContext(currentType, number, trimmed);
       if (currentType.depth <= 0) currentType = undefined;
     }
     updateJsObjectContextStack(objectStack, number, trimmed);
@@ -192,94 +234,4 @@ function jsBalancedDeclarationEndLine(input, lines, startLine) {
   return startLine;
 }
 
-function jsStructureDelta(source) {
-  let value = 0;
-  let opened = false;
-  let quote;
-  let escaped = false;
-  for (const char of String(source ?? '')) {
-    if (quote) {
-      if (escaped) escaped = false;
-      else if (char === '\\') escaped = true;
-      else if (char === quote) quote = undefined;
-      continue;
-    }
-    if (char === '\'' || char === '"' || char === '`') {
-      quote = char;
-      continue;
-    }
-    if (char === '{' || char === '[' || char === '(') {
-      value += 1;
-      opened = true;
-    } else if (char === '}' || char === ']' || char === ')') {
-      value -= 1;
-    }
-  }
-  return { value, opened };
-}
-
-function jsTypeRegionContext(name, declarationLine, lineNumber, regionKind, typeKind) {
-  const depth = jsStructureDelta(declarationLine).value;
-  if (depth <= 0) return undefined;
-  return {
-    name,
-    typeKind,
-    regionKind,
-    depth,
-    startLine: lineNumber
-  };
-}
-
-function jsTypeMemberDeclaration(input, lineNumber, declarationLine, context) {
-  const text = String(declarationLine ?? '').trim();
-  if (!text || /^[}\])]/.test(text) || text.startsWith('//')) return undefined;
-  let match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*([^;,]+))?[;,]?$/);
-  if (match && !jsControlKeyword(match[2])) {
-    return nativeDeclaration(input, lineNumber, 'TypeMethodSignature', 'method', `${context.name}.${match[2]}`, {
-      owner: context.name,
-      propertyName: match[2],
-      parameters: splitParameters(match[3]),
-      returnType: match[4]?.trim(),
-      typeKind: context.typeKind
-    }, false, {
-      regionKind: jsTypeMemberRegionKind(context, match[2], text),
-      metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
-    });
-  }
-  match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*:\s*(.+?)[;,]?$/);
-  if (!match || jsControlKeyword(match[2])) return undefined;
-  const valueType = match[3].trim();
-  const functionLike = /=>/.test(valueType) || /^\([^)]*\)\s*=>/.test(valueType);
-  return nativeDeclaration(input, lineNumber, functionLike ? 'TypeFunctionPropertySignature' : 'TypePropertySignature', functionLike ? 'function' : 'property', `${context.name}.${match[2]}`, {
-    owner: context.name,
-    propertyName: match[2],
-    valueType,
-    typeKind: context.typeKind
-  }, false, {
-    regionKind: jsTypeMemberRegionKind(context, match[2], text),
-    metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
-  });
-}
-
-function jsTypeMemberRegionKind(context, propertyName, source) {
-  return jsRegionKindForDeclarationName(propertyName, source) ?? (context.regionKind === 'type' ? 'property' : context.regionKind) ?? 'property';
-}
-
-function jsInlineClassMemberDeclarations(input, lineNumber, declarationLine, className) {
-  const open = declarationLine.indexOf('{');
-  const close = declarationLine.lastIndexOf('}');
-  if (open < 0 || close <= open) return [];
-  const body = declarationLine.slice(open + 1, close);
-  const declarations = [];
-  for (const match of body.matchAll(/(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={;]+)?\s*(?:\{|=>)/g)) {
-    if (jsControlKeyword(match[1])) continue;
-    declarations.push(nativeDeclaration(input, lineNumber, 'MethodDefinition', 'method', `${className}.${match[1]}`, {
-      methodName: match[1],
-      owner: className,
-      parameters: splitParameters(match[2])
-    }, true));
-  }
-  return declarations;
-}
-
 export { scanJavaScriptLike };

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

@@ -0,0 +1,94 @@
+import { upperFirst } from './native-import-utils.js';
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters } from './native-region-scanner-core.js';
+import { braceBlockSpan } from './native-region-scanner-spans.js';
+
+function scanKotlin(input) {
+  const declarations = [];
+  const lines = sourceLines(input.sourceText);
+  const blockStack = [];
+  let braceDepth = 0;
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    const lineStartDepth = depthAfterLeadingClosers(trimmed, braceDepth);
+    while (blockStack.length && blockStack[blockStack.length - 1].bodyDepth > lineStartDepth) blockStack.pop();
+    let match;
+    if ((match = trimmed.match(/^package\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/))) {
+      declarations.push(nativeDeclaration(input, number, 'PackageHeader', 'package', match[1], {}, false));
+    } else if ((match = trimmed.match(/^import\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\.\*)?)(?:\s+as\s+[A-Za-z_]\w*)?$/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDirective', 'package'));
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual|open|final|abstract|sealed|data|value)\s+)*(?:(enum|annotation)\s+)?(class|interface|object)\s+([A-Za-z_]\w*)/))) {
+      const owner = nearestContainer(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, kotlinDeclarationKind(match[2], match[1]), kotlinSymbolKind(match[2], match[1]), name, owner ? { owner: owner.name } : {}, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: match[2], name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual|open|final|abstract|inline|tailrec|operator|infix|external|suspend|override)\s+)*fun\s+(?:<[^>]+>\s*)?(?:([A-Za-z_][\w.<>?]*)\.)?([A-Za-z_]\w*)\s*\(([^)]*)\)/))) {
+      const owner = nearestContainer(blockStack);
+      const receiverType = match[1];
+      const target = kotlinFunctionTarget(owner, receiverType, match[2]);
+      const hasBody = trimmed.includes('{') || trimmed.includes('=');
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', target.owner ? 'method' : 'function', target.name, {
+        parameters: splitParameters(match[3]),
+        methodName: match[2],
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {}),
+        ...(receiverType ? { receiverType } : {})
+      }, hasBody, {
+        ...spanOptions(input, lines, index, trimmed.includes('{')),
+        metadata: {
+          methodName: match[2],
+          ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {}),
+          ...(receiverType ? { receiverType } : {})
+        }
+      }));
+      if (trimmed.includes('{')) blockStack.push({ kind: 'function', name: target.name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual)\s+)*typealias\s+([A-Za-z_]\w*)\s*=/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypeAliasDeclaration', 'type', match[1], {}, false));
+    } else if ((match = trimmed.match(/^(?:(?:public|private|protected|internal|expect|actual|open|final|abstract|override|const|lateinit)\s+)*(?:val|var)\s+([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'PropertyDeclaration', 'variable', match[1], {}, false));
+    }
+    braceDepth = Math.max(0, braceDepth + braceDelta(line));
+  }
+  return declarations;
+}
+
+function spanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
+function depthAfterLeadingClosers(trimmed, depth) {
+  const closers = String(trimmed).match(/^}+/)?.[0].length ?? 0;
+  return Math.max(0, depth - closers);
+}
+
+function nearestContainer(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'function') return undefined;
+    if (blockStack[index].kind === 'class' || blockStack[index].kind === 'interface' || blockStack[index].kind === 'object') return blockStack[index];
+  }
+  return undefined;
+}
+
+function kotlinFunctionTarget(owner, receiverType, methodName) {
+  if (receiverType) return { name: `${receiverType}.extension.${methodName}`, owner: receiverType, receiverKind: 'extension' };
+  if (owner) return { name: `${owner.name}.${methodName}`, owner: owner.name, receiverKind: 'member' };
+  return { name: methodName };
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function kotlinDeclarationKind(kind, prefix) {
+  if (prefix === 'enum') return 'EnumClassDeclaration';
+  if (prefix === 'annotation') return 'AnnotationClassDeclaration';
+  return `${upperFirst(kind)}Declaration`;
+}
+
+function kotlinSymbolKind(kind, prefix) {
+  if (kind === 'interface') return 'interface';
+  if (kind === 'object') return 'module';
+  if (prefix === 'enum' || prefix === 'annotation') return 'type';
+  return 'class';
+}
+
+export { scanKotlin };

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

@@ -1,4 +1,4 @@
-import { idFragment, uniqueStrings, upperFirst } from './native-import-utils.js';
+import { idFragment } from './native-import-utils.js';
 import {
   nativeDeclaration,
   nativeImportDeclaration,
@@ -7,30 +7,16 @@ import {
   splitParameters,
   splitTypeParameters
 } from './native-region-scanner-core.js';
-
-function scanPython(input) {
-  const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim();
-    let match;
-    if ((match = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*:/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDef', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
-    } else if ((match = trimmed.match(/^class\s+([A-Za-z_]\w*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'ClassDef', 'class', match[1], {}, true));
-    } else if ((match = trimmed.match(/^(?:from\s+([A-Za-z_][\w.]*)\s+import\s+.+|import\s+([A-Za-z_][\w.]*))/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1] ?? match[2], 'Import', 'module'));
-    }
-  }
-  return declarations;
-}
+import { braceBlockSpan } from './native-region-scanner-spans.js';
 
 function scanRust(input) {
   const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  const lines = sourceLines(input.sourceText);
+  for (const [index, { line, number }] of lines.entries()) {
     const trimmed = line.trim();
     let match;
     if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'ItemFn', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, 'ItemFn', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{'), { span: trimmed.includes('{') ? braceBlockSpan(input, lines, index) : undefined }));
     } else if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)/))) {
       declarations.push(nativeDeclaration(input, number, 'ItemStruct', 'type', match[1], {}, trimmed.includes('{')));
     } else if ((match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)/))) {
@@ -52,7 +38,8 @@ function scanRust(input) {
 
 function scanCLike(input) {
   const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  const lines = sourceLines(input.sourceText);
+  for (const [index, { line, number }] of lines.entries()) {
     const trimmed = line.trim();
     let match;
     if ((match = trimmed.match(/^#\s*include\s+[<"]([^>"]+)[>"]/))) {
@@ -60,30 +47,11 @@ function scanCLike(input) {
     } else if ((match = trimmed.match(/^#\s*define\s+([A-Za-z_]\w*)/))) {
       declarations.push(nativeMacroLoss(input, number, trimmed, 'preprocessor', match[1]));
     } else if ((match = trimmed.match(/^typedef\s+struct(?:\s+([A-Za-z_]\w*))?/))) {
-      declarations.push(nativeDeclaration(input, number, 'TypedefStructDeclaration', 'type', match[1] ?? `anonymous_struct_${number}`, {}, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, 'TypedefStructDeclaration', 'type', match[1] ?? `anonymous_struct_${number}`, {}, trimmed.includes('{'), { span: trimmed.includes('{') ? braceBlockSpan(input, lines, index) : undefined }));
     } else if ((match = trimmed.match(/^(?:struct|enum)\s+([A-Za-z_]\w*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'TagDeclaration', 'type', match[1], {}, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, 'TagDeclaration', 'type', match[1], {}, trimmed.includes('{'), { span: trimmed.includes('{') ? braceBlockSpan(input, lines, index) : undefined }));
     } else if ((match = trimmed.match(/^(?:[A-Za-z_][\w\s*:&<>]+)\s+([A-Za-z_]\w*)\s*\(([^;{}]*)\)\s*(?:;|\{)?$/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.endsWith('{')));
-    }
-  }
-  return declarations;
-}
-
-function scanJava(input) {
-  const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim();
-    let match;
-    if ((match = trimmed.match(/^package\s+([A-Za-z_][\w.]*);/))) {
-      declarations.push(nativeDeclaration(input, number, 'PackageDeclaration', 'package', match[1], {}, false));
-    } else if ((match = trimmed.match(/^import\s+(?:static\s+)?([A-Za-z_][\w.*]*);/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDeclaration', 'package'));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|abstract|final|static|sealed|non-sealed)\s+)*(class|interface|enum|record|@interface)\s+([A-Za-z_$][\w$]*)/))) {
-      const kind = match[1] === '@interface' ? 'AnnotationDeclaration' : `${upperFirst(match[1])}Declaration`;
-      declarations.push(nativeDeclaration(input, number, kind, javaSymbolKind(match[1]), match[2], {}, trimmed.includes('{')));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|abstract|final|static|synchronized|native)\s+)*(?:<[^>]+>\s+)?[A-Za-z_$][\w$<>\[\].?,\s]*\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*(?:throws\s+[^{]+)?(?:\{|;)?$/))) {
-      declarations.push(nativeDeclaration(input, number, 'MethodDeclaration', 'method', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.endsWith('{'), { span: trimmed.endsWith('{') ? braceBlockSpan(input, lines, index) : undefined }));
     }
   }
   return declarations;
@@ -92,7 +60,8 @@ function scanJava(input) {
 function scanGo(input) {
   const declarations = [];
   let inImportBlock = false;
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  const lines = sourceLines(input.sourceText);
+  for (const [index, { line, number }] of lines.entries()) {
     const trimmed = line.trim();
     let match;
     if (inImportBlock) {
@@ -120,12 +89,12 @@ function scanGo(input) {
         receiver,
         typeParameters: splitTypeParameters(match[3]),
         parameters: splitParameters(match[4])
-      }, trimmed.includes('{')));
+      }, trimmed.includes('{'), { span: trimmed.includes('{') ? braceBlockSpan(input, lines, index) : undefined }));
     } else if ((match = trimmed.match(/^func\s+([A-Za-z_]\w*)(?:\s*\[([^\]]+)\])?\s*\(([^)]*)\)/))) {
       declarations.push(nativeDeclaration(input, number, 'FuncDecl', 'function', match[1], {
         typeParameters: splitTypeParameters(match[2]),
         parameters: splitParameters(match[3])
-      }, trimmed.includes('{')));
+      }, trimmed.includes('{'), { span: trimmed.includes('{') ? braceBlockSpan(input, lines, index) : undefined }));
     } else if ((match = trimmed.match(/^var\s+([A-Za-z_]\w*)\b/))) {
       declarations.push(nativeDeclaration(input, number, 'VarDecl', 'variable', match[1], {}, false));
     } else if ((match = trimmed.match(/^const\s+([A-Za-z_]\w*)\b/))) {
@@ -135,82 +104,6 @@ function scanGo(input) {
   return declarations;
 }
 
-function scanSwift(input) {
-  const declarations = [];
-  const protocols = new Set();
-  for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim();
-    const declarationLine = trimmed.replace(/^(?:@[A-Za-z_][\w.]+(?:\([^)]*\))?\s+)*/, '');
-    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*)/))) {
-      if (match[1] === 'protocol') protocols.add(match[2]);
-      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Decl`, swiftSymbolKind(match[1]), match[2], {}, declarationLine.includes('{')));
-    } 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[2]);
-      const isProtocolExtension = protocols.has(match[1]) || /Protocol$/.test(match[1]);
-      declarations.push(nativeDeclaration(input, number, isProtocolExtension ? 'ProtocolExtensionDecl' : 'ExtensionDecl', 'implementation', `${match[1]}.${isProtocolExtension ? 'protocolExtension' : 'extension'}`, {
-        extendedType: match[1],
-        ...extensionFields
-      }, declarationLine.includes('{')));
-    } 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*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDecl', 'function', unquoteSwiftIdentifier(match[1]), {
-        typeParameters: splitTypeParameters(match[2]),
-        parameters: splitParameters(match[3])
-      }, declarationLine.includes('{')));
-    } 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*([^={]+))?/))) {
-      declarations.push(nativeDeclaration(input, number, 'PropertyDecl', 'property', match[2], {
-        binding: match[1],
-        valueType: match[3]?.trim()
-      }, declarationLine.includes('{') || declarationLine.includes('=>')));
-    } else if ((match = declarationLine.match(/^(?:(?:public|private(?:\([^)]*\))?|fileprivate|internal|open)\s+)*typealias\s+([A-Za-z_]\w*)\b(?:\s*=\s*(.+))?/))) {
-      declarations.push(nativeDeclaration(input, number, 'TypealiasDecl', 'type', match[1], { target: match[2]?.trim() }, false));
-    }
-  }
-  return declarations;
-}
-
-function scanCSharp(input) {
-  const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim();
-    let match;
-    if ((match = trimmed.match(/^using\s+([A-Za-z_]\w*)\s*=\s*(.+?)\s*;/))) {
-      declarations.push(nativeDeclaration(input, number, 'UsingAliasDirective', 'type', match[1], { target: match[2].trim() }, false));
-    } else if ((match = trimmed.match(/^using\s+(?:static\s+)?([A-Za-z_][\w.]*)\s*;/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'UsingDirective', 'namespace'));
-    } else if ((match = trimmed.match(/^namespace\s+([A-Za-z_][\w.]*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'NamespaceDeclaration', 'namespace', match[1], {}, trimmed.includes('{')));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|unsafe|new)\s+)*delegate\s+(.+?)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*;/))) {
-      declarations.push(nativeDeclaration(input, number, 'DelegateDeclaration', 'type', match[2], {
-        returnType: match[1].trim(),
-        parameters: splitParameters(match[3])
-      }, false));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|abstract|sealed|static|partial|readonly|ref|unsafe)\s+)*(class|interface|struct|enum|record(?:\s+(?:class|struct))?)\s+([A-Za-z_]\w*)/))) {
-      declarations.push(nativeDeclaration(input, number, csharpDeclarationKind(match[1]), csharpSymbolKind(match[1]), match[2], { csharpKind: match[1].replace(/\s+/g, ' ') }, trimmed.includes('{')));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|virtual|override|async|partial|sealed|abstract|extern|new|unsafe|readonly)\s+)*(?:[A-Za-z_][\w<>\[\].?,\s]*\??|void)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:=>.*|\{|;)?$/))) {
-      const parameters = splitParameters(match[2]);
-      const extensionReceiver = csharpExtensionReceiver(parameters);
-      declarations.push(nativeDeclaration(input, number, extensionReceiver ? 'ExtensionMethodDeclaration' : 'MethodDeclaration', 'method', match[1], {
-        parameters,
-        ...(extensionReceiver ? { extensionReceiver } : {})
-      }, trimmed.includes('{') || trimmed.includes('=>')));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|virtual|override|abstract|sealed|new|unsafe)\s+)*event\s+(.+?)\s+([A-Za-z_]\w*)\s*(?:[;{=]|=>)/))) {
-      declarations.push(nativeDeclaration(input, number, 'EventDeclaration', 'event', match[2], {
-        eventType: match[1].trim(),
-        accessors: csharpAccessors(trimmed)
-      }, trimmed.includes('{')));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|internal|static|virtual|override|abstract|sealed|new|required|readonly|unsafe)\s+)*([A-Za-z_][\w<>\[\].?,\s]*\??)\s+([A-Za-z_]\w*)\s*(?:\{|=>)/))) {
-      declarations.push(nativeDeclaration(input, number, 'PropertyDeclaration', 'property', match[2], {
-        propertyType: match[1].trim(),
-        accessors: csharpAccessors(trimmed)
-      }, trimmed.includes('{') || trimmed.includes('=>')));
-    }
-  }
-  return declarations;
-}
-
 function parseGoReceiver(raw) {
   const value = String(raw ?? '').trim();
   const match = value.match(/^(?:(\w+)\s+)?(.+)$/);
@@ -235,67 +128,8 @@ function goReceiverMethodName(receiver, methodName) {
   return receiver?.type ? `${receiver.type}.${methodName}` : methodName;
 }
 
-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 javaSymbolKind(kind) {
-  if (kind === 'interface' || kind === '@interface') return 'interface';
-  if (kind === 'enum' || kind === 'record') return 'type';
-  return 'class';
-}
-
-function swiftSymbolKind(kind) {
-  if (kind === 'protocol') return 'protocol';
-  if (kind === 'extension') return 'implementation';
-  if (kind === 'struct' || kind === 'enum' || kind === 'actor') return 'type';
-  return 'class';
-}
-
-function csharpSymbolKind(kind) {
-  const normalized = String(kind).replace(/\s+/g, ' ');
-  if (normalized === 'interface') return 'interface';
-  if (normalized === 'struct' || normalized === 'enum' || normalized.startsWith('record')) return 'type';
-  return 'class';
-}
-
-function csharpDeclarationKind(kind) {
-  const normalized = String(kind).replace(/\s+/g, ' ');
-  if (normalized === 'record struct') return 'RecordStructDeclaration';
-  if (normalized === 'record class') return 'RecordClassDeclaration';
-  if (normalized === 'record') return 'RecordDeclaration';
-  return `${upperFirst(normalized)}Declaration`;
-}
-
-function csharpExtensionReceiver(parameters) {
-  const match = String(parameters?.[0] ?? '').match(/^this\s+(.+?)\s+([A-Za-z_]\w*)$/);
-  return match ? { type: match[1].trim(), name: match[2] } : undefined;
-}
-
-function csharpAccessors(source) {
-  return uniqueStrings([...String(source ?? '').matchAll(/\b(get|set|init|add|remove)\b/g)].map((match) => match[1]));
-}
-
 export {
   scanCLike,
-  scanCSharp,
   scanGo,
-  scanJava,
-  scanPython,
-  scanRust,
-  scanSwift
+  scanRust
 };