semantifold 0.3.0 → 0.5.0

package/src/backends/writer.js

@@ -2,22 +2,138 @@
 
 import {createGenerationIndex} from "../semantic/provenance.js"
 
+/**
+ * Collects every caller-controlled binding spelling before synthetic names are chosen.
+ * @param {unknown} root - Semantic graph.
+ * @returns {Set<string>} Used source names.
+ */
+function collectBindingNames(root) {
+  const names = new Set()
+  const pending = [root]
+  const seen = new Set()
+
+  while (pending.length > 0) {
+    const value = pending.pop()
+    if (!value || typeof value != "object" || seen.has(value)) continue
+    seen.add(value)
+    if (!Array.isArray(value) && typeof Reflect.get(value, "name") == "string") names.add(Reflect.get(value, "name"))
+    for (const child of Array.isArray(value) ? value : Object.values(value)) {
+      if (child && typeof child == "object") pending.push(child)
+    }
+  }
+  return names
+}
+
+/**
+ * Converts a logical module identity to its canonical target type segment.
+ * @param {string} id - Logical module identity.
+ * @returns {string} Portable target class/module name.
+ */
+function moduleClassName(id) {
+  return id.split(/[._-]+/u).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("")
+}
+
+/**
+ * Looks up one declaration name in its owning program module.
+ * @param {Partial<import("../semantic/types.js").SemanticProgramModule>} module - Owning module.
+ * @param {string} declarationId - Stable declaration identity.
+ * @returns {string} Declaration name.
+ */
+function declarationName(module, declarationId) {
+  const declaration = [...module.functions ?? [], ...module.records ?? [], ...module.classes ?? [], ...module.errors ?? []]
+    .find(({id}) => id == declarationId)
+
+  if (!declaration) throw new RangeError(`Unknown program declaration '${declarationId}'.`)
+
+  return declaration.name
+}
+
+/**
+ * Chooses an unqualified target binding without treating a source-profile qualifier as semantic identity.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Owning program.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Importing module.
+ * @param {import("../semantic/types.js").SemanticImport} imported - Resolved import.
+ * @returns {string} Target-local binding spelling.
+ */
+export function programImportName(program, module, imported) {
+  const source = program.sources.find(({filename}) => filename == module.sourceFilename)
+
+  if (!source) throw new RangeError(`Program module '${module.id}' has no registered source.`)
+
+  return source.language == "ruby" || source.language == "java" ? imported.importedName : imported.localName
+}
+
 /** Source-aware deterministic generated-output builder. */
 export class SourceWriter {
   /**
    * Creates a source-aware writer.
    * @param {object} options - Writer options.
    * @param {string} options.filename - Output filename.
-   * @param {import("../semantic/types.js").SemanticLanguage} options.language - Output language.
+   * @param {import("../semantic/types.js").GeneratedTextLanguage} options.language - Output text language.
    * @param {import("../semantic/types.js").SemanticModule} options.module - Semantic module.
+   * @param {import("../semantic/types.js").SemanticProgram} [options.program] - Owning multi-file program.
+   * @param {Map<string, string>} [options.programPaths] - Planned artifact path by module identity.
    * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]} [options.sources] - Caller-provided sources.
+   * @param {Record<string, string>} [options.stdlibProviderEntries] - Used operation to protected native entry for a linked stdlib provider.
+   * @param {string} [options.stdlibProviderPath] - Planned stdlib provider artifact path.
+   * @param {string[]} [options.stdlibProviderPaths] - Planned stdlib provider artifact paths.
+   * @param {string[]} [options.stdlibProviderImports] - Ordered provider names this module must import.
+   * @param {string} [options.stdlibProviderOwnerModule] - Java owner module identity hosting the shared support block and shims.
+   * @param {string[]} [options.stdlibProviderShims] - Java owner program-wide used operations exposed as public static shims.
+   * @param {(expression: import("../semantic/types.js").CallExpression) => string} [options.callNameResolver] - Target-container call spelling override.
+   * @param {string} [options.callArgumentSuffix] - Synthetic trailing argument for every semantic function call.
+   * @param {boolean} [options.methodStringEquality] - Emit string equality through the platform String method.
    */
-  constructor({filename, language, module, sources}) {
+  constructor({callArgumentSuffix, callNameResolver, filename, language, methodStringEquality, module, program, programPaths, sources,
+    stdlibProviderEntries, stdlibProviderPath, stdlibProviderPaths, stdlibProviderImports, stdlibProviderOwnerModule,
+    stdlibProviderShims}) {
     const index = createGenerationIndex(module, sources)
 
     this.filename = filename
     this.language = language
+    this.module = module
+    this.program = program
+    this.programPaths = programPaths
+    this.callArgumentSuffix = callArgumentSuffix
+    this.callNameResolver = callNameResolver
+    this.methodStringEquality = methodStringEquality ?? false
     this.index = index
+    this.stdlibProviderEntries = stdlibProviderEntries
+    this.stdlibProviderPath = stdlibProviderPath
+    this.stdlibProviderPaths = stdlibProviderPaths ?? (stdlibProviderPath ? [stdlibProviderPath] : undefined)
+    this.stdlibProviderImports = stdlibProviderImports
+    this.stdlibProviderOwnerModule = stdlibProviderOwnerModule
+    this.stdlibProviderShims = stdlibProviderShims
+    const programRecords = program?.modules.flatMap((programModule) => programModule.records ?? []) ?? module.records ?? []
+    const programClasses = program?.modules.flatMap((programModule) => programModule.classes ?? []) ?? module.classes ?? []
+    const capabilityFailures = module.capabilities?.flatMap(({failures}) => failures) ?? []
+    const programErrors = program?.modules.flatMap((programModule) => [
+      ...(programModule.errors ?? []),
+      ...(programModule.capabilities?.flatMap(({failures}) => failures) ?? [])
+    ]) ?? [...module.errors ?? [], ...capabilityFailures]
+    const programFunctions = program?.modules.flatMap((programModule) => programModule.functions) ?? module.functions
+
+    this.records = new Map(programRecords.map((record) => [record.id, record]))
+    this.classes = new Map(programClasses.map((declaration) => [declaration.id, declaration]))
+    this.errors = new Map(programErrors.map((error) => [error.id, error]))
+    this.resources = new Map((module.capabilities?.flatMap(({resources}) => resources) ?? []).map((resource) => [resource.id, resource]))
+    this.effectOperations = new Map((module.capabilities?.flatMap(({operations}) => operations) ?? []).map((operation) => [operation.id, operation]))
+    this.effectOperationModules = new Map((module.capabilities?.flatMap((capability) =>
+      capability.operations.map((operation) => [operation.id, capability.authorityId])) ?? []))
+    this.fields = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, field])))
+    this.fieldRecords = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, record])))
+    this.privateFields = new Map(programClasses.flatMap((declaration) => declaration.fields.map((field) => [field.id, field])))
+    this.methods = new Map(programClasses.flatMap((declaration) => declaration.methods.map((method) => [method.id, method])))
+    this.typeParameters = new Map([...programRecords, ...programFunctions].flatMap((declaration) =>
+      (declaration.typeParameters ?? []).map((parameter) => [parameter.id, parameter])))
+    this.referenceClassEmissionDepth = 0
+    /** @type {Map<string, import("../semantic/types.js").SemanticProgramModule>} */
+    this.declarationModules = new Map(program?.modules.flatMap((programModule) => [
+      ...(programModule.records ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
+      ...(programModule.classes ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
+      ...(programModule.errors ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
+      ...programModule.functions.map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule]))
+    ]) ?? [])
     /** @type {string[]} */
     this.parts = []
     /** @type {import("../semantic/types.js").SemantifoldMappingSpan[]} */
@@ -25,6 +141,65 @@ export class SourceWriter {
     this.offset = 0
     this.line = 1
     this.column = 1
+    /** @type {Map<import("../semantic/types.js").Expression, string>} */
+    this.effectTemporaryNames = new Map()
+    /** @type {Map<import("../semantic/types.js").Expression, string>} */
+    this.effectReplacementNames = new Map()
+    /** @type {import("../semantic/types.js").Expression | undefined} */
+    this.effectDefinition = undefined
+    this.usedBindingNames = collectBindingNames(module)
+  }
+
+  /**
+   * Installs the effect expressions lowered immediately before the current statement.
+   * @param {import("../semantic/types.js").Expression[]} expressions - Ordered expressions.
+   * @returns {void}
+   */
+  planEffectReplacements(expressions) {
+    this.effectReplacementNames = new Map(expressions.map((expression) => [expression, this.effectTemporaryName(expression)]))
+  }
+
+  /**
+   * Allocates a collision-safe name for one deterministic effect site.
+   * @param {import("../semantic/types.js").Expression} expression - Effectful expression.
+   * @returns {string} Stable temporary name.
+   */
+  effectTemporaryName(expression) {
+    const known = this.effectTemporaryNames.get(expression)
+    if (known) return known
+    const site = typeof Reflect.get(expression, "effectSiteId") == "string"
+      ? Reflect.get(expression, "effectSiteId").slice("effect:".length) : String(this.effectTemporaryNames.size)
+    let name = `__semantifold_effect_${site}`
+
+    while (this.usedBindingNames.has(name)) name = `${name}_`
+    this.usedBindingNames.add(name)
+    this.effectTemporaryNames.set(expression, name)
+    return name
+  }
+
+  /**
+   * Returns the planned temporary replacement outside its own definition.
+   * @param {import("../semantic/types.js").Expression} expression - Candidate expression.
+   * @returns {string | undefined} Temporary name.
+   */
+  effectReplacementName(expression) {
+    return this.effectDefinition === expression ? undefined : this.effectReplacementNames.get(expression)
+  }
+
+  /**
+   * Emits one effect definition without recursively replacing itself.
+   * @param {import("../semantic/types.js").Expression} expression - Defined expression.
+   * @param {() => void} emit - Target expression emitter.
+   * @returns {void}
+   */
+  emitEffectDefinition(expression, emit) {
+    const previous = this.effectDefinition
+    this.effectDefinition = expression
+    try {
+      emit()
+    } finally {
+      this.effectDefinition = previous
+    }
   }
 
   /**
@@ -44,6 +219,374 @@ export class SourceWriter {
     return this.index.recordFor(node).path
   }
 
+  /**
+   * Resolves a validated nominal declaration identity for target emission.
+   * @param {string} declarationId - Semantic record identity.
+   * @returns {import("../semantic/types.js").RecordDeclaration} Record declaration.
+   */
+  recordForId(declarationId) {
+    const record = this.records.get(declarationId)
+
+    if (!record) throw new RangeError(`Unknown validated record identity '${declarationId}'.`)
+
+    return record
+  }
+
+  /**
+   * Returns the target spelling for a nominal record identity.
+   * @param {string} declarationId - Stable record declaration identity.
+   * @param {boolean} [valuePosition] - Whether the binding must exist at runtime.
+   * @returns {string} Target record spelling.
+   */
+  recordNameForId(declarationId, valuePosition = false) {
+    const record = this.recordForId(declarationId)
+    const owner = this.declarationModules.get(declarationId)
+    const imported = this.#programModule()?.imports.find((item) =>
+      item.declarationId == declarationId && (!valuePosition || !item.typeOnly))
+
+    if (this.program && owner && owner.id != Reflect.get(this.module, "id") && this.language == "ruby") {
+      return `${moduleClassName(owner.id)}::${record.name}`
+    }
+    if (imported && (this.language == "javascript" || this.language == "typescript" || this.language == "php")) {
+      return this.importNameFor(imported)
+    }
+
+    return record.name
+  }
+
+  /**
+   * Resolves one validated reference class.
+   * @param {string} declarationId - Stable class identity.
+   * @returns {import("../semantic/types.js").ClassDeclaration} Class declaration.
+   */
+  classForId(declarationId) {
+    const declaration = this.classes.get(declarationId)
+
+    if (!declaration) throw new RangeError(`Unknown validated reference class identity '${declarationId}'.`)
+
+    return declaration
+  }
+
+  /**
+   * Returns the target spelling of one reference class.
+   * @param {string} declarationId - Stable class identity.
+   * @returns {string} Target spelling.
+   */
+  classNameForId(declarationId) {
+    const declaration = this.classForId(declarationId)
+    const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId)
+
+    if (imported && (this.language == "javascript" || this.language == "typescript" || this.language == "php")) {
+      return this.importNameFor(imported)
+    }
+    return declaration.name
+  }
+
+  /**
+   * Resolves one validated owned-resource declaration.
+   * @param {string} resourceId - Stable resource identity.
+   * @returns {import("../semantic/types.js").EffectResourceDeclaration} Resource declaration.
+   */
+  resourceForId(resourceId) {
+    const resource = this.resources.get(resourceId)
+    if (!resource) throw new RangeError(`Unknown validated resource identity '${resourceId}'.`)
+    return resource
+  }
+
+  /**
+   * Resolves one validated capability operation declaration.
+   * @param {string} operationId - Stable operation identity.
+   * @returns {import("../semantic/types.js").EffectOperationDeclaration} Operation declaration.
+   */
+  effectOperationForId(operationId) {
+    const operation = this.effectOperations.get(operationId)
+    if (!operation) throw new RangeError(`Unknown validated effect operation identity '${operationId}'.`)
+    return operation
+  }
+
+  /**
+   * Resolves one validated private field.
+   * @param {string} fieldId - Stable private-field identity.
+   * @returns {import("../semantic/types.js").PrivateField} Field declaration.
+   */
+  privateFieldForId(fieldId) {
+    const field = this.privateFields.get(fieldId)
+
+    if (!field) throw new RangeError(`Unknown validated private field identity '${fieldId}'.`)
+
+    return field
+  }
+
+  /**
+   * Resolves one validated receiver method.
+   * @param {string} methodId - Stable method identity.
+   * @returns {import("../semantic/types.js").MethodDeclaration} Method declaration.
+   */
+  methodForId(methodId) {
+    const method = this.methods.get(methodId)
+
+    if (!method) throw new RangeError(`Unknown validated method identity '${methodId}'.`)
+
+    return method
+  }
+
+  /**
+   * Resolves one validated declaration-scoped type parameter.
+   * @param {string} parameterId - Stable type-parameter identity.
+   * @returns {import("../semantic/types.js").TypeParameter} Type parameter.
+   */
+  typeParameterForId(parameterId) {
+    const parameter = this.typeParameters.get(parameterId)
+
+    if (!parameter) throw new RangeError(`Unknown validated type parameter identity '${parameterId}'.`)
+
+    return parameter
+  }
+
+  /**
+   * Returns the validated nominal error declaration for an identity.
+   * @param {string} declarationId - Stable error identity.
+   * @returns {import("../semantic/types.js").ErrorDeclaration | import("../semantic/types.js").EffectFailureDeclaration} Error declaration.
+   */
+  errorForId(declarationId) {
+    const error = this.errors.get(declarationId)
+
+    if (!error) throw new RangeError(`Unknown validated error identity '${declarationId}'.`)
+
+    return error
+  }
+
+  /**
+   * Returns the target-visible spelling for one nominal error identity.
+   * @param {string} declarationId - Stable error identity.
+   * @returns {string} Target-visible name.
+   */
+  errorNameForId(declarationId) {
+    const error = this.errorForId(declarationId)
+    const owner = this.declarationModules.get(declarationId)
+    const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId)
+
+    if (this.program && owner && owner.id != Reflect.get(this.module, "id") && this.language == "ruby") {
+      return `${moduleClassName(owner.id)}::${error.name}`
+    }
+    if (imported && (this.language == "javascript" || this.language == "typescript" || this.language == "php")) {
+      return this.importNameFor(imported)
+    }
+
+    return owner ? error.name : this.capabilityNominalName(error.name)
+  }
+
+  /**
+   * Returns the target spelling for a nominal name owned by a compiler-authorized capability.
+   * PHP program entries live in a generated namespace while stdlib provider classes remain
+   * global, so PHP program mode fully qualifies capability names.
+   * @param {string} name - Declared nominal name.
+   * @returns {string} Target spelling.
+   */
+  capabilityNominalName(name) {
+    return this.program && this.language == "php" ? `\\${name}` : name
+  }
+
+  /**
+   * Returns the target spelling for a resolved function call.
+   * @param {import("../semantic/types.js").CallExpression} expression - Resolved call.
+   * @returns {string} Target call name.
+   */
+  callNameFor(expression) {
+    if (this.callNameResolver) return this.callNameResolver(expression)
+    const declarationId = expression.resolution?.declarationId
+    const owner = declarationId ? this.declarationModules.get(declarationId) : undefined
+    const imported = declarationId ? this.#programModule()?.imports.find((item) => item.declarationId == declarationId) : undefined
+
+    if (this.language == "java" && !this.program && this.referenceClassEmissionDepth > 0) return `Main.${expression.callee}`
+    if (!declarationId || !this.program || !owner || owner.id == Reflect.get(this.module, "id")) return expression.callee
+    if (this.language == "ruby" || this.language == "java") return `${moduleClassName(owner.id)}.${declarationName(owner, declarationId)}`
+    if (imported) return this.importNameFor(imported)
+
+    return declarationName(owner, declarationId)
+  }
+
+  /**
+   * Returns a target-container trailing argument for a semantic call.
+   * @param {import("../semantic/types.js").CallExpression} _expression - Resolved semantic call.
+   * @returns {string | undefined} Synthetic argument spelling, when configured.
+   */
+  callArgumentSuffixFor(_expression) {
+    return this.callArgumentSuffix
+  }
+
+  /**
+   * Reports whether string equality must avoid a target runtime helper.
+   * @returns {boolean} Whether to emit the platform String method.
+   */
+  usesMethodStringEquality() {
+    return this.methodStringEquality
+  }
+
+  /** Marks emission as occurring inside one top-level reference class. */
+  beginReferenceClassEmission() {
+    this.referenceClassEmissionDepth += 1
+  }
+
+  /** Ends one balanced top-level reference-class emission scope. */
+  endReferenceClassEmission() {
+    if (this.referenceClassEmissionDepth == 0) throw new RangeError("Reference-class emission scope is not active.")
+    this.referenceClassEmissionDepth -= 1
+  }
+
+  /**
+   * Returns the target-local binding for one resolved import.
+   * @param {import("../semantic/types.js").SemanticImport} imported - Resolved import.
+   * @returns {string} Emitted import name.
+   */
+  importNameFor(imported) {
+    const module = this.#programModule()
+
+    if (!this.program || !module) throw new RangeError("Import names require a validated semantic program.")
+
+    return programImportName(this.program, module, imported)
+  }
+
+  /**
+   * Reports whether one local declaration is exported by the current program module.
+   * @param {string | undefined} declarationId - Declaration identity.
+   * @returns {boolean} Whether it has a same-name program export.
+   */
+  isDirectlyExported(declarationId) {
+    const module = /** @type {Partial<import("../semantic/types.js").SemanticProgramModule>} */ (this.module)
+
+    return typeof declarationId == "string" && Boolean(module.exports?.some((item) =>
+      item.declarationId == declarationId && item.exportedName == declarationName(module, declarationId)))
+  }
+
+  /**
+   * Reports whether one export edge uses its declaration's emitted name.
+   * @param {import("../semantic/types.js").SemanticExport} exported - Current export edge.
+   * @returns {boolean} Whether this edge is represented by the declaration prefix.
+   */
+  isDirectExport(exported) {
+    return exported.exportedName == declarationName(this.module, exported.declarationId)
+  }
+
+  /**
+   * Reports whether one local declaration has any public program export.
+   * @param {string | undefined} declarationId - Declaration identity.
+   * @returns {boolean} Whether the declaration is exported.
+   */
+  isExported(declarationId) {
+    const module = /** @type {Partial<import("../semantic/types.js").SemanticProgramModule>} */ (this.module)
+
+    return typeof declarationId == "string" && Boolean(module.exports?.some((item) => item.declarationId == declarationId))
+  }
+
+  /**
+   * Returns whether this is the selected program entry module.
+   * @returns {boolean} Whether this writer owns the selected entry.
+   */
+  isProgramEntry() {
+    return this.program?.entryModule == Reflect.get(this.module, "id")
+  }
+
+  /**
+   * Returns the canonical class/module segment for a logical module identity.
+   * @param {string} moduleId - Logical module identity.
+   * @returns {string} Target class/module name.
+   */
+  programModuleName(moduleId) {
+    if (!this.program?.modules.some(({id}) => id == moduleId)) throw new RangeError(`Unknown program module '${moduleId}'.`)
+
+    return moduleClassName(moduleId)
+  }
+
+  /**
+   * Finds the current module in the complete program.
+   * @returns {import("../semantic/types.js").SemanticProgramModule | undefined} Current program module.
+   */
+  #programModule() {
+    if (!this.program) return undefined
+
+    return this.program.modules.find(({id}) => id == Reflect.get(this.module, "id"))
+  }
+
+  /**
+   * Returns a relative ESM/require specifier for a planned dependency artifact.
+   * @param {string} moduleId - Dependency module identity.
+   * @param {string} [extension] - Optional replacement extension.
+   * @returns {string} Relative POSIX specifier.
+   */
+  relativeModuleSpecifier(moduleId, extension) {
+    const targetPath = this.programPaths?.get(moduleId)
+
+    if (!targetPath) throw new RangeError(`Unknown planned module path '${moduleId}'.`)
+    const adjustedTarget = extension ? targetPath.replace(/\.[^./]+$/u, extension) : targetPath
+    const from = this.filename.split("/").slice(0, -1)
+    const to = adjustedTarget.split("/")
+    let common = 0
+
+    while (common < from.length && common < to.length && from[common] == to[common]) common++
+    const relative = [...from.slice(common).map(() => ".."), ...to.slice(common)].join("/")
+
+    return relative.startsWith(".") ? relative : `./${relative}`
+  }
+
+  /**
+   * Returns the protected native entry for one used stdlib provider operation.
+   * @param {import("../semantic/types.js").EffectOperationDeclaration} operation - Canonical operation declaration.
+   * @returns {string | undefined} Linked protected entry, or undefined when the operation stays inlined.
+   */
+  stdlibProviderEntryFor(operation) {
+    const module = this.effectOperationModules.get(operation.id)
+
+    return module === undefined ? undefined : this.stdlibProviderEntries?.[`${module}\u0000${operation.name}`]
+  }
+
+  /**
+   * Returns a relative specifier for the planned stdlib provider artifact.
+   * @param {string} [extension] - Optional replacement extension.
+   * @param {string} [providerPath] - One selected provider artifact path.
+   * @returns {string} Relative POSIX specifier.
+   */
+  stdlibProviderSpecifier(extension, providerPath) {
+    const targetPath = providerPath ?? this.stdlibProviderPath ?? this.stdlibProviderPaths?.[0]
+
+    if (!targetPath) throw new RangeError("A stdlib provider specifier requires a planned provider path.")
+    const adjustedTarget = extension ? targetPath.replace(/\.[^./]+$/u, extension) : targetPath
+    const from = this.filename.split("/").slice(0, -1)
+    const to = adjustedTarget.split("/")
+    let common = 0
+
+    while (common < from.length && common < to.length && from[common] == to[common]) common++
+    const relative = [...from.slice(common).map(() => ".."), ...to.slice(common)].join("/")
+
+    return relative.startsWith(".") ? relative : `./${relative}`
+  }
+
+  /**
+   * Resolves a validated field identity for target emission.
+   * @param {string} fieldId - Semantic field identity.
+   * @returns {import("../semantic/types.js").RecordField} Record field.
+   */
+  fieldForId(fieldId) {
+    const field = this.fields.get(fieldId)
+
+    if (!field) throw new RangeError(`Unknown validated field identity '${fieldId}'.`)
+
+    return field
+  }
+
+  /**
+   * Resolves the record declaration that owns a validated field identity.
+   * @param {string} fieldId - Semantic field identity.
+   * @returns {import("../semantic/types.js").RecordDeclaration} Owning record.
+   */
+  recordForFieldId(fieldId) {
+    const record = this.fieldRecords.get(fieldId)
+
+    if (!record) throw new RangeError(`Unknown validated field identity '${fieldId}'.`)
+
+    return record
+  }
+
   /**
    * Reports whether an exact parser-owned role range is available.
    * @param {import("../semantic/types.js").SemanticNode} node - Semantic node occurrence.

package/src/diagnostic.js

@@ -45,15 +45,17 @@ export class SemantifoldDiagnostic extends Error {
  * Throws a normalized parser diagnostic while preserving the parser error.
  * @param {import("./semantic/types.js").SemanticLanguage} language - Frontend language.
  * @param {unknown} error - Opaque parser error, narrowed immediately.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} [location] - Normalized parser failure range.
  * @returns {never} Always throws.
  */
-export function parseFailure(language, error) {
+export function parseFailure(language, error, location) {
   const cause = error instanceof Error ? error : new Error(String(error))
 
   throw new SemantifoldDiagnostic({
     cause,
     code: "PARSE_ERROR",
     language,
+    location,
     message: cause.message
   })
 }
@@ -104,7 +106,7 @@ export function semanticFailure(language, code, detail, location) {
 
 /**
  * Throws an unsupported backend-capability diagnostic.
- * @param {import("./semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {import("./semantic/types.js").BackendLanguage} language - Backend language or binary target.
  * @param {string} capability - Unsupported semantic capability.
  * @param {import("./semantic/types.js").SourceLocation | undefined} location - Semantic source location.
  * @returns {never} Always throws.

package/src/frontends/c.js

@@ -553,7 +553,8 @@ export class CReader {
       const bindings = new Map(inherited)
 
       for (const statement of block.statements) {
-        if (statement.kind == "LocalDeclaration") bindings.set(statement.name, statement.type.name)
+        if (statement.kind == "LocalDeclaration") bindings.set(statement.name,
+          /** @type {import("../semantic/types.js").TypeReference} */ (statement.type).name)
         if (statement.kind == "PrintStatement") {
           const expected = this.printTypes.get(statement)
 
@@ -567,7 +568,8 @@ export class CReader {
       }
     }
 
-    for (const declaration of module.functions) visit(declaration.body, new Map(declaration.parameters.map((parameter) => [parameter.name, parameter.type.name])))
+    for (const declaration of module.functions) visit(declaration.body, new Map(declaration.parameters.map((parameter) => [parameter.name,
+      /** @type {import("../semantic/types.js").TypeReference} */ (parameter.type).name])))
     visit(module.entryPoint.body, new Map())
   }
 

package/src/frontends/cpp.js

@@ -585,7 +585,8 @@ export class CppReader {
       const bindings = new Map(inherited)
 
       for (const statement of block.statements) {
-        if (statement.kind == "LocalDeclaration") bindings.set(statement.name, statement.type.name)
+        if (statement.kind == "LocalDeclaration") bindings.set(statement.name,
+          /** @type {import("../semantic/types.js").TypeReference} */ (statement.type).name)
         if (statement.kind == "PrintStatement") {
           const expected = this.printTypes.get(statement)
 
@@ -599,7 +600,8 @@ export class CppReader {
       }
     }
 
-    for (const declaration of module.functions) visit(declaration.body, new Map(declaration.parameters.map((parameter) => [parameter.name, parameter.type.name])))
+    for (const declaration of module.functions) visit(declaration.body, new Map(declaration.parameters.map((parameter) => [parameter.name,
+      /** @type {import("../semantic/types.js").TypeReference} */ (parameter.type).name])))
     visit(module.entryPoint.body, new Map())
   }
 

package/src/frontends/csharp.js

@@ -663,9 +663,11 @@ function validateCheckedArithmetic(module) {
    */
   const visitBlock = (block) => block.statements.forEach((statement) => {
     if (statement.kind == "LocalDeclaration") visitExpression(statement.initializer)
-    else if (statement.kind == "AssignmentStatement" || statement.kind == "PrintStatement" || statement.kind == "ReturnStatement") {
+    else if (statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement") {
       visitExpression(statement.expression)
-    } else {
+    } else if (statement.kind == "ReturnStatement") {
+      if (statement.expression) visitExpression(statement.expression)
+    } else if (statement.kind == "IfStatement") {
       visitExpression(statement.condition)
       visitBlock(statement.consequent)
       if (statement.alternate) visitBlock(statement.alternate)