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

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

@@ -4,125 +4,22 @@ import {
   nativeImportDeclaration,
   nativeMacroLoss,
   sourceLines,
-  splitParameters,
-  splitTypeParameters
+  splitParameters
 } from './native-region-scanner-core.js';
-
-function scanPhp(input) {
-  const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim().replace(/^<\?php\s*/, '');
-    let match;
-    if ((match = trimmed.match(/^namespace\s+([A-Za-z_][\w\\]*)\s*;/))) {
-      declarations.push(nativeDeclaration(input, number, 'NamespaceDefinition', 'namespace', match[1], {}, false));
-    } else if ((match = trimmed.match(/^use\s+([A-Za-z_][\w\\]*)(?:\s+as\s+([A-Za-z_]\w*))?\s*;/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'UseDeclaration', 'namespace'));
-    } else if ((match = trimmed.match(/^(?:(?:abstract|final|readonly)\s+)*(class|interface|trait|enum)\s+([A-Za-z_]\w*)/))) {
-      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Declaration`, phpSymbolKind(match[1]), match[2], {}, trimmed.includes('{')));
-    } else if ((match = trimmed.match(/^(?:(?:public|protected|private|static|final|abstract)\s+)*function\s+&?\s*([A-Za-z_]\w*)\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
-    }
-  }
-  return declarations;
-}
-
-function scanRuby(input) {
-  const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim();
-    let match;
-    if ((match = trimmed.match(/^(?:require|load)\s+['"]([^'"]+)['"]/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'Require', 'module'));
-    } else if ((match = trimmed.match(/^module\s+([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'Module', 'module', match[1], {}, true));
-    } else if ((match = trimmed.match(/^class\s+([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'Class', 'class', match[1], {}, true));
-    } else if ((match = trimmed.match(/^def\s+(?:self\.)?([A-Za-z_]\w*[!?=]?)\s*(?:\(([^)]*)\)|([^#=]*))?/))) {
-      declarations.push(nativeDeclaration(input, number, 'Def', 'method', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, true));
-    }
-  }
-  return declarations;
-}
-
-function scanKotlin(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*(?:\.[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*)/))) {
-      declarations.push(nativeDeclaration(input, number, kotlinDeclarationKind(match[2], match[1]), kotlinSymbolKind(match[2], match[1]), match[3], {}, trimmed.includes('{')));
-    } 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*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{') || trimmed.includes('=')));
-    } 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));
-    }
-  }
-  return declarations;
-}
-
-function scanScala(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*(?:\.[A-Za-z_]\w*)*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'PackageClause', 'package', match[1], {}, false));
-    } else if ((match = trimmed.match(/^import\s+(.+?);?$/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1].trim(), 'Import', 'package'));
-    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|sealed|abstract|case|implicit|lazy|override|inline|transparent|open)\s+)*(class|trait|object|enum)\s+([A-Za-z_]\w*)/))) {
-      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Def`, scalaSymbolKind(match[1]), match[2], {}, trimmed.includes('{') || trimmed.includes(':')));
-    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|implicit|override|inline)\s+)*def\s+([A-Za-z_]\w*)\s*(?:\[[^\]]+\])?\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'DefDef', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{') || trimmed.includes('=')));
-    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|implicit|opaque)\s+)*type\s+([A-Za-z_]\w*)\b/))) {
-      declarations.push(nativeDeclaration(input, number, 'TypeDef', 'type', match[1], {}, false));
-    } else if ((match = trimmed.match(/^(?:(?:private|protected|final|implicit|lazy|override|inline)\s+)*(?:val|var)\s+([A-Za-z_]\w*)\b/))) {
-      declarations.push(nativeDeclaration(input, number, 'ValDef', 'variable', match[1], {}, false));
-    }
-  }
-  return declarations;
-}
-
-function scanDart(input) {
-  const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim();
-    let match;
-    if ((match = trimmed.match(/^(?:import|export)\s+['"]([^'"]+)['"]/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'UriBasedDirective', 'library'));
-    } else if ((match = trimmed.match(/^part\s+['"]([^'"]+)['"]/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'PartDirective', 'library'));
-    } else if ((match = trimmed.match(/^(?:(?:abstract|base|final|interface|sealed)\s+)*(class|mixin|enum)\s+([A-Za-z_]\w*)/))) {
-      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Declaration`, dartSymbolKind(match[1]), match[2], {}, trimmed.includes('{')));
-    } else if ((match = trimmed.match(/^extension\s+([A-Za-z_]\w*)\s+on\s+.+\{/))) {
-      declarations.push(nativeDeclaration(input, number, 'ExtensionDeclaration', 'implementation', match[1], {}, true));
-    } else if ((match = trimmed.match(/^typedef\s+([A-Za-z_]\w*)\b/))) {
-      declarations.push(nativeDeclaration(input, number, 'TypeAlias', 'type', match[1], {}, false));
-    } else if ((match = trimmed.match(/^(?:(?:external|static)\s+)*(?:[A-Za-z_]\w*(?:<[^>]+>)?\??|void)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:async\s*)?(?:\{|=>|;)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{') || trimmed.includes('=>')));
-    } else if ((match = trimmed.match(/^(?:(?:static|external|late)\s+)*(?:const|final|var)\s+(?:[A-Za-z_]\w*(?:<[^>]+>)?\??\s+)?([A-Za-z_]\w*)\b/))) {
-      declarations.push(nativeDeclaration(input, number, 'VariableDeclaration', 'variable', match[1], {}, false));
-    }
-  }
-  return declarations;
-}
+import { braceBlockSpan, endKeywordBlockSpan, sqlStatementSpan } from './native-region-scanner-spans.js';
 
 function scanLua(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(/^(?:local\s+[A-Za-z_]\w*\s*=\s*)?require\s*\(?\s*['"]([^'"]+)['"]\s*\)?/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1], 'RequireCall', 'module'));
     } else if ((match = trimmed.match(/^(?:local\s+)?function\s+([A-Za-z_]\w*(?:[.:][A-Za-z_]\w*)*)\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, true, endSpanOptions(input, lines, index)));
     } else if ((match = trimmed.match(/^(?:local\s+)?([A-Za-z_]\w*(?:[.:][A-Za-z_]\w*)*)\s*=\s*function\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionAssignment', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+      declarations.push(nativeDeclaration(input, number, 'FunctionAssignment', 'function', match[1], { parameters: splitParameters(match[2]) }, true, endSpanOptions(input, lines, index)));
     } else if ((match = trimmed.match(/^local\s+([A-Za-z_]\w*)\s*=\s*(?:\{|\w+)/))) {
       declarations.push(nativeDeclaration(input, number, 'LocalDeclaration', 'variable', match[1], {}, false));
     }
@@ -132,15 +29,16 @@ function scanLua(input) {
 
 function scanShell(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(/^(?:source|\.)\s+(?:"([^"]+)"|'([^']+)'|([./A-Za-z0-9_-][\w./-]*))(?:\s|$)/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1] ?? match[2] ?? match[3], 'SourceCommand', 'file'));
     } else if ((match = trimmed.match(/^function\s+([A-Za-z_][\w-]*)\s*(?:\(\s*\))?\s*(?:\{|$)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], {}, true));
+      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], {}, true, spanOptions(input, lines, index, trimmed.includes('{'))));
     } else if ((match = trimmed.match(/^([A-Za-z_][\w-]*)\s*\(\s*\)\s*(?:\{|$)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], {}, true));
+      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], {}, true, spanOptions(input, lines, index, trimmed.includes('{'))));
     } else if ((match = trimmed.match(/^(?:export\s+)?(?:readonly\s+)?([A-Za-z_]\w*)=/))) {
       declarations.push(nativeDeclaration(input, number, 'VariableAssignment', 'variable', match[1], {}, false));
     } else if ((match = trimmed.match(/^alias\s+([A-Za-z_][\w-]*)=/))) {
@@ -152,14 +50,15 @@ function scanShell(input) {
 
 function scanSql(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(/^CREATE\s+EXTENSION\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$-]*))/i))) {
       declarations.push(nativeImportDeclaration(input, number, normalizeSqlIdentifier(match[1]), 'CreateExtensionStatement', 'extension'));
     } else if ((match = trimmed.match(/^CREATE\s+(?:OR\s+REPLACE\s+)?(?:TEMP(?:ORARY)?\s+)?((?:UNIQUE\s+)?INDEX|MATERIALIZED\s+VIEW|TABLE|VIEW|FUNCTION|PROCEDURE|TRIGGER|SCHEMA|TYPE)\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*))?)/i))) {
       const objectKind = match[1].toUpperCase().replace(/\s+/g, ' ');
-      declarations.push(nativeDeclaration(input, number, sqlLanguageKind(objectKind), sqlSymbolKind(objectKind), normalizeSqlIdentifier(match[2]), { objectKind }, trimmed.includes('(')));
+      declarations.push(nativeDeclaration(input, number, sqlLanguageKind(objectKind), sqlSymbolKind(objectKind), normalizeSqlIdentifier(match[2]), { objectKind }, trimmed.includes('('), { span: sqlStatementSpan(input, lines, index) }));
     }
   }
   return declarations;
@@ -167,7 +66,8 @@ function scanSql(input) {
 
 function scanZig(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|export)\s+)?(?:const|var)\s+([A-Za-z_]\w*)\s*=\s*@import\(\s*["']([^"']+)["']\s*\)\s*;?/))) {
@@ -175,9 +75,9 @@ function scanZig(input) {
     } else if ((match = trimmed.match(/^(?:(?:pub|export)\s+)?usingnamespace\s+@import\(\s*["']([^"']+)["']\s*\)\s*;?/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1], 'UsingNamespaceImport', 'module'));
     } else if ((match = trimmed.match(/^(?:(?:pub|export)\s+)?const\s+([A-Za-z_]\w*)\s*=\s*(?:extern\s+)?(struct|enum|union|opaque|error)\b/))) {
-      declarations.push(nativeDeclaration(input, number, `Const${upperFirst(match[2])}Declaration`, 'type', match[1], { zigKind: match[2] }, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, `Const${upperFirst(match[2])}Declaration`, 'type', match[1], { zigKind: match[2] }, trimmed.includes('{'), spanOptions(input, lines, index, trimmed.includes('{'))));
     } else if ((match = trimmed.match(/^(?:(?:pub|export|extern|inline)\s+)*(?:fn)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FnDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, 'FnDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{'), spanOptions(input, lines, index, trimmed.includes('{'))));
     } else if ((match = trimmed.match(/^(?:(?:pub|export)\s+)?const\s+([A-Za-z_]\w*)\b/))) {
       declarations.push(nativeDeclaration(input, number, 'ConstDeclaration', 'constant', match[1], {}, false));
     } else if ((match = trimmed.match(/^(?:(?:pub|export)\s+)?var\s+([A-Za-z_]\w*)\b/))) {
@@ -190,37 +90,12 @@ function scanZig(input) {
   return declarations;
 }
 
-function phpSymbolKind(kind) {
-  if (kind === 'interface') return 'interface';
-  if (kind === 'trait') return 'trait';
-  if (kind === 'enum') return 'type';
-  return 'class';
-}
-
-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';
-}
-
-function scalaSymbolKind(kind) {
-  if (kind === 'trait') return 'trait';
-  if (kind === 'object') return 'module';
-  if (kind === 'enum') return 'type';
-  return 'class';
+function spanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
 }
 
-function dartSymbolKind(kind) {
-  if (kind === 'mixin') return 'trait';
-  if (kind === 'enum') return 'type';
-  return 'class';
+function endSpanOptions(input, lines, index) {
+  return { span: endKeywordBlockSpan(input, lines, index) };
 }
 
 function sqlSymbolKind(kind) {
@@ -247,12 +122,7 @@ function zigMetaName(source) {
 }
 
 export {
-  scanDart,
-  scanKotlin,
   scanLua,
-  scanPhp,
-  scanRuby,
-  scanScala,
   scanShell,
   scanSql,
   scanZig

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

@@ -6,17 +6,19 @@ import {
   sourceLines,
   splitParameters
 } from './native-region-scanner-core.js';
+import { braceBlockSpan, endKeywordBlockSpan, pythonBlockSpan, terminatedBlockSpan } from './native-region-scanner-spans.js';
 
 function scanElixir(input) {
   const declarations = [];
   let currentModule;
-  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;
     let recordedMeta = false;
     if ((match = trimmed.match(/^defmodule\s+([A-Z]\w*(?:\.[A-Z]\w*)*)\s+do\b/))) {
       currentModule = match[1];
-      declarations.push(nativeDeclaration(input, number, 'ModuleDefinition', 'module', match[1], {}, true));
+      declarations.push(nativeDeclaration(input, number, 'ModuleDefinition', 'module', match[1], {}, true, endSpanOptions(input, lines, index)));
     } else if ((match = trimmed.match(/^(?:alias|import|require)\s+([A-Z]\w*(?:\.[A-Z]\w*)*)/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDirective', 'module'));
     } else if ((match = trimmed.match(/^use\s+([A-Z]\w*(?:\.[A-Z]\w*)*)/))) {
@@ -26,7 +28,8 @@ function scanElixir(input) {
       declarations.push(nativeMacroLoss(input, number, trimmed, 'macroExpansion', match[2]));
       recordedMeta = true;
     } else if ((match = trimmed.match(/^defp?\s+([A-Za-z_]\w*[!?]?)\s*(?:\(([^)]*)\)|([^,]*))?/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, /\bdo\b/.test(trimmed)));
+      const hasDoBlock = /\bdo\b/.test(trimmed);
+      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, hasDoBlock, hasDoBlock ? endSpanOptions(input, lines, index) : {}));
     } else if (trimmed.startsWith('defstruct')) {
       declarations.push(nativeDeclaration(input, number, 'StructDefinition', 'type', currentModule ?? `struct_${number}`, {}, true));
     } else if ((match = trimmed.match(/^@(type|typep|opaque|callback)\s+([A-Za-z_]\w*[!?]?)/))) {
@@ -39,10 +42,19 @@ function scanElixir(input) {
   return declarations;
 }
 
+function endSpanOptions(input, lines, index) {
+  return { span: endKeywordBlockSpan(input, lines, index) };
+}
+
+function braceSpanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
 function scanErlang(input) {
   const declarations = [];
   const seenFunctions = new Set();
-  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;
     let recordedMacro = false;
@@ -70,7 +82,7 @@ function scanErlang(input) {
       const name = erlangAtomName(match[1]);
       if (!seenFunctions.has(name)) {
         seenFunctions.add(name);
-        declarations.push(nativeDeclaration(input, number, 'FunctionClause', 'function', name, { parameters: splitParameters(match[2]) }, true));
+        declarations.push(nativeDeclaration(input, number, 'FunctionClause', 'function', name, { parameters: splitParameters(match[2]) }, true, { span: terminatedBlockSpan(input, lines, index, /\.\s*$/) }));
       }
     }
     if (!recordedMacro && /(^|[^A-Za-z0-9_])\?[A-Za-z_]\w*/.test(trimmed)) {
@@ -83,7 +95,8 @@ function scanErlang(input) {
 function scanHaskell(input) {
   const declarations = [];
   const seenFunctions = new Set();
-  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 (/^#\s*(?:if|ifdef|ifndef|else|elif|endif|define|include)\b/.test(trimmed)) {
@@ -106,12 +119,15 @@ function scanHaskell(input) {
     } else if ((match = trimmed.match(/^class\s+(?:\([^)]*\)\s*=>\s*)?([A-Z][A-Za-z0-9_']*)\b/))) {
       declarations.push(nativeDeclaration(input, number, 'ClassDeclaration', 'type', match[1], {}, /\bwhere\b/.test(trimmed)));
     } else if ((match = trimmed.match(/^([a-z_][A-Za-z0-9_']*)\s*::\s*(.+)$/))) {
-      seenFunctions.add(match[1]);
-      declarations.push(nativeDeclaration(input, number, 'FunctionSignature', 'function', match[1], { signature: match[2].trim() }, false));
+      declarations.push(nativeDeclaration(input, number, 'FunctionSignature', 'function', match[1], { signature: match[2].trim() }, false, {
+        regionKind: 'declaration',
+        symbolId: `symbol:${input.language}:signature:${idFragment(match[1])}`,
+        metadata: { signatureOnly: true }
+      }));
     } else if ((match = trimmed.match(/^([a-z_][A-Za-z0-9_']*)\b[^=]*=/))) {
       if (!seenFunctions.has(match[1])) {
         seenFunctions.add(match[1]);
-        declarations.push(nativeDeclaration(input, number, 'FunctionBinding', 'function', match[1], {}, true));
+        declarations.push(nativeDeclaration(input, number, 'FunctionBinding', 'function', match[1], {}, true, { span: pythonBlockSpan(input, lines, index) }));
       }
     }
   }
@@ -120,7 +136,8 @@ function scanHaskell(input) {
 
 function scanR(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(/^(?:library|require)\s*\(\s*["']?([A-Za-z_][\w.-]*)["']?/))) {
@@ -130,7 +147,7 @@ function scanR(input) {
     } else if ((match = trimmed.match(/^source\s*\(\s*["']([^"']+)["']/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1], 'SourceCall', 'module'));
     } else if ((match = trimmed.match(/^([A-Za-z_][\w.]*)\s*(?:<-|=)\s*function\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionAssignment', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, 'FunctionAssignment', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{'), braceSpanOptions(input, lines, index, trimmed.includes('{'))));
     } else if ((match = trimmed.match(/^([A-Za-z_][\w.]*)\s*<-\s*R6Class\s*\(\s*["']([^"']+)["']/))) {
       declarations.push(nativeDeclaration(input, number, 'R6ClassDeclaration', 'class', match[2] || match[1], { binding: match[1] }, true));
       declarations.push(nativeMacroLoss(input, number, trimmed, 'dynamicRuntime', match[2] || match[1]));
@@ -154,9 +171,19 @@ function scanR(input) {
 }
 
 function scanGenericDeclarations(input) {
-  return sourceLines(input.sourceText)
+  const lines = sourceLines(input.sourceText);
+  return lines
+    .map(({ line, number }, index) => ({ line, number, index }))
     .filter(({ line }) => /\b(function|class|struct|enum|trait|interface|def)\b/.test(line))
-    .map(({ line, number }) => nativeDeclaration(input, number, 'NativeDeclaration', 'variable', idFragment(line.trim()).slice(0, 40), { source: line.trim() }, true));
+    .map(({ line, number, index }) => nativeDeclaration(input, number, 'NativeDeclaration', 'variable', idFragment(line.trim()).slice(0, 40), { source: line.trim() }, true, genericSpanOptions(input, lines, index)));
+}
+
+function genericSpanOptions(input, lines, index) {
+  const line = lines[index]?.line.trim() ?? '';
+  if (line.includes('{')) return { span: braceBlockSpan(input, lines, index) };
+  if (/\b(?:class|module|def|function)\b/.test(line)) return { span: endKeywordBlockSpan(input, lines, index) };
+  if (/:\s*$/.test(line)) return { span: pythonBlockSpan(input, lines, index) };
+  return {};
 }
 
 function elixirMetaName(source) {

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

@@ -0,0 +1,97 @@
+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 scanJava(input) {
+  const declarations = [];
+  const blockStack = [];
+  const lines = sourceLines(input.sourceText);
+  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.]*);/))) {
+      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 owner = nearestType(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      const kind = match[2] === '@interface' ? 'AnnotationDeclaration' : `${upperFirst(match[2])}Declaration`;
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, kind, javaSymbolKind(match[2]), name, {
+        modifiers: javaModifiers(match[1]),
+        ...(owner ? { owner: owner.name } : {})
+      }, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: javaTypeStackKind(match[2]), name, bodyDepth: braceDepth + 1 });
+    } 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+[^{]+)?(?:\{.*|;)?$/))) {
+      const owner = nearestType(blockStack);
+      const target = javaMethodTarget(owner, match[1], match[3]);
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, 'MethodDeclaration', target.owner ? 'method' : 'function', target.name, {
+        methodName: match[3],
+        modifiers: javaModifiers(match[1]),
+        typeParameters: splitTypeParameters(match[2]),
+        parameters: splitParameters(match[4]),
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+      }, hasBody, {
+        ...spanOptions(input, lines, index, hasBody),
+        metadata: {
+          methodName: match[3],
+          modifiers: javaModifiers(match[1]),
+          ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+        }
+      }));
+      if (hasBody) blockStack.push({ kind: 'method', name: target.name, bodyDepth: braceDepth + 1 });
+    }
+    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 nearestType(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'method') return undefined;
+    if (['class', 'interface', 'enum', 'record', 'annotation'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function javaMethodTarget(owner, modifiers, methodName) {
+  if (!owner) return { name: methodName };
+  const receiverKind = /\bstatic\b/.test(modifiers) ? 'static' : 'member';
+  return { name: receiverKind === 'static' ? `${owner.name}.static.${methodName}` : `${owner.name}.${methodName}`, owner: owner.name, receiverKind };
+}
+
+function javaModifiers(raw) {
+  return splitParameters(String(raw ?? '').trim().replace(/\s+/g, ','));
+}
+
+function javaTypeStackKind(kind) {
+  if (kind === '@interface') return 'annotation';
+  return String(kind).replace(/\s+/g, ' ');
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function javaSymbolKind(kind) {
+  if (kind === 'interface' || kind === '@interface') return 'interface';
+  if (kind === 'enum' || kind === 'record') return 'type';
+  return 'class';
+}
+
+export { scanJava };

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

@@ -0,0 +1,100 @@
+import { jsControlKeyword, nativeDeclaration, nativeSignatureDeclaration, splitParameters } from './native-region-scanner-core.js';
+import { jsInitializerKind, jsVariableHasBody } from './native-region-scanner-js-helpers.js';
+
+function jsClassMemberDeclaration(input, lineNumber, declarationLine, className) {
+  const method = jsClassMethodMatch(declarationLine);
+  if (method && !jsControlKeyword(method.name)) return jsClassMethodDeclaration(input, lineNumber, method, className);
+  const property = jsClassPropertyMatch(declarationLine);
+  if (!property || jsControlKeyword(property.name)) return undefined;
+  return jsClassPropertyDeclaration(input, lineNumber, property, className);
+}
+
+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 = [];
+  const pattern = /((?:(?: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;
+  for (const match of body.matchAll(pattern)) {
+    const method = { modifiers: match[1], name: match[2], parameters: match[3], source: match[0] };
+    if (!jsControlKeyword(method.name)) declarations.push(jsClassMethodDeclaration(input, lineNumber, method, className));
+  }
+  return declarations;
+}
+
+function jsClassMethodMatch(declarationLine) {
+  const 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*[^={]+)?(?:\{|=>|$)/);
+  if (!match) return undefined;
+  return { modifiers: match[1], name: match[2], parameters: match[3], source: declarationLine };
+}
+
+function jsClassPropertyMatch(declarationLine) {
+  const match = declarationLine.match(/^((?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*)(#?[A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/);
+  if (!match) return undefined;
+  return { modifiers: match[1], name: match[2], source: declarationLine, valueType: match[3]?.trim() };
+}
+
+function jsClassMethodDeclaration(input, lineNumber, method, className) {
+  const target = jsClassMemberTarget(className, method.modifiers, method.name);
+  const hasBody = String(method.source ?? '').includes('{') || String(method.source ?? '').includes('=>');
+  return (hasBody ? nativeDeclaration : nativeSignatureDeclaration)(input, lineNumber, 'MethodDefinition', 'method', target.name, {
+    methodName: method.name,
+    owner: className,
+    receiverKind: target.receiverKind,
+    accessorKind: jsAccessorKind(method.modifiers),
+    modifiers: jsModifiers(method.modifiers),
+    parameters: splitParameters(method.parameters)
+  }, hasBody, { metadata: jsClassMemberMetadata(className, target, method.name, method.modifiers) });
+}
+
+function jsClassPropertyDeclaration(input, lineNumber, property, className) {
+  const initializerKind = jsInitializerKind(property.source ?? '', property.name);
+  const hasBody = jsVariableHasBody(initializerKind, property.source ?? '');
+  const target = jsClassMemberTarget(className, property.modifiers, property.name);
+  return nativeDeclaration(input, lineNumber, 'PropertyDefinition', initializerKind === 'function' ? 'function' : 'property', target.name, {
+    propertyName: property.name,
+    owner: className,
+    receiverKind: target.receiverKind,
+    valueType: property.valueType,
+    initializerKind,
+    modifiers: jsModifiers(property.modifiers)
+  }, hasBody, {
+    regionKind: initializerKind === 'function' ? 'body' : 'property',
+    metadata: {
+      initializerKind,
+      ...jsClassMemberMetadata(className, target, property.name, property.modifiers)
+    }
+  });
+}
+
+function jsClassMemberTarget(className, modifiers, memberName) {
+  const receiverKind = /\bstatic\b/.test(modifiers) ? 'static' : 'member';
+  return {
+    name: receiverKind === 'static' ? `${className}.static.${memberName}` : `${className}.${memberName}`,
+    receiverKind
+  };
+}
+
+function jsClassMemberMetadata(owner, target, memberName, modifiers) {
+  return {
+    owner,
+    receiverKind: target.receiverKind,
+    propertyName: memberName,
+    methodName: memberName,
+    modifiers: jsModifiers(modifiers),
+    accessorKind: jsAccessorKind(modifiers)
+  };
+}
+
+function jsAccessorKind(modifiers) {
+  if (/\bget\b/.test(modifiers)) return 'get';
+  if (/\bset\b/.test(modifiers)) return 'set';
+  return undefined;
+}
+
+function jsModifiers(raw) {
+  return String(raw ?? '').trim().split(/\s+/).filter(Boolean);
+}
+
+export { jsClassMemberDeclaration, jsInlineClassMemberDeclarations };