@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.43

package/dist/native-parser-feature-matrix.js

@@ -0,0 +1,92 @@
+import {
+  normalizeNativeLanguageId,
+  normalizeSemanticMergeReadiness
+} from './native-import-utils.js';
+import {
+  NativeImportLanguageProfiles,
+  NativeParserFeatureCategories,
+  NativeParserFeatureCoverageStatuses,
+  mergeNativeImportProfiles,
+  parserAstFormatIdForParser
+} from './coverage-matrix-profiles.js';
+import {
+  nativeParserFeatureRowsForProfiles
+} from './native-parser-feature-rows.js';
+import {
+  nativeParserFeatureMatrixSummary,
+  nativeParserFeatureMergeAssessment,
+  normalizeNativeParserRequiredFeatures,
+  summarizeNativeParserFeatureLanguages
+} from './native-parser-feature-assessment.js';
+
+export function createNativeParserFeatureMatrix(input = {}, context = {}) {
+  const imports = input.imports ?? [];
+  const adapters = input.adapters ?? [];
+  const profiles = mergeNativeImportProfiles(input.languages ?? NativeImportLanguageProfiles, imports, adapters, [], context);
+  const parsers = nativeParserFeatureRowsForProfiles(profiles, {
+    imports,
+    adapters,
+    requiredFeatures: input.requiredFeatures,
+    minimumReadiness: input.minimumReadiness,
+    includeEmptyParsers: input.includeEmptyParsers
+  }, context);
+  const summary = nativeParserFeatureMatrixSummary(parsers);
+  return {
+    kind: 'frontier.lang.nativeParserFeatureMatrix',
+    version: 1,
+    generatedAt: input.generatedAt ?? Date.now(),
+    parsers,
+    languages: summarizeNativeParserFeatureLanguages(profiles, parsers),
+    summary,
+    metadata: {
+      categories: [...NativeParserFeatureCategories],
+      statuses: [...NativeParserFeatureCoverageStatuses],
+      requiredFeatures: normalizeNativeParserRequiredFeatures(input.requiredFeatures),
+      minimumReadiness: normalizeSemanticMergeReadiness(input.minimumReadiness ?? 'ready'),
+      note: 'Native parser feature coverage is admission evidence per language/parser. It does not promote lightweight scans or host adapters beyond their declared and observed capabilities.'
+    }
+  };
+}
+
+export function queryNativeParserFeatureMatrix(matrixOrInput = {}, query = {}, context = {}) {
+  const matrix = matrixOrInput?.kind === 'frontier.lang.nativeParserFeatureMatrix'
+    ? matrixOrInput
+    : createNativeParserFeatureMatrix(matrixOrInput, context);
+  const language = normalizeNativeLanguageId(query.language);
+  const parser = query.parser === undefined ? undefined : parserAstFormatIdForParser(query.parser);
+  const requiredFeatures = normalizeNativeParserRequiredFeatures(query.requiredFeatures ?? matrix.metadata?.requiredFeatures);
+  const minimumReadiness = normalizeSemanticMergeReadiness(query.minimumReadiness ?? matrix.metadata?.minimumReadiness ?? 'ready');
+  const row = matrix.parsers.find((entry) => {
+    if (language && normalizeNativeLanguageId(entry.language) !== language && !(entry.aliases ?? []).map(normalizeNativeLanguageId).includes(language)) {
+      return false;
+    }
+    if (!parser) return true;
+    const parserIds = [
+      entry.parser,
+      entry.parserFormat,
+      ...(entry.parserAliases ?? []),
+      ...(entry.parserAdapters ?? [])
+    ].map(parserAstFormatIdForParser);
+    return parserIds.includes(parser);
+  });
+  const merge = row
+    ? nativeParserFeatureMergeAssessment(row, { requiredFeatures, minimumReadiness })
+    : {
+      mergeReady: false,
+      readiness: 'blocked',
+      requiredFeatures,
+      minimumReadiness,
+      blockingFeatures: requiredFeatures,
+      reviewFeatures: [],
+      reasons: [`No native parser feature coverage row matched language=${query.language ?? '*'} parser=${query.parser ?? '*'}.`]
+    };
+  return {
+    kind: 'frontier.lang.nativeParserFeatureQuery',
+    version: 1,
+    found: Boolean(row),
+    language: row?.language ?? language,
+    parser: row?.parser ?? parser,
+    row,
+    merge
+  };
+}

package/dist/native-parser-feature-rows.js

@@ -0,0 +1,219 @@
+import {
+  normalizeNativeLanguageId,
+  normalizeSemanticMergeReadiness,
+  uniqueStrings
+} from './native-import-utils.js';
+import {
+  normalizeParserAstFormatId,
+  parserAstFormatIdForParser
+} from './coverage-matrix-profiles.js';
+import {
+  getNativeParserAstFormatProfile
+} from './native-parser-ast-format-matrix.js';
+import {
+  nativeImportCoverageReasons,
+  nativeImporterAdapterCoverageEntryFromImport,
+  safeNativeImporterAdapterSummary,
+  summarizeNativeImporterAdapterCoverageEntries
+} from './native-import-coverage-matrix.js';
+import {
+  nativeParserControlFlowFeature,
+  nativeParserMacroMetaprogrammingFeature,
+  nativeParserSemanticFeature,
+  nativeParserSourcePreservationFeature,
+  nativeParserSyntaxFeature,
+  nativeParserTypeFeature
+} from './native-parser-feature-coverage.js';
+import {
+  nativeParserFeatureMergeAssessment
+} from './native-parser-feature-assessment.js';
+
+export function nativeParserFeatureRowsForProfiles(profiles, context, dependencies = {}) {
+  const rows = [];
+  for (const profile of profiles) {
+    const matchingImports = nativeParserFeatureImportsForProfile(profile, context.imports);
+    const matchingAdapters = nativeParserFeatureAdapterSummariesForProfile(profile, context.adapters, dependencies);
+    for (const parser of nativeParserFeatureParserSlots(profile, matchingImports, matchingAdapters)) {
+      const row = nativeParserFeatureRowForParser(profile, parser, {
+        ...context,
+        imports: matchingImports.filter((imported) => nativeParserFeatureParserMatches(nativeParserParserForImport(imported), parser)),
+        adapters: matchingAdapters.filter((adapter) => nativeParserFeatureParserMatches(adapter.parser, parser))
+      }, dependencies);
+      if (context.includeEmptyParsers === false && row.imports.total === 0 && row.adapters.total === 0) continue;
+      rows.push(row);
+    }
+  }
+  return rows.sort((left, right) => {
+    const languageOrder = left.language.localeCompare(right.language);
+    return languageOrder || left.parser.localeCompare(right.parser);
+  });
+}
+
+function nativeParserFeatureRowForParser(profile, parser, context, dependencies = {}) {
+  const imports = context.imports ?? [];
+  const adapters = context.adapters ?? [];
+  const parserFormat = parserAstFormatIdForParser(parser);
+  const parserProfile = getNativeParserAstFormatProfile(parserFormat);
+  const adapterCoverage = summarizeNativeImporterAdapterCoverageEntries([
+    ...imports.map((imported) => nativeImporterAdapterCoverageEntryFromImport(imported)).filter(Boolean),
+    ...adapters.map((adapter) => ({
+      adapterId: adapter.id,
+      language: adapter.language,
+      parser: adapter.parser,
+      coverage: adapter.coverage
+    }))
+  ], dependencies);
+  const losses = imports.flatMap((imported) => imported?.losses ?? imported?.nativeAst?.losses ?? []);
+  const evidence = imports.flatMap((imported) => imported?.evidence ?? []);
+  const lossSummary = dependencies.summarizeNativeImportLosses(losses, { evidence, parser });
+  const semanticEvidence = nativeParserFeatureSemanticEvidence(imports, dependencies);
+  const sourceMaps = imports.flatMap((imported) => imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? []);
+  const sourceMapMappings = sourceMaps.reduce((sum, sourceMap) => sum + (sourceMap?.mappings?.length ?? 0), 0);
+  const sourcePreservation = dependencies.summarizeImportSourcePreservation(undefined, imports);
+  const nativeAstNodes = imports.reduce((sum, imported) => sum + Object.keys(imported?.nativeAst?.nodes ?? imported?.nativeSource?.ast?.nodes ?? {}).length, 0);
+  const featureContext = {
+    profile,
+    parser,
+    parserFormat,
+    parserProfile,
+    imports,
+    adapters,
+    adapterCoverage,
+    losses,
+    evidence,
+    lossSummary,
+    semanticEvidence,
+    sourceMaps,
+    sourceMapMappings,
+    sourcePreservation,
+    nativeAstNodes
+  };
+  const features = {
+    syntax: nativeParserSyntaxFeature(featureContext),
+    semantic: nativeParserSemanticFeature(featureContext),
+    type: nativeParserTypeFeature(featureContext),
+    controlFlow: nativeParserControlFlowFeature(featureContext),
+    macroMetaprogramming: nativeParserMacroMetaprogrammingFeature(featureContext, dependencies),
+    sourcePreservation: nativeParserSourcePreservationFeature(featureContext)
+  };
+  const importReadiness = imports.length
+    ? lossSummary.semanticMergeReadiness
+    : adapters.length ? 'needs-review' : normalizeSemanticMergeReadiness(profile.defaultReadiness) ?? 'needs-review';
+  const row = {
+    language: profile.language,
+    aliases: profile.aliases,
+    parser,
+    parserFormat,
+    parserAliases: uniqueStrings([...(parserProfile?.aliases ?? []), ...(parserProfile?.parserAdapters ?? [])]),
+    parserAdapters: uniqueStrings([parser, ...(parserProfile?.parserAdapters ?? [])]),
+    extensions: profile.extensions,
+    supportsLightweightScan: profile.supportsLightweightScan,
+    projectionTargets: profile.projectionTargets,
+    knownLossKinds: uniqueStrings([...(profile.knownLossKinds ?? []), ...Object.keys(lossSummary.byKind)]),
+    defaultReadiness: profile.defaultReadiness,
+    notes: uniqueStrings([...(profile.notes ?? []), ...(parserProfile?.notes ?? [])]),
+    adapters: {
+      total: adapters.length,
+      ids: adapters.map((adapter) => adapter.id),
+      versions: uniqueStrings(adapters.map((adapter) => adapter.version).filter(Boolean)),
+      exactness: uniqueStrings(adapters.map((adapter) => adapter.coverage?.exactness).filter(Boolean)),
+      coverage: adapterCoverage
+    },
+    imports: {
+      total: imports.length,
+      sourcePaths: uniqueStrings(imports.map((imported) => imported?.sourcePath ?? imported?.nativeSource?.sourcePath ?? imported?.nativeAst?.sourcePath).filter(Boolean)),
+      readiness: importReadiness,
+      readinessReasons: imports.length ? lossSummary.readinessReasons : nativeImportCoverageReasons(profile),
+      nativeAstNodes,
+      symbols: semanticEvidence.symbols,
+      references: semanticEvidence.references,
+      types: semanticEvidence.types,
+      controlFlow: semanticEvidence.controlFlow,
+      sourceMaps: sourceMaps.length,
+      sourceMapMappings,
+      losses: lossSummary.total,
+      lossKinds: lossSummary.byKind,
+      lossCategories: lossSummary.categories,
+      sourcePreservation
+    },
+    features
+  };
+  return {
+    ...row,
+    merge: nativeParserFeatureMergeAssessment(row, {
+      requiredFeatures: context.requiredFeatures,
+      minimumReadiness: context.minimumReadiness
+    })
+  };
+}
+
+function nativeParserFeatureParserSlots(profile, imports, adapters) {
+  const slots = [
+    ...(profile.parserAdapters ?? []),
+    ...adapters.map((adapter) => adapter.parser),
+    ...imports.map(nativeParserParserForImport)
+  ].filter(Boolean);
+  if (!slots.length && profile.supportsLightweightScan) slots.push(`${profile.language}.lightweight-declaration-scan`);
+  const seen = new Set();
+  const result = [];
+  for (const slot of slots) {
+    const key = `${normalizeParserAstFormatId(slot)}#${parserAstFormatIdForParser(slot)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(String(slot));
+  }
+  return result;
+}
+
+function nativeParserFeatureImportsForProfile(profile, imports = []) {
+  const languages = nativeParserFeatureLanguageSet(profile);
+  return imports.filter((imported) => languages.has(normalizeNativeLanguageId(imported?.language ?? imported?.nativeAst?.language ?? imported?.nativeSource?.language)));
+}
+
+function nativeParserFeatureAdapterSummariesForProfile(profile, adapters = [], dependencies = {}) {
+  const languages = nativeParserFeatureLanguageSet(profile);
+  return adapters
+    .map((adapter) => safeNativeImporterAdapterSummary(adapter, dependencies))
+    .filter(Boolean)
+    .filter((adapter) => languages.has(normalizeNativeLanguageId(adapter.language)));
+}
+
+function nativeParserFeatureLanguageSet(profile) {
+  return new Set([profile.language, ...(profile.aliases ?? [])].map(normalizeNativeLanguageId).filter(Boolean));
+}
+
+function nativeParserParserForImport(imported) {
+  return imported?.adapter?.parser
+    ?? imported?.metadata?.adapterCoverage?.parser
+    ?? imported?.nativeAst?.parser
+    ?? imported?.nativeSource?.parser
+    ?? imported?.parser
+    ?? imported?.metadata?.parser;
+}
+
+function nativeParserFeatureParserMatches(candidateParser, rowParser) {
+  if (!candidateParser || !rowParser) return false;
+  const candidate = normalizeParserAstFormatId(candidateParser);
+  const row = normalizeParserAstFormatId(rowParser);
+  return candidate === row || parserAstFormatIdForParser(candidateParser) === parserAstFormatIdForParser(rowParser);
+}
+
+function nativeParserFeatureSemanticEvidence(imports, dependencies = {}) {
+  const totals = {
+    declarations: 0,
+    symbols: 0,
+    references: 0,
+    types: 0,
+    controlFlow: 0
+  };
+  for (const imported of imports) {
+    const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+    const evidence = dependencies.observeNativeImporterSemanticEvidence(semanticIndex);
+    totals.declarations += evidence.declarations;
+    totals.symbols += semanticIndex?.symbols?.length ?? 0;
+    totals.references += evidence.references;
+    totals.types += evidence.types;
+    totals.controlFlow += evidence.controlFlow;
+  }
+  return totals;
+}

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

@@ -0,0 +1,179 @@
+import { idFragment } from './native-import-utils.js';
+
+function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fields = {}, hasBody = false, options = {}) {
+  const nodeId = `native_${idFragment(languageKind)}_${lineNumber}_${idFragment(name)}`;
+  return {
+    nodeId,
+    kind: languageKind,
+    languageKind: `${input.language}.${languageKind}`,
+    name,
+    symbolKind,
+    symbolId: `symbol:${input.language}:${idFragment(name)}`,
+    span: spanForLine(input, lineNumber),
+    fields,
+    metadata: { scan: 'lightweight-declaration', hasBody, ...options.metadata },
+    ...(options.regionKind ? { regionKind: options.regionKind } : {}),
+    ...(options.role ? { role: options.role } : {}),
+    ...(hasBody ? { loss: opaqueBodyLoss(input, lineNumber, nodeId, name) } : {})
+  };
+}
+
+function nativeImportDeclaration(input, lineNumber, importPath, languageKind, symbolKind) {
+  const name = String(importPath);
+  const nodeId = `native_${idFragment(languageKind)}_${lineNumber}_${idFragment(name)}`;
+  return {
+    nodeId,
+    kind: languageKind,
+    languageKind: `${input.language}.${languageKind}`,
+    name,
+    symbolKind,
+    symbolId: `symbol:${input.language}:import:${idFragment(name)}`,
+    role: 'import',
+    importPath: name,
+    span: spanForLine(input, lineNumber),
+    fields: { importPath: name },
+    metadata: { scan: 'lightweight-import' }
+  };
+}
+
+function nativeMacroLoss(input, lineNumber, source, kind, name = idFragment(source).slice(0, 40)) {
+  const nodeId = `native_${kind}_${lineNumber}_${idFragment(name)}`;
+  return {
+    nodeId,
+    kind: kind === 'preprocessor' ? 'PreprocessorDirective' : 'MacroInvocation',
+    languageKind: `${input.language}.${kind}`,
+    name,
+    symbolKind: 'constant',
+    symbolId: `symbol:${input.language}:${kind}:${idFragment(name)}`,
+    span: spanForLine(input, lineNumber),
+    fields: { source },
+    metadata: { scan: 'lightweight-macro' },
+    loss: {
+      id: `loss_${idFragment(nodeId)}`,
+      severity: 'warning',
+      phase: 'read',
+      sourceFormat: input.language,
+      kind,
+      message: `${input.language} ${kind} retained as native source; expansion is not evaluated by the lightweight importer.`,
+      span: spanForLine(input, lineNumber),
+      nodeId
+    }
+  };
+}
+
+function opaqueBodyLoss(input, lineNumber, nodeId, name) {
+  return {
+    id: `loss_${idFragment(nodeId)}_body`,
+    severity: 'info',
+    phase: 'read',
+    sourceFormat: input.language,
+    kind: 'opaqueNative',
+    message: `Body for ${name} is retained as native source by the lightweight declaration importer.`,
+    span: spanForLine(input, lineNumber),
+    nodeId
+  };
+}
+
+function lightweightCoverageLosses(input, declarations, sourcePreservation) {
+  const id = idFragment(input.sourcePath ?? input.language);
+  const span = declarations[0]?.span ?? {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    startLine: 1,
+    startColumn: 1
+  };
+  return [
+    {
+      id: `loss_${id}_declaration_only_coverage`,
+      severity: 'info',
+      phase: 'read',
+      sourceFormat: input.language,
+      kind: 'declarationOnlyCoverage',
+      message: 'Lightweight importer scanned declarations and imports only; expressions, control flow, and full type checking were not evaluated.',
+      span
+    },
+    {
+      id: `loss_${id}_partial_semantic_index`,
+      severity: 'info',
+      phase: 'index',
+      sourceFormat: input.language,
+      kind: 'partialSemanticIndex',
+      message: 'Semantic index contains lightweight declaration/import facts only; references, calls, resolved types, and cross-file links may be missing.',
+      span
+    },
+    {
+      id: `loss_${id}_source_map_approximation`,
+      severity: 'info',
+      phase: 'map',
+      sourceFormat: input.language,
+      kind: 'sourceMapApproximation',
+      message: 'Source-map spans are declaration or line estimates; exact token ranges require a parser adapter.',
+      span
+    },
+    {
+      id: `loss_${id}_source_preservation`,
+      severity: 'warning',
+      phase: 'read',
+      sourceFormat: input.language,
+      kind: 'sourcePreservation',
+      message: sourcePreservation
+        ? 'Comments, whitespace, token order, directives, and formatting are preserved as opaque native source evidence; exact structural edits still require a parser adapter.'
+        : 'Comments, whitespace, token order, directives, and formatting are not preserved by the lightweight importer.',
+      span,
+      metadata: sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservationSummary: sourcePreservation.summary
+      } : undefined
+    }
+  ];
+}
+
+function sourceLines(sourceText) {
+  return String(sourceText ?? '').split(/\r?\n/).map((line, index) => ({ line, number: index + 1 }));
+}
+
+function spanForLine(input, lineNumber) {
+  return {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    startLine: lineNumber,
+    endLine: lineNumber,
+    startColumn: 1
+  };
+}
+
+function splitParameters(raw) {
+  return String(raw ?? '')
+    .split(',')
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function splitTypeParameters(raw) {
+  return splitParameters(raw);
+}
+
+function braceDelta(source) {
+  let delta = 0;
+  for (const char of String(source ?? '')) {
+    if (char === '{') delta += 1;
+    if (char === '}') delta -= 1;
+  }
+  return delta;
+}
+
+function jsControlKeyword(value) {
+  return ['if', 'for', 'while', 'switch', 'catch', 'with'].includes(String(value));
+}
+
+export {
+  braceDelta,
+  jsControlKeyword,
+  lightweightCoverageLosses,
+  nativeDeclaration,
+  nativeImportDeclaration,
+  nativeMacroLoss,
+  sourceLines,
+  splitParameters,
+  splitTypeParameters
+};