@shapeshift-labs/frontier-lang-compiler 0.2.40 → 0.2.42

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

@@ -0,0 +1,62 @@
+import{idFragment}from'../../native-import-utils.js';
+import{isRustSynAstNode}from'./isRustSynAstNode.js';import{nativeNodeId}from'./nativeNodeId.js';import{primitiveRustSynFields}from'./primitiveRustSynFields.js';import{rustSynChildEntries}from'./rustSynChildEntries.js';import{rustSynDeclaration}from'./rustSynDeclaration.js';import{rustSynKind}from'./rustSynKind.js';import{rustSynMacroKind}from'./rustSynMacroKind.js';import{rustSynNodeValue}from'./rustSynNodeValue.js';import{rustSynPayload}from'./rustSynPayload.js';import{rustSynSpanKind}from'./rustSynSpanKind.js';import{spanFromRustSynNode}from'./spanFromRustSynNode.js';
+export function visitRustSynNode(node, context, propertyPath) {
+  if (!isRustSynAstNode(node) || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = rustSynKind(node);
+  const payload = rustSynPayload(node);
+  const span = spanFromRustSynNode(payload, context.input);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  for (const [field, value] of rustSynChildEntries(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitRustSynNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitRustSynNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declaration = rustSynDeclaration(payload, kind, id, context.input);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? rustSynNodeValue(payload),
+    fields: primitiveRustSynFields(payload, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      spanKind: rustSynSpanKind(payload)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  if (rustSynMacroKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_rust_macro_expansion`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'macroExpansion',
+      message: 'Rust macro syntax was parsed but macro expansion and generated items require host compiler evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat
+      }
+    });
+  }
+  return id;
+}

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

@@ -0,0 +1,103 @@
+import{idFragment}from'../../native-import-utils.js';
+import{isSwiftSyntaxNode}from'./isSwiftSyntaxNode.js';import{nativeNodeId}from'./nativeNodeId.js';import{primitiveSwiftSyntaxFields}from'./primitiveSwiftSyntaxFields.js';import{spanFromSwiftSyntaxNode}from'./spanFromSwiftSyntaxNode.js';import{swiftGeneratedCodeLoss}from'./swiftGeneratedCodeLoss.js';import{swiftGeneratedCodeMarker}from'./swiftGeneratedCodeMarker.js';import{swiftSyntaxChildEntries}from'./swiftSyntaxChildEntries.js';import{swiftSyntaxConditionalCompilationKind}from'./swiftSyntaxConditionalCompilationKind.js';import{swiftSyntaxDeclarations}from'./swiftSyntaxDeclarations.js';import{swiftSyntaxKind}from'./swiftSyntaxKind.js';import{swiftSyntaxMacroKind}from'./swiftSyntaxMacroKind.js';import{swiftSyntaxNodeValue}from'./swiftSyntaxNodeValue.js';import{swiftSyntaxPositionKind}from'./swiftSyntaxPositionKind.js';import{swiftSyntaxProblemNode}from'./swiftSyntaxProblemNode.js';import{swiftSyntaxRecoveredKind}from'./swiftSyntaxRecoveredKind.js';
+export function visitSwiftSyntaxNode(node, context, propertyPath) {
+  if (!isSwiftSyntaxNode(node) || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = swiftSyntaxKind(node);
+  const span = spanFromSwiftSyntaxNode(node, context.input, context.options);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  for (const [field, value] of swiftSyntaxChildEntries(node, kind)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitSwiftSyntaxNode(entry, context, `${propertyPath}.${field}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitSwiftSyntaxNode(value, context, `${propertyPath}.${field}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declarations = swiftSyntaxDeclarations(node, kind, id, context.input);
+  const declaration = declarations[0];
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? swiftSyntaxNodeValue(node),
+    fields: primitiveSwiftSyntaxFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      positionKind: swiftSyntaxPositionKind(node),
+      parser: context.options.parser
+    }
+  };
+  context.nodes[id] = nativeNode;
+  for (const entry of declarations) {
+    context.declarations.push({ ...entry, nativeNode });
+  }
+  if (swiftSyntaxRecoveredKind(kind) || swiftSyntaxProblemNode(node, kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_swift_syntax_recovered_node`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: 'SwiftSyntax reported missing, unexpected, skipped, or error syntax; semantic import is partial until syntax errors are resolved.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (swiftSyntaxConditionalCompilationKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_swift_conditional_compilation`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'conditionalCompilation',
+      message: 'Swift conditional compilation syntax was imported; active branch selection and inactive branch source ownership require host build-setting evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (swiftSyntaxMacroKind(kind)) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_swift_macro_expansion`,
+      severity: 'warning',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'macroExpansion',
+      message: 'Swift macro syntax was imported, but expansion, generated declarations, and binding effects require host macro-expansion evidence.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        nodeKind: kind
+      }
+    });
+  }
+  if (swiftGeneratedCodeMarker(node, kind)) {
+    context.losses.push(swiftGeneratedCodeLoss(context.input, id, span, context.options, { nodeKind: kind }));
+  }
+  return id;
+}

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

@@ -0,0 +1,46 @@
+import{ignoredSyntaxField}from'./ignoredSyntaxField.js';import{isSyntaxAstNode}from'./isSyntaxAstNode.js';import{literalSyntaxValue}from'./literalSyntaxValue.js';import{nativeNodeId}from'./nativeNodeId.js';import{numberOrUndefined}from'./numberOrUndefined.js';import{primitiveSyntaxFields}from'./primitiveSyntaxFields.js';import{spanFromLoc}from'./spanFromLoc.js';import{syntaxDeclaration}from'./syntaxDeclaration.js';
+export function visitSyntaxAstNode(node, context, propertyPath) {
+  if (!isSyntaxAstNode(node) || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const id = nativeNodeId(context, node.type ?? node.kind ?? 'Node', node.loc, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  const fields = primitiveSyntaxFields(node);
+  for (const [key, value] of Object.entries(node)) {
+    if (ignoredSyntaxField(key)) continue;
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        const childId = visitSyntaxAstNode(entry, context, `${propertyPath}.${key}[${index}]`);
+        if (childId) children.push(childId);
+      });
+    } else {
+      const childId = visitSyntaxAstNode(value, context, `${propertyPath}.${key}`);
+      if (childId) children.push(childId);
+    }
+  }
+  const declaration = syntaxDeclaration(node, id, context.input, context.options);
+  const nativeNode = {
+    id,
+    kind: String(node.type ?? node.kind ?? 'Node'),
+    languageKind: `${context.input.language}.${node.type ?? node.kind ?? 'Node'}`,
+    span: spanFromLoc(node.loc, context.input),
+    value: declaration?.name ?? literalSyntaxValue(node),
+    fields,
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      start: numberOrUndefined(node.start),
+      end: numberOrUndefined(node.end),
+      range: Array.isArray(node.range) ? node.range.slice(0, 2) : undefined
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  return id;
+}

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

@@ -0,0 +1,145 @@
+import{idFragment}from'../../native-import-utils.js';
+import{nativeNodeId}from'./nativeNodeId.js';import{numberOrUndefined}from'./numberOrUndefined.js';import{shortNodeText}from'./shortNodeText.js';import{spanFromTreeSitterNode}from'./spanFromTreeSitterNode.js';import{treeSitterDeclaration}from'./treeSitterDeclaration.js';
+export function visitTreeSitterNode(node, context, propertyPath, depth = 0) {
+  if (!node || typeof node !== 'object' || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  context.counter += 1;
+  const kind = String(node.type ?? node.kind ?? 'node');
+  const span = spanFromTreeSitterNode(node, context.input);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  const rawChildren = treeSitterChildren(node);
+  rawChildren.forEach((child, index) => {
+    const childId = visitTreeSitterNode(child, context, `${propertyPath}.children[${index}]`, depth + 1);
+    if (childId) children.push(childId);
+  });
+  const named = treeSitterBoolean(node, 'isNamed', 'named');
+  const missing = treeSitterBoolean(node, 'isMissing', 'missing');
+  const extra = treeSitterBoolean(node, 'isExtra', 'extra');
+  const parseError = treeSitterBoolean(node, 'isError') || kind === 'ERROR';
+  const containsParseError = treeSitterBoolean(node, 'hasError') || parseError;
+  observeTreeSitterCstNode(context, { kind, named, missing, parseError, containsParseError, childCount: children.length, depth });
+  const declaration = treeSitterDeclaration(node, kind, id, context.input, context.options);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? shortNodeText(node),
+    fields: {
+      named,
+      missing,
+      extra,
+      error: containsParseError,
+      parseError,
+      containsParseError
+    },
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      cstDepth: depth,
+      childCount: children.length,
+      startIndex: numberOrUndefined(node.startIndex),
+      endIndex: numberOrUndefined(node.endIndex),
+      parseState: numberOrUndefined(node.parseState),
+      nextParseState: numberOrUndefined(node.nextParseState),
+      grammarId: numberOrUndefined(node.grammarId),
+      grammarType: stringOrUndefined(node.grammarType),
+      nodeType: stringOrUndefined(node.type ?? node.kind)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  if (containsParseError || missing) {
+    context.losses.push({
+      id: `loss_${idFragment(id)}_tree_sitter_error`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: context.input.language,
+      kind: 'unsupportedSyntax',
+      message: missing
+        ? 'Tree-sitter reported a missing syntax node during tolerant parsing.'
+        : 'Tree-sitter reported a parse error node.',
+      span,
+      nodeId: id,
+      metadata: {
+        parser: context.options.parser,
+        astFormat: context.options.astFormat,
+        tolerantParse: true,
+        parseError,
+        containsParseError,
+        missing
+      }
+    });
+  }
+  return id;
+}
+
+function treeSitterChildren(node) {
+  const children = treeSitterArrayChildren(node, 'children');
+  if (children.length) return children;
+  const childCountChildren = treeSitterIndexedChildren(node, 'childCount', 'child');
+  if (childCountChildren.length) return childCountChildren;
+  const namedChildren = treeSitterArrayChildren(node, 'namedChildren');
+  if (namedChildren.length) return namedChildren;
+  return treeSitterIndexedChildren(node, 'namedChildCount', 'namedChild');
+}
+
+function treeSitterArrayChildren(node, field) {
+  const value = node[field];
+  return Array.isArray(value) ? value.filter((child) => child && typeof child === 'object') : [];
+}
+
+function treeSitterIndexedChildren(node, countField, childMethod) {
+  const count = Number(node[countField]);
+  if (!Number.isFinite(count) || count <= 0 || typeof node[childMethod] !== 'function') return [];
+  const children = [];
+  for (let index = 0; index < count; index += 1) {
+    const child = node[childMethod](index);
+    if (child && typeof child === 'object') children.push(child);
+  }
+  return children;
+}
+
+function treeSitterBoolean(node, ...fields) {
+  for (const field of fields) {
+    const value = node[field];
+    if (typeof value === 'function') return Boolean(value.call(node));
+    if (value !== undefined) return Boolean(value);
+  }
+  return false;
+}
+
+function stringOrUndefined(value) {
+  return value === undefined || value === null ? undefined : String(value);
+}
+
+function observeTreeSitterCstNode(context, node) {
+  const summary = context.treeSitterCstSummary ??= {
+    totalNodes: 0,
+    namedNodes: 0,
+    anonymousNodes: 0,
+    missingNodes: 0,
+    errorNodes: 0,
+    containingErrorNodes: 0,
+    leafNodes: 0,
+    maxDepth: 0,
+    kinds: {}
+  };
+  summary.totalNodes += 1;
+  if (node.named) summary.namedNodes += 1;
+  else summary.anonymousNodes += 1;
+  if (node.missing) summary.missingNodes += 1;
+  if (node.parseError) summary.errorNodes += 1;
+  if (node.containsParseError) summary.containingErrorNodes += 1;
+  if (!node.childCount) summary.leafNodes += 1;
+  summary.maxDepth = Math.max(summary.maxDepth, node.depth);
+  summary.kinds[node.kind] = (summary.kinds[node.kind] ?? 0) + 1;
+}

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

@@ -0,0 +1,45 @@
+import{nativeNodeId}from'./nativeNodeId.js';import{numberOrUndefined}from'./numberOrUndefined.js';import{primitiveTypeScriptFields}from'./primitiveTypeScriptFields.js';import{spanFromTypeScriptNode}from'./spanFromTypeScriptNode.js';import{typeScriptDeclaration}from'./typeScriptDeclaration.js';import{typeScriptKindName}from'./typeScriptKindName.js';import{typeScriptNodeValue}from'./typeScriptNodeValue.js';
+export function visitTypeScriptAstNode(node, sourceFile, context, propertyPath, ts) {
+  if (!node || typeof node !== 'object' || context.truncated) return undefined;
+  if (context.objectIds.has(node)) return context.objectIds.get(node);
+  if (context.counter >= context.maxNodes) {
+    context.truncated = true;
+    return undefined;
+  }
+  const kind = typeScriptKindName(node, ts);
+  const span = spanFromTypeScriptNode(node, sourceFile);
+  const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
+  context.objectIds.set(node, id);
+  if (!context.rootId) context.rootId = id;
+  const children = [];
+  const visitChild = (child) => {
+    const childId = visitTypeScriptAstNode(child, sourceFile, context, `${propertyPath}.${children.length}`, ts);
+    if (childId) children.push(childId);
+  };
+  if (ts && typeof ts.forEachChild === 'function') {
+    ts.forEachChild(node, visitChild);
+  } else if (typeof node.forEachChild === 'function') {
+    node.forEachChild(visitChild);
+  } else if (Array.isArray(node.children)) {
+    node.children.forEach(visitChild);
+  }
+  const declaration = typeScriptDeclaration(node, kind, id, context.input, context.options);
+  const nativeNode = {
+    id,
+    kind,
+    languageKind: `${context.input.language}.${kind}`,
+    span,
+    value: declaration?.name ?? typeScriptNodeValue(node),
+    fields: primitiveTypeScriptFields(node, kind),
+    children,
+    metadata: {
+      astFormat: context.options.astFormat,
+      propertyPath,
+      pos: numberOrUndefined(node.pos),
+      end: numberOrUndefined(node.end)
+    }
+  };
+  context.nodes[id] = nativeNode;
+  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  return id;
+}

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

@@ -0,0 +1,32 @@
+import{idFragment,uniqueByEvidenceId,uniqueByLossId,uniqueRecordsById}from'../../native-import-utils.js';
+import{attachExternalOwnership}from'./attachExternalOwnership.js';
+export function withExternalEmptyLoss(result, context) {
+  if (!result.documents.length) {
+    result.documents.push({
+      id: `doc_${context.idPart}_${idFragment(context.format)}`,
+      path: context.sourcePath ?? `${context.format}:memory`,
+      language: context.language,
+      sourceHash: context.sourceHash,
+      metadata: { format: context.format, inferred: true }
+    });
+  }
+  if (!result.symbols.length && !result.occurrences.length) {
+    result.losses.push({
+      id: `loss_${context.idPart}_${idFragment(context.format)}_empty_semantic_index`,
+      severity: 'warning',
+      phase: 'index',
+      sourceFormat: context.format,
+      kind: 'partialSemanticIndex',
+      message: `${context.format} payload did not contain symbols or occurrences that Frontier can map.`,
+      metadata: { format: context.format }
+    });
+  }
+  attachExternalOwnership(result, context);
+  result.symbols = uniqueRecordsById(result.symbols);
+  result.occurrences = uniqueRecordsById(result.occurrences);
+  result.relations = uniqueRecordsById(result.relations);
+  result.facts = uniqueRecordsById(result.facts);
+  result.losses = uniqueByLossId(result.losses);
+  result.evidence = uniqueByEvidenceId(result.evidence);
+  return result;
+}

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

@@ -0,0 +1,53 @@
+import{maxSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportResultContract}from'./createNativeImportResultContract.js';
+export function withNativeImportReadiness(importResult, lossSummary) {
+  const mergeCandidates = (importResult.mergeCandidates ?? []).map((candidate) => {
+    const readiness = maxSemanticMergeReadiness(candidate.readiness, lossSummary.semanticMergeReadiness);
+    return {
+      ...candidate,
+      readiness,
+      reasons: uniqueStrings([
+        ...(candidate.reasons ?? []),
+        ...lossSummary.readinessReasons
+      ]),
+      metadata: {
+        ...candidate.metadata,
+        nativeImportLossSummary: lossSummary,
+        severityReadiness: lossSummary.semanticMergeReadiness,
+        finalReadiness: readiness,
+        lossCategories: lossSummary.categories,
+        lossSeverityCounts: lossSummary.bySeverity,
+        lossKindCounts: lossSummary.byKind
+      }
+    };
+  });
+  const semanticMergeReadiness = mergeCandidates[0]?.readiness ?? lossSummary.semanticMergeReadiness;
+  const contractInput = {
+    ...importResult,
+    mergeCandidates,
+    metadata: {
+      ...importResult.metadata,
+      nativeImportLossSummary: lossSummary,
+      semanticMergeReadiness
+    }
+  };
+  const importResultContract = createNativeImportResultContract(contractInput, { lossSummary });
+  return {
+    ...importResult,
+    mergeCandidates,
+    metadata: {
+      ...importResult.metadata,
+      importResultContract,
+      nativeImportLossSummary: lossSummary,
+      semanticMergeReadiness,
+      readinessReasons: importResultContract.readiness.reasons,
+      sourcePreservationSummary: importResultContract.sourcePreservation,
+      adapterCoverageSummary: importResultContract.adapterCoverage,
+      regionSummary: importResultContract.regions,
+      sourceMapSummary: importResultContract.sourceMaps,
+      lossCategories: lossSummary.categories,
+      lossSeverityCounts: lossSummary.bySeverity,
+      lossKindCounts: lossSummary.byKind
+    }
+  };
+}

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

@@ -0,0 +1,7 @@
+import{stableUniversalAstJson}from'@shapeshift-labs/frontier-lang-kernel';
+export function writeSemanticSliceJson(slice) {
+  if (slice?.kind !== 'frontier.lang.semanticSlice') {
+    throw new Error('Invalid Frontier semantic slice: expected kind frontier.lang.semanticSlice');
+  }
+  return stableUniversalAstJson(slice);
+}

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

@@ -0,0 +1,8 @@
+import{stableUniversalAstJson,validateUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
+export function writeUniversalAstJson(envelope) {
+  const issues = validateUniversalAstEnvelope(envelope);
+  if (issues.length > 0) {
+    throw new Error(`Invalid Frontier universal AST envelope: ${issues.join('; ')}`);
+  }
+  return stableUniversalAstJson(envelope);
+}