@shapeshift-labs/frontier-lang-compiler 0.2.149 → 0.2.151

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

@@ -0,0 +1,112 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import { lineColumnForOffset } from './lineColumnForOffset.js';
+import { nearestLexicalPublicOwner, nearestPublicOwnerForOffset } from './projectSymbolGraphScopeUseDefOwners.js';
+
+function bindingRecords(bindings, context) {
+  const lexicalPublicOwners = bindings
+    .filter((binding) => binding.depth === 0 && publicKeysHas(context.publicKeys, context.sourcePath, binding.name))
+    .map((binding) => ({ name: binding.name, start: binding.start, depth: binding.depth }));
+  return bindings.map((binding, index) => {
+    const sourceSpan = sourceSpanForRange(context, binding.start, binding.end);
+    const semanticSpan = semanticSpanForHash(sourceSpan);
+    const rangeOwner = nearestPublicOwnerForOffset(context.publicOwners, binding.start);
+    const lexicalOwner = nearestLexicalPublicOwner(lexicalPublicOwners, binding);
+    const publicOwner = binding.name === rangeOwner?.name ? undefined : (rangeOwner ?? lexicalOwner);
+    const publicContract = (publicKeysHas(context.publicKeys, context.sourcePath, binding.name) && binding.depth === 0) || Boolean(publicOwner);
+    return compactRecord({
+      id: `scope_binding_${idFragment(context.sourcePath)}_${index + 1}`,
+      name: binding.name,
+      bindingKind: binding.kind,
+      namespaces: binding.namespaces,
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      sourceSpan,
+      start: binding.start,
+      end: binding.end,
+      depth: binding.depth,
+      ordinal: index + 1,
+      scopeEvidenceSource: binding.scopeEvidenceSource,
+      scopeEvidenceKind: binding.scopeEvidenceKind,
+      scopeType: binding.scopeType,
+      definitionType: binding.definitionType,
+      externalBindingId: binding.externalBindingId,
+      evidenceIds: binding.evidenceIds?.length ? binding.evidenceIds : undefined,
+      publicContract: publicContract || undefined,
+      publicOwnerName: publicOwner?.name,
+      signatureHash: hashSemanticValue({
+        kind: 'frontier.lang.projectScopeBindingSignature',
+        name: binding.name,
+        bindingKind: binding.kind,
+        namespaces: binding.namespaces,
+        depth: binding.depth,
+        sourceSpan: semanticSpan
+      })
+    });
+  });
+}
+
+function sourceSpanForRange(context, start, end) {
+  const startPos = lineColumnForOffset(context.sourceText, start);
+  const endPos = lineColumnForOffset(context.sourceText, end);
+  return {
+    sourceId: context.sourceHash,
+    path: context.sourcePath,
+    start,
+    end,
+    startLine: startPos.line,
+    startColumn: startPos.column,
+    endLine: endPos.line,
+    endColumn: endPos.column
+  };
+}
+
+function semanticSpanForHash(span) {
+  return {
+    path: span.path,
+    start: span.start,
+    end: span.end,
+    startLine: span.startLine,
+    startColumn: span.startColumn,
+    endLine: span.endLine,
+    endColumn: span.endColumn
+  };
+}
+
+function closureCaptureEvidence(referenceDepth, binding, publicOwnerName) {
+  if (!binding || !Number.isInteger(referenceDepth) || !Number.isInteger(binding.depth)) return undefined;
+  const closureDepthDelta = referenceDepth - binding.depth;
+  if (closureDepthDelta <= 0) return undefined;
+  const closureBindingDepth = binding.depth;
+  const closureOwnerName = publicOwnerName ?? binding.publicOwnerName;
+  return compactRecord({
+    closureDepthDelta,
+    closureBindingDepth,
+    closureOwnerName,
+    closureCaptureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectScopeClosureCapture',
+      binding: binding.signatureHash,
+      bindingId: binding.id,
+      bindingName: binding.name,
+      bindingKind: binding.bindingKind,
+      bindingDepth: closureBindingDepth,
+      referenceDepth,
+      closureDepthDelta,
+      closureOwnerName
+    })
+  });
+}
+
+function publicKeysHas(keys, sourcePath, name) {
+  return Boolean(sourcePath && name && keys.has(publicKey(sourcePath, name)));
+}
+
+function publicKey(sourcePath, name) {
+  return sourcePath && name ? `${sourcePath}\0${name}` : undefined;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+export { bindingRecords, closureCaptureEvidence, compactRecord, publicKey, publicKeysHas, semanticSpanForHash, sourceSpanForRange };

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

@@ -0,0 +1,238 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import {
+  attachAliasMetadata,
+  attachReferenceAliasMetadata,
+  compactRecord,
+  createScopeGraphContext,
+  nativeImportSourceText
+} from './projectSymbolGraphScopeUseDefAliases.js';
+import { lexicalScopeRecordsForImport } from './projectSymbolGraphScopeUseDefLexical.js';
+import { publicKey } from './projectSymbolGraphScopeUseDefRecordBuilders.js';
+import { publicOwnerRanges } from './projectSymbolGraphScopeUseDefOwners.js';
+import { structuralScopeRecordsForImport } from './projectSymbolGraphScopeUseDefStructural.js';
+import { directUseHashesByBinding, finalizeBindingUseHashes } from './projectSymbolGraphScopeUseDefUseHashes.js';
+
+const CompilerReferenceAmbiguousReason = 'typescript-compiler-reference-site-ambiguous';
+const CompilerReferenceLexicalMismatchReason = 'typescript-compiler-reference-lexical-binding-mismatch';
+const CompilerReferenceImportAliasTargetMismatchReason = 'typescript-compiler-reference-import-alias-target-mismatch';
+
+function createProjectScopeUseDefRecords(semanticIndex, imports, publicContractRegions) {
+  const publicKeys = publicScopeKeys(publicContractRegions, semanticIndex);
+  const context = createScopeGraphContext(semanticIndex, imports, publicKeys);
+  const records = imports.map((imported) => scopeRecordsForImport(imported, context)).filter(Boolean);
+  const initialBindings = uniqueRecords(records.flatMap((record) => record.scopeBindingRecords));
+  const initialReferences = uniqueRecords(records.flatMap((record) => record.scopeReferenceRecords));
+  const directUseHashes = directUseHashesByBinding(initialBindings, initialReferences);
+  const aliasBindings = attachAliasMetadata(initialBindings, directUseHashes, context);
+  const aliasReferences = attachReferenceAliasMetadata(initialReferences, aliasBindings);
+  const compilerReferences = attachCompilerReferenceSiteEvidence(aliasReferences, compilerReferenceSiteIndex(semanticIndex));
+  return {
+    scopeBindingRecords: finalizeBindingUseHashes(aliasBindings, compilerReferences),
+    scopeReferenceRecords: compilerReferences
+  };
+}
+
+function scopeRecordsForImport(imported, context) {
+  const sourceText = nativeImportSourceText(imported);
+  const sourcePath = imported?.sourcePath ?? imported?.nativeSource?.sourcePath;
+  if (!sourceText || !sourcePath) return undefined;
+  const sourceHash = imported?.nativeSource?.sourceHash ?? imported?.metadata?.sourceHash;
+  const fileContext = {
+    ...context,
+    sourceText,
+    sourcePath,
+    sourceHash,
+    publicOwners: publicOwnerRanges(context, sourcePath, sourceText)
+  };
+  return structuralScopeRecordsForImport(imported, fileContext) ?? lexicalScopeRecordsForImport(sourceText, fileContext);
+}
+
+function publicScopeKeys(publicContractRegions = [], semanticIndex) {
+  const keys = new Set(publicContractRegions.flatMap((region) => [
+    publicKey(region.sourcePath, region.symbolName),
+    publicKey(region.sourcePath, region.exportedName)
+  ]).filter(Boolean));
+  for (const symbol of semanticIndex?.symbols ?? []) {
+    if (symbol?.kind !== 'export') continue;
+    const path = symbol.definitionSpan?.path;
+    for (const name of [symbol.name, symbol.metadata?.localName, symbol.metadata?.exportedName]) {
+      if (name && !String(name).startsWith('{')) keys.add(publicKey(path, name));
+    }
+  }
+  return keys;
+}
+
+function uniqueRecords(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = record.id ?? JSON.stringify(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function attachCompilerReferenceSiteEvidence(references, compilerSites) {
+  if (!compilerSites.size) return references;
+  return references.map((reference) => {
+    const candidates = uniqueCompilerCandidates(compilerSites.get(compilerReferenceSiteKey(reference.sourceSpan)) ?? []);
+    if (!candidates.length) return reference;
+    if (candidates.length > 1) return blockedCompilerReference(reference, candidates, CompilerReferenceAmbiguousReason);
+    const mismatchReason = compilerReferenceLexicalMismatchReason(reference, candidates[0]);
+    if (mismatchReason) return blockedCompilerReference(reference, candidates, mismatchReason);
+    return passedCompilerReference(reference, candidates[0]);
+  });
+}
+
+function passedCompilerReference(reference, candidate) {
+  const proofHash = compilerReferenceProofHash('frontier.lang.projectScopeCompilerReferenceSiteProof', reference, [candidate]);
+  return compactRecord({
+    ...reference,
+    ...compilerReferenceFields(candidate),
+    compilerReferenceStatus: 'passed',
+    compilerReferenceProofHash: proofHash,
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectScopeReferenceSignatureCompilerProof',
+      reference: reference.signatureHash,
+      compilerReferenceProofHash: proofHash
+    })
+  });
+}
+
+function blockedCompilerReference(reference, candidates, reasonCode) {
+  const reasonCodes = uniqueStrings([...(reference.reasonCodes ?? []), reasonCode]);
+  const proofHash = compilerReferenceProofHash('frontier.lang.projectScopeCompilerReferenceSiteBlocker', reference, candidates, reasonCodes);
+  return compactRecord({
+    ...reference,
+    ...(candidates.length === 1 ? compilerReferenceFields(candidates[0]) : {}),
+    status: 'blocked',
+    reasonCodes,
+    compilerReferenceStatus: 'blocked',
+    compilerReferenceReasonCodes: [reasonCode],
+    compilerReferenceCandidates: candidates.slice(0, 6).map(compilerReferenceCandidateSummary),
+    compilerReferenceProofHash: proofHash,
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectScopeReferenceSignatureCompilerBlocker',
+      reference: reference.signatureHash,
+      compilerReferenceProofHash: proofHash,
+      reasonCodes
+    })
+  });
+}
+
+function compilerReferenceLexicalMismatchReason(reference, candidate) {
+  if (candidate.compilerSymbol?.aliased === true && reference.importAlias !== true) {
+    return CompilerReferenceLexicalMismatchReason;
+  }
+  if (candidate.compilerSymbol?.aliased === true && reference.importAlias === true) {
+    const compilerTargetName = candidate.compilerSymbol?.targetName;
+    const lexicalTargetNames = uniqueStrings([
+      reference.resolvedBindingName,
+      reference.resolvedExportName,
+      reference.importedName
+    ]);
+    if (compilerTargetName && lexicalTargetNames.length && !lexicalTargetNames.includes(compilerTargetName)) {
+      return CompilerReferenceImportAliasTargetMismatchReason;
+    }
+  }
+  return undefined;
+}
+
+function compilerReferenceSiteIndex(semanticIndex) {
+  const occurrences = new Map((semanticIndex?.occurrences ?? []).map((occurrence) => [occurrence.id, occurrence]));
+  const relations = groupBy((semanticIndex?.relations ?? []).filter((relation) => relation?.predicate === 'references'), 'sourceId');
+  const facts = groupBy((semanticIndex?.facts ?? []).filter((fact) => fact?.predicate === 'compilerSymbolReference'), 'subjectId');
+  const result = new Map();
+  for (const occurrence of occurrences.values()) {
+    const occurrenceRelations = relations.get(occurrence.id) ?? [];
+    const occurrenceFacts = facts.get(occurrence.id) ?? [];
+    if (!occurrence.metadata?.compilerReference && !occurrenceFacts.length) continue;
+    const key = compilerReferenceSiteKey(occurrence.span);
+    if (!key) continue;
+    const symbolIds = uniqueStrings([occurrence.symbolId, ...occurrenceRelations.map((relation) => relation.targetId), ...occurrenceFacts.map((fact) => fact.objectId)]);
+    for (const symbolId of symbolIds) {
+      const fact = occurrenceFacts.find((item) => item.objectId === symbolId) ?? occurrenceFacts[0];
+      const relationEvidenceIds = occurrenceRelations.filter((relation) => relation.targetId === symbolId).flatMap((relation) => relation.evidenceIds ?? []);
+      addCompilerReferenceSite(result, key, compactRecord({
+        occurrenceId: occurrence.id,
+        symbolId,
+        compilerSymbol: objectValue(fact?.value ?? occurrence.metadata?.compilerSymbol),
+        compilerSymbolIdentityHash: fact?.value?.identityHash,
+        evidenceIds: uniqueStrings([...relationEvidenceIds, ...(fact?.evidenceIds ?? [])])
+      }));
+    }
+  }
+  return result;
+}
+
+function addCompilerReferenceSite(result, key, record) {
+  if (!record.symbolId) return;
+  result.set(key, [...(result.get(key) ?? []), record]);
+}
+
+function compilerReferenceFields(candidate) {
+  return compactRecord({
+    compilerReferenceSymbolId: candidate.symbolId,
+    compilerReferenceIdentityHash: candidate.compilerSymbolIdentityHash,
+    compilerReferenceFullyQualifiedName: candidate.compilerSymbol?.fullyQualifiedName,
+    compilerReferenceLocalName: candidate.compilerSymbol?.localName,
+    compilerReferenceTargetName: candidate.compilerSymbol?.targetName,
+    compilerReferenceAliased: candidate.compilerSymbol?.aliased,
+    compilerReferenceEvidenceIds: candidate.evidenceIds?.length ? candidate.evidenceIds : undefined
+  });
+}
+
+function compilerReferenceCandidateSummary(candidate) {
+  return compilerReferenceFields(candidate);
+}
+
+function compilerReferenceProofHash(kind, reference, candidates, reasonCodes = undefined) {
+  return hashSemanticValue({
+    kind,
+    reference: reference.signatureHash,
+    sourcePath: reference.sourcePath,
+    sourceSpan: reference.sourceSpan ? {
+      path: reference.sourceSpan.path,
+      startLine: reference.sourceSpan.startLine,
+      startColumn: reference.sourceSpan.startColumn,
+      endLine: reference.sourceSpan.endLine,
+      endColumn: reference.sourceSpan.endColumn
+    } : undefined,
+    candidates: candidates.map(compilerReferenceCandidateSummary),
+    reasonCodes
+  });
+}
+
+function compilerReferenceSiteKey(span) {
+  if (!span?.path || !Number.isInteger(span.startLine) || !Number.isInteger(span.startColumn) || !Number.isInteger(span.endLine) || !Number.isInteger(span.endColumn)) return undefined;
+  return [span.path, span.startLine, span.startColumn, span.endLine, span.endColumn].join('#');
+}
+
+function uniqueCompilerCandidates(candidates) {
+  const seen = new Set();
+  return candidates.filter((candidate) => {
+    const key = `${candidate.symbolId}\0${candidate.compilerSymbolIdentityHash ?? ''}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function groupBy(records, field) {
+  const result = new Map();
+  for (const record of records) {
+    const key = record?.[field];
+    if (key) result.set(key, [...(result.get(key) ?? []), record]);
+  }
+  return result;
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { createProjectScopeUseDefRecords };

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

@@ -0,0 +1,104 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import { namespaceOverlap, rangeKey, uniqueStrings } from '../../js-ts-semantic-scope-use-def-utils.js';
+import { bindingRecords, closureCaptureEvidence, compactRecord, semanticSpanForHash, sourceSpanForRange } from './projectSymbolGraphScopeUseDefRecordBuilders.js';
+import { nearestPublicOwnerForOffset } from './projectSymbolGraphScopeUseDefOwners.js';
+import { normalizeStructuralScopeEvidence, structuralScopeEvidenceForImport } from './projectSymbolGraphScopeUseDefStructuralNormalize.js';
+
+function structuralScopeRecordsForImport(imported, context) {
+  const evidence = structuralScopeEvidenceForImport(imported);
+  if (!evidence) return undefined;
+  const normalized = normalizeStructuralScopeEvidence(evidence);
+  if (!normalized.bindingInputs.length && !normalized.referenceInputs.length) return undefined;
+  const bindings = bindingRecords(normalized.bindingInputs, context);
+  const bindingIndex = structuralBindingIndex(normalized.bindingInputs, bindings);
+  const references = structuralReferenceRecords(normalized.referenceInputs, bindings, bindingIndex, context);
+  return {
+    scopeBindingRecords: bindings,
+    scopeReferenceRecords: references
+  };
+}
+
+function structuralReferenceRecords(references, bindings, bindingIndex, context) {
+  const bindingKeys = new Set(bindings.map((binding) => `${binding.start}:${binding.end}`));
+  return references.flatMap((reference, index) => {
+    if (bindingKeys.has(rangeKey(reference)) && reference.includeDeclarationReference !== true) return [];
+    const binding = structuralBindingForReference(reference, bindings, bindingIndex);
+    const sourceSpan = sourceSpanForRange(context, reference.start, reference.end);
+    const semanticSpan = semanticSpanForHash(sourceSpan);
+    const publicOwner = nearestPublicOwnerForOffset(context.publicOwners, reference.start);
+    const publicOwnerName = binding?.publicOwnerName ?? publicOwner?.name;
+    const closureCapture = closureCaptureEvidence(reference.depth, binding, publicOwnerName);
+    return [compactRecord({
+      id: `scope_ref_${idFragment(context.sourcePath)}_external_${index + 1}`,
+      name: reference.name,
+      namespace: reference.namespace,
+      namespaces: reference.namespaces,
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      sourceSpan,
+      start: reference.start,
+      end: reference.end,
+      depth: reference.depth,
+      scopeEvidenceSource: reference.scopeEvidenceSource,
+      scopeEvidenceKind: reference.scopeEvidenceKind,
+      scopeType: reference.scopeType,
+      referenceKind: reference.referenceKind,
+      evidenceIds: reference.evidenceIds?.length ? reference.evidenceIds : undefined,
+      bindingId: binding?.id,
+      bindingName: binding?.name ?? reference.resolvedName,
+      bindingKind: binding?.bindingKind,
+      bindingOrdinal: binding?.ordinal,
+      closure: Boolean(closureCapture) || undefined,
+      closureDepthDelta: closureCapture?.closureDepthDelta,
+      closureBindingDepth: closureCapture?.closureBindingDepth,
+      closureOwnerName: closureCapture?.closureOwnerName,
+      closureCaptureHash: closureCapture?.closureCaptureHash,
+      publicContract: (binding?.publicContract || Boolean(publicOwnerName)) || undefined,
+      publicOwnerName,
+      status: binding ? undefined : 'unresolved',
+      reasonCodes: binding ? undefined : ['scope-manager-unresolved-reference'],
+      signatureHash: hashSemanticValue({
+        kind: 'frontier.lang.projectScopeReferenceSignature',
+        name: reference.name,
+        namespace: reference.namespace,
+        bindingId: binding?.id,
+        sourceSpan: semanticSpan,
+        evidenceSource: reference.scopeEvidenceSource,
+        closureCaptureHash: closureCapture?.closureCaptureHash,
+        closureDepthDelta: closureCapture?.closureDepthDelta,
+        closureOwnerName: closureCapture?.closureOwnerName
+      })
+    })];
+  });
+}
+
+function structuralBindingIndex(inputs, records) {
+  const byExternalId = new Map();
+  const byNameRange = new Map();
+  for (let index = 0; index < records.length; index += 1) {
+    const input = inputs[index];
+    const record = records[index];
+    for (const externalId of uniqueStrings([input?.externalBindingId, record.externalBindingId, input?.bindingId])) byExternalId.set(externalId, record);
+    byNameRange.set(nameRangeKey(record.name, record.start, record.end), record);
+  }
+  return { byExternalId, byNameRange };
+}
+
+function structuralBindingForReference(reference, bindings, bindingIndex) {
+  for (const externalId of uniqueStrings([reference.externalBindingId, reference.bindingId, reference.resolvedBindingId])) {
+    const binding = bindingIndex.byExternalId.get(externalId);
+    if (binding) return binding;
+  }
+  const byResolvedRange = bindingIndex.byNameRange.get(nameRangeKey(reference.resolvedName, reference.resolvedStart, reference.resolvedEnd));
+  if (byResolvedRange) return byResolvedRange;
+  return bindings
+    .filter((binding) => binding.name === (reference.resolvedName ?? reference.name) && namespaceOverlap(binding.namespaces, reference.namespaces))
+    .sort((left, right) => Math.abs(left.depth - reference.depth) - Math.abs(right.depth - reference.depth) || right.start - left.start)[0];
+}
+
+function nameRangeKey(name, start, end) {
+  return name && Number.isInteger(start) && Number.isInteger(end) ? `${name}:${start}:${end}` : undefined;
+}
+
+export { structuralScopeRecordsForImport };