@shapeshift-labs/frontier-lang-compiler 0.2.59 → 0.2.60

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

@@ -109,6 +109,18 @@ export function createLightweightNativeImport(input) {
   occurrences.push(...dependencies.occurrences);
   relations.push(...dependencies.relations);
   facts.push(...dependencies.facts);
+  for (const occurrence of dependencies.occurrences) {
+    mappings.push({
+      id: `map_${idFragment(occurrence.id)}`,
+      nativeAstNodeId: occurrence.nativeAstNodeId,
+      semanticSymbolId: occurrence.symbolId,
+      semanticOccurrenceId: occurrence.id,
+      sourceSpan: occurrence.span,
+      evidenceIds: [evidenceId],
+      lossIds: [],
+      precision: 'line'
+    });
+  }
   losses.push(...lightweightCoverageLosses(input, declarations, input.sourcePreservation));
 
   const semanticIndex = createSemanticIndexRecord({

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

@@ -48,7 +48,7 @@ export function createLightweightSemanticLayers(input) {
     })),
     evaluationModels: [evaluationModel(input, evidenceIds)],
     effectRegions: effectRegions(input, evidenceIds),
-    loweringRecords: mappings.slice(0, 40).map((mapping) => ({
+    loweringRecords: mappings.map((mapping) => ({
       id: `lowering_${mapping.id}`,
       kind: 'nativeSourceToFrontierSemanticIndex',
       sourceMapId: mapping.sourceMapId,

package/dist/lightweight-dependency-language.js

@@ -0,0 +1,223 @@
+const ignoredIdentifiers = new Set([
+  'abstract', 'alias', 'and', 'as', 'async', 'await', 'break', 'case', 'catch',
+  'class', 'const', 'continue', 'def', 'default', 'defer', 'delete', 'do',
+  'else', 'enum', 'export', 'extends', 'false', 'finally', 'fn', 'for', 'from',
+  'func', 'function', 'if', 'impl', 'import', 'in', 'interface', 'let', 'match',
+  'mod', 'module', 'namespace', 'new', 'nil', 'none', 'not', 'null', 'or',
+  'package', 'pass', 'protocol', 'pub', 'public', 'return', 'self', 'static',
+  'struct', 'super', 'switch', 'this', 'throw', 'trait', 'true', 'try', 'type',
+  'undefined', 'use', 'using', 'var', 'void', 'while', 'with', 'yield'
+]);
+
+export function dependencyIdentifiers(input, declaration, line) {
+  const identifiers = new Set();
+  addIdentifier(identifiers, declaration.name);
+  for (const part of splitIdentifierPath(declaration.name)) addIdentifier(identifiers, part);
+  for (const field of ['methodName', 'propertyName', 'owner']) addIdentifier(identifiers, declaration.fields?.[field]);
+  if (declaration.role === 'import') {
+    for (const identifier of importLineIdentifiers(input, line)) addIdentifier(identifiers, identifier);
+    for (const identifier of importPathIdentifiers(declaration.importPath ?? declaration.name)) addIdentifier(identifiers, identifier);
+  }
+  return [...identifiers];
+}
+
+export function addIdentifier(set, value) {
+  if (isDependencyIdentifier(value)) set.add(String(value));
+}
+
+export function isDependencyIdentifier(value) {
+  const text = String(value ?? '');
+  return /^[A-Za-z_$][\w$]*$/.test(text) && !ignoredIdentifiers.has(text.toLowerCase());
+}
+
+export function dependencyScanRanges(input, declarations, lines) {
+  const ordered = [...(declarations ?? [])].sort((left, right) => (left.span?.startLine ?? 0) - (right.span?.startLine ?? 0));
+  return ordered
+    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
+    .map((declaration, index) => ({
+      declaration,
+      startLine: declaration.span?.startLine ?? 1,
+      endLine: dependencyScanEndLine(input, declaration, lines, ordered[index + 1]?.span?.startLine)
+    }));
+}
+
+export function maskDependencyLine(input, line, state) {
+  const language = String(input.language ?? '').toLowerCase();
+  const text = String(line ?? '');
+  let output = '';
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (state.inBlockComment) {
+      output += ' ';
+      if (char === '*' && next === '/') {
+        output += ' ';
+        index += 1;
+        state.inBlockComment = false;
+      }
+      continue;
+    }
+    if (quote) {
+      output += ' ';
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      output += '  ';
+      index += 1;
+      state.inBlockComment = true;
+      continue;
+    }
+    if (startsLineComment(language, char, next, text, index)) break;
+    if (char === '\'' || char === '"' || char === '`') {
+      output += ' ';
+      quote = char;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+export function emptyDependencySummary() {
+  return { total: 0, calls: 0, uses: 0 };
+}
+
+function importLineIdentifiers(input, line) {
+  const language = String(input.language ?? '').toLowerCase();
+  const source = String(line ?? '').trim();
+  if (language === 'python') return pythonImportIdentifiers(source);
+  if (language === 'rust') return rustImportIdentifiers(source);
+  if (language === 'go') return aliasedPathImportIdentifiers(source);
+  if (language === 'javascript' || language === 'typescript') return jsImportIdentifiers(source);
+  if (language === 'haskell') return haskellImportIdentifiers(source);
+  return aliasedPathImportIdentifiers(source);
+}
+
+function jsImportIdentifiers(source) {
+  const identifiers = [];
+  let match = source.match(/^import\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+[^,{]+,\s*\{([^}]+)\}\s+from\b|^import\s+\{([^}]+)\}\s+from\b/);
+  if (match) identifiers.push(...namedImportIdentifiers(match[1] ?? match[2]));
+  return identifiers;
+}
+
+function pythonImportIdentifiers(source) {
+  const identifiers = [];
+  const importMatch = source.match(/^import\s+(.+)$/);
+  if (importMatch) identifiers.push(...commaParts(importMatch[1]).map((part) => part.split(/\s+as\s+/i).pop()));
+  const fromMatch = source.match(/^from\s+\S+\s+import\s+(.+)$/);
+  if (fromMatch) identifiers.push(...namedImportIdentifiers(fromMatch[1]));
+  return identifiers;
+}
+
+function rustImportIdentifiers(source) {
+  const match = source.match(/^use\s+(.+?);?$/);
+  if (!match) return [];
+  const raw = match[1].replace(/[{}]/g, ' ');
+  return raw.split(/::|,|\s+as\s+/i).map((part) => part.trim()).filter(Boolean);
+}
+
+function haskellImportIdentifiers(source) {
+  const match = source.match(/^import\s+(?:qualified\s+)?([A-Za-z_][\w.]*)(?:\s+as\s+([A-Za-z_]\w*))?/);
+  return match ? [match[2], ...splitIdentifierPath(match[1])].filter(Boolean) : [];
+}
+
+function aliasedPathImportIdentifiers(source) {
+  const alias = source.match(/^(?:import|using|use)\s+([A-Za-z_$][\w$]*)\s*=/)?.[1]
+    ?? source.match(/^(?:import|using|use)\s+([A-Za-z_$][\w$]*)\s+["']/)?.[1]
+    ?? source.match(/\bas\s+([A-Za-z_$][\w$]*)\b/)?.[1];
+  return alias ? [alias] : [];
+}
+
+function namedImportIdentifiers(raw) {
+  return commaParts(raw).map((part) => part.trim().split(/\s+as\s+/i).pop()?.trim()).filter(Boolean);
+}
+
+function importPathIdentifiers(value) {
+  return splitIdentifierPath(String(value ?? '').replace(/['";]/g, ''));
+}
+
+function splitIdentifierPath(value) {
+  return String(value ?? '').split(/[^A-Za-z0-9_$]+/).filter(isDependencyIdentifier);
+}
+
+function commaParts(raw) {
+  return String(raw ?? '').split(',').map((part) => part.trim()).filter(Boolean);
+}
+
+function dependencyScanEndLine(input, declaration, lines, nextStartLine) {
+  const startLine = declaration.span?.startLine ?? 1;
+  if (!declaration.metadata?.hasBody) return startLine;
+  if (usesIndentationBlocks(input)) {
+    return indentationRegionEndLine(lines, startLine);
+  }
+  const balancedEnd = balancedRegionEndLine(lines, startLine);
+  const fallbackEnd = nextStartLine ? nextStartLine - 1 : lines.length;
+  return Math.max(startLine, Math.min(balancedEnd > startLine ? balancedEnd : fallbackEnd, lines.length));
+}
+
+function usesIndentationBlocks(input) {
+  return ['python'].includes(String(input.language ?? '').toLowerCase());
+}
+
+function indentationRegionEndLine(lines, startLine) {
+  const header = lines[startLine - 1]?.line ?? '';
+  const baseIndent = indentationWidth(header);
+  let lastBodyLine = startLine;
+  let sawBodyLine = false;
+  for (let index = startLine; index < lines.length; index += 1) {
+    const line = lines[index]?.line ?? '';
+    if (!line.trim()) {
+      if (sawBodyLine) lastBodyLine = index + 1;
+      continue;
+    }
+    const indent = indentationWidth(line);
+    if (indent <= baseIndent) return Math.max(startLine, lastBodyLine);
+    sawBodyLine = true;
+    lastBodyLine = index + 1;
+  }
+  return lastBodyLine;
+}
+
+function indentationWidth(line) {
+  let width = 0;
+  for (const char of String(line ?? '')) {
+    if (char === ' ') width += 1;
+    else if (char === '\t') width += 4;
+    else break;
+  }
+  return width;
+}
+
+function balancedRegionEndLine(lines, startLine) {
+  const state = { inBlockComment: false };
+  let depth = 0;
+  let opened = false;
+  for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
+    for (const char of maskDependencyLine({ language: 'javascript' }, lines[index].line, state)) {
+      if (char === '{' || char === '[' || char === '(') {
+        depth += 1;
+        opened = true;
+      } else if (char === '}' || char === ']' || char === ')') {
+        depth -= 1;
+      }
+    }
+    if (opened && depth <= 0) return lines[index].number;
+  }
+  return startLine;
+}
+
+function startsLineComment(language, char, next, text, index) {
+  if (char === '/' && next === '/') return true;
+  if (char === '#' && !['csharp'].includes(language)) return true;
+  if (char === '-' && next === '-' && ['sql', 'haskell', 'lua'].includes(language)) return true;
+  return text.startsWith('rem ', index) && language === 'shell';
+}

package/dist/lightweight-dependency-relations.js

@@ -1,23 +1,20 @@
 import { idFragment } from './native-import-utils.js';
+import {
+  addIdentifier,
+  dependencyIdentifiers,
+  dependencyScanRanges,
+  emptyDependencySummary,
+  isDependencyIdentifier,
+  maskDependencyLine
+} from './lightweight-dependency-language.js';
 import { sourceLines } from './native-region-scanner-core.js';
 
-const jsLikeLanguages = new Set(['javascript', 'typescript']);
-const ignoredIdentifiers = new Set([
-  'async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default',
-  'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'from',
-  'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'null', 'of',
-  'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof',
-  'undefined', 'var', 'void', 'while', 'with', 'yield'
-]);
-
 export function lightweightDependencyRelations(input, declarations, documentId) {
-  if (!jsLikeLanguages.has(String(input.language ?? '').toLowerCase())) {
-    return { relations: [], occurrences: [], facts: [], summary: emptySummary() };
-  }
+  if (typeof input.sourceText !== 'string') return { relations: [], occurrences: [], facts: [], summary: emptyDependencySummary() };
   const lines = sourceLines(input.sourceText);
   const identifiers = declarationIdentifierMap(input, declarations, lines);
   const records = { relations: [], occurrences: [], facts: [], seen: new Set() };
-  for (const scan of declarationScanRanges(declarations, lines)) {
+  for (const scan of dependencyScanRanges(input, declarations, lines)) {
     scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records);
   }
   return {
@@ -52,101 +49,27 @@ function declarationIdentifierMap(input, declarations, lines) {
 
 function identifiersForDeclaration(input, declaration, lines) {
   const identifiers = new Set();
-  addIdentifier(identifiers, declaration.name);
-  const parts = String(declaration.name ?? '').split('.');
-  addIdentifier(identifiers, parts[parts.length - 1]);
-  if (declaration.role === 'import') {
-    const line = lines[(declaration.span?.startLine ?? 1) - 1]?.line ?? '';
-    for (const identifier of importLocalIdentifiers(line)) addIdentifier(identifiers, identifier);
-    addIdentifier(identifiers, packageIdentifier(declaration.importPath ?? declaration.name));
+  const line = lines[(declaration.span?.startLine ?? 1) - 1]?.line ?? '';
+  for (const identifier of dependencyIdentifiers(input, declaration, line)) {
+    addIdentifier(identifiers, identifier);
   }
   return [...identifiers];
 }
 
-function importLocalIdentifiers(line) {
-  const source = String(line ?? '');
-  const identifiers = [];
-  let match = source.match(/^import\s+([A-Za-z_$][\w$]*)\s+from\b/);
-  if (match) identifiers.push(match[1]);
-  match = source.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
-  if (match) identifiers.push(match[1]);
-  match = source.match(/^import\s+[^,{]+,\s*\{([^}]+)\}\s+from\b/);
-  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
-  match = source.match(/^import\s+\{([^}]+)\}\s+from\b/);
-  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
-  return identifiers;
-}
-
-function namedImportIdentifiers(raw) {
-  return String(raw ?? '')
-    .split(',')
-    .map((part) => part.trim().split(/\s+as\s+/i).pop()?.trim())
-    .filter(Boolean);
-}
-
-function packageIdentifier(value) {
-  const parts = String(value ?? '').split('/').filter(Boolean);
-  const last = parts[parts.length - 1] ?? value;
-  return String(last).replace(/[^A-Za-z0-9_$]/g, '');
-}
-
 function addIdentifierTarget(map, identifier, target) {
-  if (!isIdentifier(identifier)) return;
+  if (!isDependencyIdentifier(identifier)) return;
   const existing = map.get(identifier) ?? [];
   if (!existing.some((entry) => entry.symbolId === target.symbolId)) existing.push(target);
   map.set(identifier, existing);
 }
 
-function addIdentifier(set, value) {
-  if (isIdentifier(value)) set.add(value);
-}
-
-function isIdentifier(value) {
-  const text = String(value ?? '');
-  return /^[A-Za-z_$][\w$]*$/.test(text) && !ignoredIdentifiers.has(text);
-}
-
-function declarationScanRanges(declarations, lines) {
-  return (declarations ?? [])
-    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
-    .map((declaration) => ({
-      declaration,
-      startLine: declaration.span?.startLine ?? 1,
-      endLine: declarationScanEndLine(declaration, lines)
-    }));
-}
-
-function declarationScanEndLine(declaration, lines) {
-  const startLine = declaration.span?.startLine ?? 1;
-  if (!declaration.metadata?.hasBody || declaration.kind === 'ClassDeclaration') return startLine;
-  return balancedRegionEndLine(lines, startLine);
-}
-
-function balancedRegionEndLine(lines, startLine) {
-  const state = { inBlockComment: false, inTemplateString: false };
-  let depth = 0;
-  let opened = false;
-  for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
-    for (const char of maskReferenceLine(lines[index].line, state)) {
-      if (char === '{' || char === '[' || char === '(') {
-        depth += 1;
-        opened = true;
-      } else if (char === '}' || char === ']' || char === ')') {
-        depth -= 1;
-      }
-    }
-    if (opened && depth <= 0) return lines[index].number;
-  }
-  return startLine;
-}
-
 function scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records) {
-  const state = { inBlockComment: false, inTemplateString: false };
+  const state = { inBlockComment: false };
   for (let lineNumber = scan.startLine; lineNumber <= scan.endLine; lineNumber += 1) {
-    const scanLine = maskReferenceLine(lines[lineNumber - 1]?.line ?? '', state);
+    const scanLine = maskDependencyLine(input, lines[lineNumber - 1]?.line ?? '', state);
     for (const match of scanLine.matchAll(/[A-Za-z_$][\w$]*/g)) {
       const name = match[0];
-      if (ignoredIdentifiers.has(name) || !identifiers.has(name)) continue;
+      if (!isDependencyIdentifier(name) || !identifiers.has(name)) continue;
       const targets = identifiers.get(name).filter((target) => target.symbolId !== scan.declaration.symbolId);
       for (const target of targets) {
         addDependencyRecord(input, documentId, scan.declaration, target, {
@@ -197,7 +120,7 @@ function addDependencyRecord(input, documentId, caller, target, occurrence, reco
     nativeAstNodeId: caller.nodeId
   });
   records.facts.push({
-    id: `fact_${idFragment(relationId)}_lightweight_dependency`,
+    id: `fact_${idFragment(relationId)}_${records.facts.length + 1}_lightweight_dependency`,
     predicate: 'lightweightDependency',
     subjectId: caller.symbolId,
     value: {
@@ -213,59 +136,3 @@ function addDependencyRecord(input, documentId, caller, target, occurrence, reco
 function isCallReference(line, afterIdentifierIndex) {
   return /^\s*\(/.test(String(line ?? '').slice(afterIdentifierIndex));
 }
-
-function maskReferenceLine(line, state) {
-  const text = String(line ?? '');
-  let output = '';
-  let quote;
-  let escaped = false;
-  for (let index = 0; index < text.length; index += 1) {
-    const char = text[index];
-    const next = text[index + 1];
-    if (state.inBlockComment) {
-      output += ' ';
-      if (char === '*' && next === '/') {
-        output += ' ';
-        index += 1;
-        state.inBlockComment = false;
-      }
-      continue;
-    }
-    if (state.inTemplateString) {
-      output += ' ';
-      if (char === '`' && !escaped) state.inTemplateString = false;
-      escaped = char === '\\' && !escaped;
-      continue;
-    }
-    if (quote) {
-      output += ' ';
-      if (escaped) escaped = false;
-      else if (char === '\\') escaped = true;
-      else if (char === quote) quote = undefined;
-      continue;
-    }
-    if (char === '/' && next === '/') break;
-    if (char === '/' && next === '*') {
-      output += '  ';
-      index += 1;
-      state.inBlockComment = true;
-      continue;
-    }
-    if (char === '\'' || char === '"') {
-      output += ' ';
-      quote = char;
-      continue;
-    }
-    if (char === '`') {
-      output += ' ';
-      state.inTemplateString = true;
-      continue;
-    }
-    output += char;
-  }
-  return output;
-}
-
-function emptySummary() {
-  return { total: 0, calls: 0, uses: 0 };
-}

package/dist/semantic-import-source-preservation.js

@@ -46,9 +46,9 @@ function createKernelSourcePreservationRecords(input) {
   }
 
   for (const sourceMap of input.sourceMaps ?? []) {
-    for (const mapping of sourceMap.mappings ?? []) {
+    for (const [index, mapping] of (sourceMap.mappings ?? []).entries()) {
       records.push(explainSourcePreservation({
-        id: `source_preservation_${idFragment(sourceMap.id)}_${idFragment(mapping.id)}`,
+        id: `source_preservation_${idFragment(sourceMap.id)}_${index + 1}_${idFragment(mapping.id)}`,
         sourceMap,
         mapping,
         level: mapping.preservation,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.59",
+  "version": "0.2.60",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",