@shapeshift-labs/frontier-lang-compiler 0.2.25 → 0.2.27

package/README.md

@@ -116,6 +116,7 @@ Ask the compiler what is actually covered before sending native imports into a m
 ```js
 import {
   createNativeImportCoverageMatrix,
+  createNativeParserAstFormatMatrix,
   createProjectionTargetLossMatrix,
   importNativeSource
 } from '@shapeshift-labs/frontier-lang-compiler';
@@ -132,6 +133,9 @@ const python = matrix.languages.find((entry) => entry.language === 'python');
 console.log(python.imports.readiness); // scanner imports are intentionally review-required
 console.log(python.parserAdapters); // host-owned exact parsers such as LibCST can be injected
 
+const parserMatrix = createNativeParserAstFormatMatrix({ imports: [imported] });
+console.log(parserMatrix.formats.find((entry) => entry.id === 'python-ast')?.adapters.total ?? 0);
+
 const projectionMatrix = createProjectionTargetLossMatrix({ imports: [imported] });
 const pythonProjection = projectionMatrix.languages.find((entry) => entry.language === 'python');
 
@@ -328,6 +332,8 @@ Use injected parser adapters when a real language parser is available but should
 ```js
 import {
   createBabelNativeImporterAdapter,
+  createPythonAstNativeImporterAdapter,
+  createRustSynNativeImporterAdapter,
   importNativeProject,
   runNativeImporterAdapter
 } from '@shapeshift-labs/frontier-lang-compiler';
@@ -335,6 +341,13 @@ import {
 const babelAdapter = createBabelNativeImporterAdapter({
   parserModule: await import('@babel/parser')
 });
+const pythonAstAdapter = createPythonAstNativeImporterAdapter({
+  parserModule: hostPythonAstParser
+});
+const rustSynAdapter = createRustSynNativeImporterAdapter({
+  parserModule: hostRustSynParser,
+  rustEdition: '2021'
+});
 
 const imported = await runNativeImporterAdapter(babelAdapter, {
   sourcePath: 'src/todo.ts',
@@ -343,10 +356,11 @@ const imported = await runNativeImporterAdapter(babelAdapter, {
 
 const project = await importNativeProject({
   projectRoot: 'src',
-  adapters: [babelAdapter],
+  adapters: [babelAdapter, pythonAstAdapter, rustSynAdapter],
   sources: [
     { language: 'typescript', adapter: babelAdapter.id, sourcePath: 'src/todo.ts', sourceText },
-    { language: 'python', sourcePath: 'tools/todo.py', sourceText: pythonSource }
+    { language: 'python', adapter: pythonAstAdapter.id, sourcePath: 'tools/todo.py', sourceText: pythonSource },
+    { language: 'rust', adapter: rustSynAdapter.id, sourcePath: 'src/todo.rs', sourceText: rustSource }
   ]
 });
 
@@ -365,6 +379,8 @@ The built-in adapter factories are dependency-light wrappers for caller-owned pa
 - `createEstreeNativeImporterAdapter`
 - `createBabelNativeImporterAdapter`
 - `createTypeScriptCompilerNativeImporterAdapter`
+- `createPythonAstNativeImporterAdapter`
+- `createRustSynNativeImporterAdapter`
 - `createTreeSitterNativeImporterAdapter`
 
 Adapter summaries include a structured `coverage` record so merge queues can distinguish exact parser AST imports from declaration scans. The record declares exactness, parser token/trivia support, diagnostics support, source-range and generated-range support, and semantic coverage. Built-in wrappers normalize native AST/CST nodes and declaration-level semantic indexes; they do not claim resolved references, types, control flow, generated ranges, or token/trivia fidelity unless the host adapter supplies that evidence.

package/bench/smoke.mjs

@@ -4,8 +4,11 @@ import {
   compileFrontierSource,
   createEstreeNativeImporterAdapter,
   createNativeImportCoverageMatrix,
+  createNativeParserAstFormatMatrix,
   createProjectionTargetLossMatrix,
   createNativeSourcePreservation,
+  createPythonAstNativeImporterAdapter,
+  createRustSynNativeImporterAdapter,
   createSemanticImportSidecar,
   diffNativeSources,
   importExternalSemanticIndex,
@@ -73,6 +76,13 @@ const matrixStart = performance.now();
 const coverageMatrix = createNativeImportCoverageMatrix({ imports: nativeImportResults });
 const matrixDurationMs = performance.now() - matrixStart;
 
+const parserFormatMatrixStart = performance.now();
+const parserFormatMatrix = createNativeParserAstFormatMatrix({
+  imports: nativeImportResults,
+  adapters: [estreeAdapter, createPythonAstNativeImporterAdapter(), createRustSynNativeImporterAdapter()]
+});
+const parserFormatMatrixDurationMs = performance.now() - parserFormatMatrixStart;
+
 const projectionMatrixStart = performance.now();
 const projectionLossMatrix = createProjectionTargetLossMatrix({ imports: nativeImportResults });
 const projectionMatrixDurationMs = performance.now() - projectionMatrixStart;
@@ -228,6 +238,10 @@ console.log(JSON.stringify({
   adapterCoverageTokenGaps: coverageMatrix.summary.adapterCoverage.gaps.tokens ?? 0,
   adapterCoverageReferenceGaps: coverageMatrix.summary.adapterCoverage.gaps.references ?? 0,
   coverageMatrixDurationMs: Number(matrixDurationMs.toFixed(2)),
+  parserFormatMatrixFormats: parserFormatMatrix.summary.formats,
+  parserFormatMatrixImports: parserFormatMatrix.summary.imports,
+  parserFormatMatrixNativeAstNodes: parserFormatMatrix.summary.nativeAstNodes,
+  parserFormatMatrixDurationMs: Number(parserFormatMatrixDurationMs.toFixed(2)),
   projectionMatrixLanguages: projectionLossMatrix.summary.languages,
   projectionMatrixMissingAdapters: projectionLossMatrix.summary.missingAdapters,
   projectionMatrixUnsupportedTargetFeatures: projectionLossMatrix.summary.unsupportedTargetFeatures,

package/dist/index.d.ts

@@ -236,6 +236,88 @@ export interface NativeImportLanguageProfile {
   readonly notes: readonly string[];
 }
 
+export type NativeParserAstFormatKind =
+  | 'abstract-ast'
+  | 'concrete-syntax-tree'
+  | 'compiler-ast'
+  | 'semantic-index'
+  | string;
+
+export interface NativeParserAstFormatProfile {
+  readonly id: string;
+  readonly aliases: readonly string[];
+  readonly kind: NativeParserAstFormatKind;
+  readonly languages: readonly (FrontierSourceLanguage | 'mixed' | string)[];
+  readonly parserAdapters: readonly string[];
+  readonly exactness: NativeImporterAdapterExactness;
+  readonly sourceRangeModel: string;
+  readonly preservesTokens: boolean;
+  readonly preservesTrivia: boolean;
+  readonly supportsIncremental: boolean;
+  readonly supportsErrorRecovery: boolean;
+  readonly notes: readonly string[];
+}
+
+export interface NativeParserAstFormatCoverage {
+  readonly id: string;
+  readonly kind: NativeParserAstFormatKind;
+  readonly languages: readonly (FrontierSourceLanguage | 'mixed' | string)[];
+  readonly parserAdapters: readonly string[];
+  readonly exactness: NativeImporterAdapterExactness;
+  readonly sourceRangeModel: string;
+  readonly preservesTokens: boolean;
+  readonly preservesTrivia: boolean;
+  readonly supportsIncremental: boolean;
+  readonly supportsErrorRecovery: boolean;
+  readonly notes: readonly string[];
+  readonly adapters: {
+    readonly total: number;
+    readonly ids: readonly string[];
+    readonly parsers: readonly string[];
+    readonly effectiveCapabilities: Readonly<Record<string, number>>;
+  };
+  readonly imports: {
+    readonly total: number;
+    readonly sourcePaths: readonly string[];
+    readonly readiness: SemanticMergeReadiness;
+    readonly nativeAstNodes: number;
+    readonly symbols: number;
+    readonly sourceMapMappings: number;
+    readonly losses: number;
+  };
+}
+
+export interface NativeParserAstFormatMatrix {
+  readonly kind: 'frontier.lang.nativeParserAstFormatMatrix';
+  readonly version: 1;
+  readonly generatedAt: number;
+  readonly formats: readonly NativeParserAstFormatCoverage[];
+  readonly summary: {
+    readonly formats: number;
+    readonly adapterSlots: number;
+    readonly adapters: number;
+    readonly imports: number;
+    readonly nativeAstNodes: number;
+    readonly symbols: number;
+    readonly sourceMapMappings: number;
+    readonly losses: number;
+    readonly byKind: Readonly<Record<string, number>>;
+    readonly byReadiness: Readonly<Record<string, number>>;
+    readonly effectiveCapabilities: Readonly<Record<string, number>>;
+  };
+  readonly metadata: {
+    readonly note: string;
+    readonly profileIds: readonly string[];
+  };
+}
+
+export interface NativeParserAstFormatMatrixOptions {
+  readonly formats?: readonly NativeParserAstFormatProfile[];
+  readonly imports?: readonly NativeSourceImportResult[];
+  readonly adapters?: readonly NativeImporterAdapter[];
+  readonly generatedAt?: number;
+}
+
 export interface NativeImporterAdapterCoverageAggregate {
   readonly total: number;
   readonly declared: Readonly<Record<string, number>>;
@@ -1283,6 +1365,51 @@ export interface TypeScriptCompilerNativeImporterAdapterOptions {
   readonly includeTokens?: boolean;
 }
 
+export interface PythonAstNativeImporterAdapterOptions {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage;
+  readonly parser?: string;
+  readonly version?: string;
+  readonly capabilities?: readonly string[];
+  readonly coverage?: NativeImporterAdapterCoverageInput;
+  readonly supportedExtensions?: readonly string[];
+  readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
+  readonly ast?: unknown;
+  readonly parse?: (sourceText: string, options: Record<string, unknown>) => unknown;
+  readonly parserModule?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly pythonAst?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly parserOptions?: Record<string, unknown>;
+  readonly mode?: 'exec' | 'eval' | 'single' | 'func_type' | string;
+  readonly pythonVersion?: string;
+  readonly featureVersion?: string | number;
+  readonly typeComments?: boolean;
+  readonly optimize?: number;
+  readonly includeAttributes?: boolean;
+  readonly maxNodes?: number;
+}
+
+export interface RustSynNativeImporterAdapterOptions {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage;
+  readonly parser?: string;
+  readonly version?: string;
+  readonly capabilities?: readonly string[];
+  readonly coverage?: NativeImporterAdapterCoverageInput;
+  readonly supportedExtensions?: readonly string[];
+  readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
+  readonly ast?: unknown;
+  readonly file?: unknown;
+  readonly sourceFile?: unknown;
+  readonly parse?: (sourceText: string, options: Record<string, unknown>) => unknown;
+  readonly parserModule?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly rustSyn?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly syn?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
+  readonly parserOptions?: Record<string, unknown>;
+  readonly rustEdition?: '2015' | '2018' | '2021' | '2024' | string;
+  readonly includeAttributes?: boolean;
+  readonly maxNodes?: number;
+}
+
 export interface TreeSitterNativeImporterAdapterOptions {
   readonly id?: string;
   readonly language?: FrontierSourceLanguage;
@@ -1625,6 +1752,8 @@ export declare const ProjectionTargetLossClasses: readonly ProjectionTargetLossC
 export declare const NativeImportReadinessBySeverity: Readonly<Record<NativeImportLossSummary['highestSeverity'], SemanticMergeReadiness>>;
 export declare const NativeImportFeatureEvidencePolicies: Readonly<Record<string, NativeImportFeatureEvidencePolicy>>;
 export declare const NativeImportLanguageProfiles: readonly NativeImportLanguageProfile[];
+export declare const NativeParserAstFormatProfiles: readonly NativeParserAstFormatProfile[];
+export declare const NativeParserAstFormats: readonly string[];
 export declare const ExternalSemanticIndexFormats: readonly ExternalSemanticIndexFormat[];
 export declare function normalizeCompileTarget(target?: string): FrontierCompileTarget;
 export declare function compileFrontierSource(source: string, options?: FrontierCompileOptions): FrontierCompileResult;
@@ -1641,6 +1770,8 @@ export declare function summarizeNativeImportLosses(losses?: readonly NativeAstL
 export declare function classifyNativeImportReadiness(losses?: readonly NativeAstLossRecord[], options?: NativeImportLossSummaryOptions): NativeImportReadinessClassification;
 export declare function classifyNativeImportRoundtripReadiness(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: NativeImportRoundtripReadinessOptions): NativeImportRoundtripReadinessClassification;
 export declare function createNativeImportCoverageMatrix(options?: NativeImportCoverageMatrixOptions): NativeImportCoverageMatrix;
+export declare function getNativeParserAstFormatProfile(format?: string): NativeParserAstFormatProfile | undefined;
+export declare function createNativeParserAstFormatMatrix(options?: NativeParserAstFormatMatrixOptions): NativeParserAstFormatMatrix;
 export declare function createProjectionTargetLossMatrix(options?: ProjectionTargetLossMatrixOptions): ProjectionTargetLossMatrix;
 export declare function createNativeSourcePreservation(options: CreateNativeSourcePreservationOptions): NativeSourcePreservation;
 export declare function createSemanticImportSidecar(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: SemanticImportSidecarOptions): SemanticImportSidecar;
@@ -1648,6 +1779,8 @@ export declare function createNativeImportResultContract(importResult: NativeSou
 export declare function createEstreeNativeImporterAdapter(options?: JavaScriptNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function createBabelNativeImporterAdapter(options?: JavaScriptNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function createTypeScriptCompilerNativeImporterAdapter(options?: TypeScriptCompilerNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createPythonAstNativeImporterAdapter(options?: PythonAstNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createRustSynNativeImporterAdapter(options?: RustSynNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function createTreeSitterNativeImporterAdapter(options?: TreeSitterNativeImporterAdapterOptions): NativeImporterAdapter;
 export declare function runNativeImporterAdapter(adapter: NativeImporterAdapter, input: RunNativeImporterAdapterOptions): Promise<NativeImporterAdapterImportResult>;
 export declare function runNativeTargetProjectionAdapter(adapter: NativeTargetProjectionAdapter, input: NativeTargetProjectionAdapterInput): NativeTargetProjectionResult;