{
  "schemaVersion": 1,
  "productId": "topaz",
  "languageVersion": "topaz-5.21",
  "revision": "0b40731208ac5831fe8765f2b45035c0923db8d0",
  "files": [
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker.tpz",
      "language": "topaz",
      "bytes": 10171,
      "sha256": "e39ee31cd9d75f98f8000f3b58cb80d7659f63c3f1e56f49f56752facbc8b959",
      "content": "// Public type-checking facade for the embedded self compiler.\n// Checker leaves own formation and inference; this file wires their services,\n// runs the phases in order, and exposes only check to the package entry.\n\nimport types {\n  CheckResult,\n  PreviewTypedCall,\n  PreviewTypedCapture,\n  PreviewTypedNode,\n  ResolveResult,\n  SyntaxNode,\n}\nimport checker_types { TypeValue }\nimport checker.model {\n  CheckerRequest,\n  CheckerResponse,\n  CheckerService,\n  CheckerState,\n  ModuleSyntax,\n  constructor,\n  emptyType,\n  functionType,\n  primitive,\n}\nimport checker.type_algebra {\n  flattenedHasHole,\n  resolvedFlatType,\n  stringJoin,\n  typeEqual,\n  typeText,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  child,\n  children,\n  moduleSyntax,\n  spanKey,\n  text,\n  unwrapExport,\n}\nimport checker.nominals {\n  collectProtocols,\n  fillNominals,\n  predeclareNominals,\n}\nimport checker.protocols_methods {\n  collectProtocolImpls,\n  collectReceiverImpls,\n  functionDeclaration,\n  predeclareFunctions,\n}\nimport checker.members_capabilities { gateCollectionKey }\nimport checker.diagnostics_derives { checkDerives }\nimport checker.call_facts {\n  builtinNamespaceObject,\n  diagnoseUnboundReferences,\n}\nimport checker.expression_control { inferExpression }\nimport checker.statements {\n  checkBlock,\n  checkBlockExpected,\n}\nimport checker.bodies_captures {\n  checkFunctionBodies,\n  checkFunctionDeclaration,\n  checkerIndexes,\n  deriveCaptures,\n  diagnoseLispexRuleFactoryEscapes,\n  initialCheckerState,\n}\n\nfunction dispatchCheckerService(\n  state: CheckerState,\n  request: CheckerRequest,\n) -> CheckerResponse {\n  match request.kind {\n    case \"check-function\" => {\n      match state.modules.get(request.moduleIndex) {\n        case Some(module) => checkFunctionDeclaration(\n          dispatchCheckerService,\n          state,\n          module,\n          request.node,\n        )\n        case None => ()\n      }\n      CheckerResponse { typeValue: emptyType(\"unknown\"), boolValue: false }\n    }\n    case \"infer-expression\" => CheckerResponse {\n      typeValue: inferExpression(\n        dispatchCheckerService,\n        state,\n        request.moduleIndex,\n        request.source,\n        request.node,\n      ),\n      boolValue: false,\n    }\n    case \"builtin-namespace-object\" => CheckerResponse {\n      typeValue: emptyType(\"unknown\"),\n      boolValue: builtinNamespaceObject(\n        dispatchCheckerService,\n        state,\n        request.moduleIndex,\n        request.source,\n        request.node,\n      ),\n    }\n    case \"check-block\" => CheckerResponse {\n      typeValue: checkBlock(\n        dispatchCheckerService,\n        state,\n        request.moduleIndex,\n        request.source,\n        request.node,\n      ),\n      boolValue: false,\n    }\n    case \"check-block-expected\" => CheckerResponse {\n      typeValue: checkBlockExpected(\n        dispatchCheckerService,\n        state,\n        request.moduleIndex,\n        request.source,\n        request.node,\n        request.typeValue,\n      ),\n      boolValue: false,\n    }\n    case \"gate-collection-key\" => {\n      gateCollectionKey(\n        dispatchCheckerService,\n        state,\n        request.moduleIndex,\n        request.node,\n        request.typeValue,\n      )\n      CheckerResponse { typeValue: emptyType(\"unknown\"), boolValue: false }\n    }\n    case _ => CheckerResponse { typeValue: emptyType(\"unknown\"), boolValue: false }\n  }\n}\n\nfunction checkerService() -> CheckerService {\n  dispatchCheckerService\n}\n\nfunction runCheckerPhases(service: CheckerService, state: CheckerState) -> () {\n  predeclareNominals(state)\n  fillNominals(service, state)\n  collectProtocols(service, state)\n  collectReceiverImpls(service, state)\n  collectProtocolImpls(service, state)\n  checkDerives(state)\n  predeclareFunctions(service, state)\n  diagnoseUnboundReferences(state)\n  checkFunctionBodies(service, state)\n  diagnoseEntryPointSignatures(state)\n  diagnoseLispexRuleFactoryEscapes(state)\n  deriveCaptures(state)\n  ()\n}\n\nfunction checkerResult(state: CheckerState) -> CheckResult {\n  let mut nodes: Array<PreviewTypedNode> = []\n  for node in state.nodes {\n    let resolved = resolvedFlatType(node.typeValue, state.inferenceSolutions)\n    nodes.push(PreviewTypedNode {\n      ...node,\n      typeValue: resolved,\n      ambient: flattenedHasHole(resolved),\n    })\n  }\n  let mut calls: Array<PreviewTypedCall> = []\n  for call in state.calls {\n    let calleeType = resolvedFlatType(call.calleeType, state.inferenceSolutions)\n    let resultType = resolvedFlatType(call.resultType, state.inferenceSolutions)\n    calls.push(PreviewTypedCall {\n      ...call,\n      calleeType: calleeType,\n      resultType: resultType,\n      ambient: flattenedHasHole(calleeType) || flattenedHasHole(resultType),\n    })\n  }\n  let mut captures: Array<PreviewTypedCapture> = []\n  for capture in state.captures {\n    let resolved = resolvedFlatType(capture.typeValue, state.inferenceSolutions)\n    captures.push(PreviewTypedCapture {\n      ...capture,\n      typeValue: resolved,\n      ambient: flattenedHasHole(resolved),\n    })\n  }\n  CheckResult {\n    nodes: nodes,\n    calls: calls,\n    captures: captures,\n    diagnostics: state.diagnostics,\n  }\n}\n\n// The documented command-line entry point is\n// `export function main(args: Array<string>, stdin: string) -> Result<int, string>`,\n// so the entry module's exported `main` has exactly one admitted signature.\nfunction explicitMainType() -> TypeValue {\n  functionType(\n    [constructor(\"Array\", [primitive(\"string\")]), primitive(\"string\")],\n    [],\n    constructor(\"Result\", [primitive(\"int\"), primitive(\"string\")]),\n  )\n}\n\nfunction exportedMainNameNode(module: ModuleSyntax, statement: SyntaxNode) -> Option<SyntaxNode> {\n  if statement.kind != \"statement/export\" {\n    return None\n  }\n  let declaration = match functionDeclaration(unwrapExport(statement)) {\n    case Some(value) => value\n    case None => return None\n  }\n  let nameNode = match child(declaration, \"name\") {\n    case Some(value) => value\n    case None => return None\n  }\n  if text(module.source, nameNode) != \"main\" {\n    return None\n  }\n  Some(nameNode)\n}\n\nfunction diagnoseExplicitMainSignature(\n  state: CheckerState,\n  module: ModuleSyntax,\n  nameNode: SyntaxNode,\n) -> () {\n  let definitionIndex = match state.functionIndexes.get(spanKey(\n    module.moduleIndex,\n    nameNode.lo,\n    nameNode.hi,\n  )) {\n    case Some(index) => index\n    case None => -1\n  }\n  let definition = match state.functions.get(definitionIndex) {\n    case Some(value) => value\n    case None => return ()\n  }\n  let mut defaulted = false\n  for value in definition.parameterDefaults {\n    if value {\n      defaulted = true\n    }\n  }\n  let expected = explicitMainType()\n  let actual = functionType(\n    definition.parameterTypes,\n    definition.variadic,\n    definition.result,\n  )\n  if definition.typeParameters.length == 0 && !defaulted && typeEqual(actual, expected) {\n    return ()\n  }\n  addDiagnostic(\n    state,\n    module.moduleIndex,\n    \"TPZ5022\",\n    \"`export function main` must be non-generic and have signature `{typeText(expected)}`; found `{typeText(actual)}`\",\n    \"\",\n    nameNode,\n  )\n}\n\n// Only the entry module owns the command-line entry point; an exported `main`\n// anywhere else is an ordinary function.\nfunction diagnoseEntryPointSignatures(state: CheckerState) -> () {\n  for module in state.modules {\n    let entry = match state.resolved.modules.get(module.moduleIndex) {\n      case Some(resolved) => resolved.entry\n      case None => false\n    }\n    if !entry {\n      continue\n    }\n    for statement in module.root.children {\n      match exportedMainNameNode(module, statement) {\n        case Some(nameNode) => diagnoseExplicitMainSignature(state, module, nameNode)\n        case None => ()\n      }\n    }\n  }\n  ()\n}\n\nfunction externReplayError(\n  modules: Array<string>,\n  errors: Array<string>,\n  target: string,\n) -> Option<string> {\n  let mut index = 0\n  for module in modules {\n    if module == target {\n      return errors.get(index)\n    }\n    index += 1\n  }\n  None\n}\n\nfunction diagnoseExternReplayImport(\n  state: CheckerState,\n  module: ModuleSyntax,\n  statement: SyntaxNode,\n  externReplayModules: Array<string>,\n  externReplayErrors: Array<string>,\n) -> () {\n  let item = match child(statement, \"import\") {\n    case Some(value) => value\n    case None => return ()\n  }\n  let path = match child(item, \"path\") {\n    case Some(value) => value\n    case None => return ()\n  }\n  let mut segments: Array<string> = []\n  for segment in children(path, \"segments\") {\n    segments.push(text(module.source, segment))\n  }\n  let target = stringJoin(segments, \".\")\n  match externReplayError(\n    externReplayModules,\n    externReplayErrors,\n    target,\n  ) {\n    case Some(error) => addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5032\",\n      \"extern module `{target}` has an invalid deterministic replay binding: {error}\",\n      \"\",\n      path,\n    )\n    case None => ()\n  }\n}\n\nfunction diagnoseExternReplayErrors(\n  state: CheckerState,\n  externReplayModules: Array<string>,\n  externReplayErrors: Array<string>,\n) -> Result<(), string> {\n  if externReplayModules.length != externReplayErrors.length {\n    return Err(\"checker extern replay fact columns differ in length\")\n  }\n  for module in state.modules {\n    for statement in module.root.children {\n      if statement.kind == \"statement/import\" {\n        diagnoseExternReplayImport(\n          state,\n          module,\n          statement,\n          externReplayModules,\n          externReplayErrors,\n        )\n      }\n    }\n  }\n  Ok(())\n}\n\n// Runs formation and body phases, preserving diagnostic and observation order.\nexport function check(\n  resolved: ResolveResult,\n  externReplayModules: Array<string>,\n  externReplayErrors: Array<string>,\n  maxAstNodes: int,\n  maxAstDepth: int,\n  languageMode: string = \"topaz-5.20\",\n) -> Result<CheckResult, string> {\n  let service = checkerService()\n  let modules = moduleSyntax(resolved, maxAstNodes, maxAstDepth)?\n  let state = initialCheckerState(resolved, modules, checkerIndexes(resolved), languageMode)\n  diagnoseExternReplayErrors(state, externReplayModules, externReplayErrors)?\n  runCheckerPhases(service, state)\n  Ok(checkerResult(state))\n}\n",
      "sourceSha256": "e39ee31cd9d75f98f8000f3b58cb80d7659f63c3f1e56f49f56752facbc8b959"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/bodies_captures.tpz",
      "language": "topaz",
      "bytes": 33705,
      "sha256": "620b57f69d6133ad274e7314f84c9f52e96f445d6a483f9152c3e294595df704",
      "content": "// Function-body checking, initialization order, and closure capture derivation.\n// Expression recursion enters through CheckerService; this leaf owns body\n// sequencing and returns indexes used by the checker facade.\n\nimport types {\n  PreviewResolvedReference,\n  PreviewTypedCall,\n  PreviewTypedCapture,\n  ResolveResult,\n  SyntaxNode,\n}\nimport checker.model {\n  CaptureTarget,\n  CheckerService,\n  CheckerState,\n  constantRenderEpoch,\n  advanceConstantRenderEpoch,\n  restoreConstantRenderEpoch,\n  FunctionDefinition,\n  ModuleSyntax,\n  ReturnExpectation,\n  TYPE_BOUND_INDEX_STRIDE,\n  constructor,\n  emptyType,\n  functionType,\n  primitive,\n}\nimport checker.type_algebra {\n  flattenType,\n  hasHole,\n  joinedTypes,\n  projectionType,\n  stripProjectionTypes,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  addNode,\n  attribute,\n  bindSymbol,\n  boolAttribute,\n  child,\n  children,\n  containsString,\n  declarationFor,\n  definitionNameKey,\n  emptyStringIntMap,\n  moduleIdentityAt,\n  referenceFor,\n  referenceTargetsPendingFunction,\n  recordDefinitionIndex,\n  replaceNodeType,\n  scopeFor,\n  scopeKey,\n  spanKey,\n  text,\n  typedNodeIndex,\n  unwrapExport,\n}\nimport checker.protocols_methods { functionDeclaration }\nimport checker.members_capabilities {\n  bindingIndex,\n}\nimport checker.patterns { patternBindingNodes }\nimport checker.call_facts {\n  checkExpressionExpected,\n}\nimport checker.expression_core { blockTerminates }\nimport checker.statements {\n  checkBlock,\n  checkBlockExpected,\n  checkStatement,\n  constantExpressionShape,\n  foldConstantInteger,\n  precheckTopLevelBindings,\n}\n\nfunction checkRecordDefaults(service: CheckerService, state: CheckerState, module: ModuleSyntax) -> () {\n  for statement in module.root.children {\n    let item = unwrapExport(statement)\n    if item.kind == \"statement/record\" {\n      let recordName = match child(item, \"name\") {\n        case Some(found) => text(module.source, found)\n        case None => \"\"\n      }\n      // Reuse the formed field types, including each generic parameter's origin.\n      let definition = state.records.get(recordDefinitionIndex(\n        state,\n        module.moduleIndex,\n        recordName,\n      ))\n      for field in children(item, \"fields\") {\n        match child(field, \"default\") {\n          case Some(found) => {\n            let fieldName = match child(field, \"name\") {\n              case Some(name) => text(module.source, name)\n              case None => \"\"\n            }\n            let mut expected = emptyType(\"unknown\")\n            match definition {\n              case Some(recordDefinition) => {\n                for declared in recordDefinition.fields {\n                  if declared.name == fieldName {\n                    expected = declared.typeValue\n                  }\n                };\n              }\n              case None => ()\n            }\n            let _ = checkExpressionExpected(\n              service,\n              state,\n              module.moduleIndex,\n              module.source,\n              found,\n              expected,\n            )\n          }\n          case None => ()\n        }\n      }\n    }\n  }\n  ()\n}\n\nfunction checkFunctionDefault(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> () {\n  if !constantExpressionShape(state, moduleIndex, node, true) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"`const` initializers must be constant expressions (§4)\",\n      \"\",\n      node,\n    )\n    return ()\n  }\n  let saved = constantRenderEpoch(state)\n  advanceConstantRenderEpoch(state)\n  let _ = foldConstantInteger(state, moduleIndex, node)\n  restoreConstantRenderEpoch(state, saved)\n  ()\n}\n\nfunction callsPendingReturnSince(\n  state: CheckerState,\n  firstCall: int,\n) -> bool {\n  let mut index = firstCall\n  while index < state.calls.length {\n    match state.calls.get(index) {\n      case Some(call) => match referenceFor(\n        state,\n        call.moduleIndex,\n        call.calleeLo,\n        call.calleeHi,\n      ) {\n        case Some(reference) => if referenceTargetsPendingFunction(\n          state,\n          reference,\n        ) {\n          return true\n        }\n        case None => ()\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  false\n}\n\nexport function checkFunctionDeclaration(\n  service: CheckerService, state: CheckerState, module: ModuleSyntax, declaration: SyntaxNode,\n) -> () {\n  let saved = constantRenderEpoch(state)\n  advanceConstantRenderEpoch(state)\n  checkFunctionDeclarationInner(service, state, module, declaration)\n  restoreConstantRenderEpoch(state, saved)\n}\n\nfunction checkFunctionDeclarationInner(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  declaration: SyntaxNode,\n) -> () {\n  let nameNode = match child(declaration, \"name\") {\n    case Some(found) => found\n    case None => declaration\n  }\n  let mut exported = false\n  for published in state.resolved.exports {\n    if published.moduleIndex == module.moduleIndex && published.namespace == \"value\" &&\n      published.declarationLo == nameNode.lo && published.declarationHi == nameNode.hi {\n      exported = true\n    }\n  }\n  let mut seenBounds: Array<string> = []\n  for bound in children(declaration, \"typeParameterBounds\") {\n    let protocol = text(module.source, bound)\n    if exported && protocol != \"Eq\" && protocol != \"Order\" && protocol != \"Show\" && protocol != \"JSON\" {\n      addDiagnostic(state, module.moduleIndex, \"TPZ5524\",\n        \"exported functions cannot expose module-local protocol bound `{protocol}`\", \"\", bound)\n    }\n    let key = \"{bound.index / TYPE_BOUND_INDEX_STRIDE}:{protocol}\"\n    if containsString(seenBounds, key) {\n      addDiagnostic(state, module.moduleIndex, \"TPZ5523\",\n        \"protocol bound `{protocol}` is repeated for the same type parameter\", \"\", bound)\n    } else {\n      seenBounds.push(key)\n    }\n  }\n  let definitionIndex = match state.functionIndexes.get(spanKey(\n    module.moduleIndex,\n    nameNode.lo,\n    nameNode.hi,\n  )) {\n    case Some(index) => index\n    case None => -1\n  }\n  match state.functions.get(definitionIndex) {\n    case Some(definition) => {\n      let mut fixedIndex = 0\n      for parameter in children(declaration, \"parameters\") {\n        let name = match child(parameter, \"name\") {\n          case Some(found) => found\n          case None => parameter\n        }\n        let parameterType = if boolAttribute(parameter, \"variadic\") {\n          constructor(\"Array\", [match definition.variadic.get(0) {\n            case Some(found) => found\n            case None => emptyType(\"unknown\")\n          }])\n        } else {\n          match definition.parameterTypes.get(fixedIndex) {\n            case Some(found) => found\n            case None => emptyType(\"unknown\")\n          }\n        }\n        if !boolAttribute(parameter, \"variadic\") {\n          fixedIndex += 1\n        }\n        bindSymbol(\n          state,\n          module.moduleIndex,\n          name.lo,\n          name.hi,\n          text(module.source, name),\n          parameterType,\n          false,\n        )\n        addNode(state, module.moduleIndex, \"binding\", name, parameterType)\n        match child(parameter, \"default\") {\n          case Some(found) => {\n            let _ = checkExpressionExpected(\n              service,\n              state,\n              module.moduleIndex,\n              module.source,\n              found,\n              parameterType,\n            )\n            checkFunctionDefault(state, module.moduleIndex, found)\n          }\n          case None => ()\n        }\n      }\n      match child(declaration, \"body\") {\n        case Some(body) => {\n          let inferredResult = definition.result.kind == \"unknown\"\n          let firstCall = state.calls.length\n          let mut activeFunctions = state.activeFunctions\n          activeFunctions.push(definitionIndex)\n          let mut loopFloors = state.loopFloors\n          loopFloors.push(state.loopFrames.length)\n          let mut expectedReturns = state.expectedReturns\n          expectedReturns.push(ReturnExpectation { typeValue: definition.result, checkResult: true })\n          let mut returnJoins = state.returnJoins\n          returnJoins.push([])\n          let bodyResult = if inferredResult {\n            checkBlock(\n              service,\n              state,\n              module.moduleIndex,\n              module.source,\n              body,\n            )\n          } else {\n            checkBlockExpected(\n              service,\n              state,\n              module.moduleIndex,\n              module.source,\n              body,\n              definition.result,\n            )\n          }\n          let mut returns = match returnJoins.get(returnJoins.length - 1) {\n            case Some(found) => found\n            case None => []\n          }\n          returnJoins.pop()\n          expectedReturns.pop()\n          loopFloors.pop()\n          activeFunctions.pop()\n          if inferredResult {\n            match child(body, \"tail\") {\n              case Some(_) => returns.push(bodyResult)\n              case None => if !blockTerminates(body) {\n                returns.push(primitive(\"unit\"))\n              }\n            }\n            let mut result = if returns.length == 0 {\n              primitive(\"unit\")\n            } else {\n              let mut unresolved = false\n              for found in returns {\n                if hasHole(found) {\n                  unresolved = true\n                }\n              }\n              if unresolved {\n                emptyType(\"unknown\")\n              } else {\n                joinedTypes(state, returns, true)\n              }\n            }\n            if projectionType(result) {\n              addDiagnostic(\n                state,\n                module.moduleIndex,\n                \"TPZ5022\",\n                \"cannot infer a return type for `{definition.name}`: it returns a destructured generic value with no nameable type — annotate the return type\",\n                \"\",\n                nameNode,\n              )\n              result = stripProjectionTypes(result)\n            }\n            if result.kind == \"unknown\" &&\n              callsPendingReturnSince(state, firstCall) {\n              addDiagnostic(\n                state,\n                module.moduleIndex,\n                \"TPZ5022\",\n                \"`{definition.name}` is (mutually) recursive: declare its return type (§7)\",\n                \"\",\n                nameNode,\n              )\n            }\n            let mut pending = state.pendingFunctions\n            pending[definitionIndex] = false\n            let patched = FunctionDefinition {\n              ...definition,\n              result: result,\n            }\n            let mut functions = state.functions\n            functions[definitionIndex] = patched\n            let functionValue = functionType(\n              definition.parameterTypes,\n              definition.variadic,\n              result,\n            )\n            bindSymbol(\n              state,\n              module.moduleIndex,\n              nameNode.lo,\n              nameNode.hi,\n              definition.name,\n              functionValue,\n              false,\n            )\n            replaceNodeType(\n              state,\n              module.moduleIndex,\n              \"declaration\",\n              nameNode,\n              functionValue,\n            )\n          }\n        }\n        case None => ()\n      }\n      // Publish the declaration fact after checking its body. Signatures used\n      // during recursion are already available in symbols and functions.\n      addNode(\n        state,\n        module.moduleIndex,\n        \"declaration\",\n        nameNode,\n        functionType(\n          definition.parameterTypes,\n          definition.variadic,\n          definition.result,\n        ),\n      )\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction staticTopLevelItem(item: SyntaxNode) -> bool {\n  item.kind == \"statement/function\" ||\n    item.kind == \"statement/impl\" ||\n    item.kind == \"statement/record\" ||\n    item.kind == \"statement/enum\" ||\n    item.kind == \"statement/newtype\" ||\n    item.kind == \"statement/type-alias\" ||\n    item.kind == \"statement/protocol\" ||\n    item.kind == \"statement/const\" ||\n    item.kind == \"statement/import\"\n}\n\nfunction checkImplBodies(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  statement: SyntaxNode,\n) -> () {\n  let item = unwrapExport(statement)\n  if item.kind != \"statement/impl\" {\n    return ()\n  }\n  for method in children(item, \"methods\") {\n    match child(method, \"declaration\") {\n      case Some(declaration) => checkFunctionDeclaration(\n        service,\n        state,\n        module,\n        declaration,\n      )\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction topLevelRuntimeBindingIndexes(\n  module: ModuleSyntax,\n) -> Map<int, int> {\n  let mut indexes: Map<int, int> = map {}\n  let mut index = 0\n  for statement in module.root.children {\n    let item = unwrapExport(statement)\n    match functionDeclaration(item) {\n      case Some(declaration) => match child(declaration, \"name\") {\n        case Some(name) => indexes.insert(name.lo, index)\n        case None => ()\n      }\n      case None => if item.kind == \"statement/let\" {\n        match child(item, \"pattern\") {\n          case Some(pattern) => for binding in patternBindingNodes(pattern) {\n            indexes.insert(binding.lo, index)\n          }\n          case None => ()\n        }\n      } else {\n        ()\n      }\n    }\n    index += 1\n  }\n  indexes\n}\n\nfunction initializationReferenceViolation(\n  state: CheckerState,\n  module: ModuleSyntax,\n  runtimeBindingIndexes: Map<int, int>,\n  cutoff: int,\n  node: SyntaxNode,\n) -> bool {\n  match referenceFor(state, module.moduleIndex, node.lo, node.hi) {\n    case Some(reference) => if reference.targetModuleIndex == module.moduleIndex {\n      match runtimeBindingIndexes.get(reference.targetLo) {\n        case Some(target) => target >= cutoff\n        case None => false\n      }\n    } else {\n      false\n    }\n    case None => false\n  }\n}\n\nfunction initializationChildIsImmediate(\n  parent: SyntaxNode,\n  found: SyntaxNode,\n) -> bool {\n  // Conditional children are delayed under the same DIRECT rule as branch,\n  // arm, loop, lambda, function, defer, and concurrent bodies.\n  let kind = parent.kind\n  if kind == \"statement/function\" || kind == \"statement/defer\" ||\n    kind == \"statement/break\" || kind == \"statement/continue\" ||\n    kind == \"expression/lambda\" || kind == \"expression/loop\" {\n    return false\n  }\n  if kind == \"statement/while\" || kind == \"expression/if\" {\n    return found.field == \"condition\"\n  }\n  if kind == \"expression/match\" {\n    return found.field == \"scrutinee\"\n  }\n  if kind == \"expression/for\" || kind == \"comprehension-clause/for\" {\n    return found.field == \"iterator\"\n  }\n  if kind == \"expression/comprehension\" {\n    return found.field == \"clauses\" && found.index == 0 &&\n      found.kind == \"comprehension-clause/for\"\n  }\n  if kind == \"expression/concurrent\" {\n    return found.field == \"timeout\"\n  }\n  if kind == \"expression/binary\" && found.field == \"right\" {\n    let operator = attribute(parent, \"operator\")\n    return operator != \"and\" && operator != \"or\" && operator != \"coalesce\"\n  }\n  if kind == \"expression/call\" && found.field == \"arguments\" {\n    match child(parent, \"callee\") {\n      case Some(callee) => return callee.kind != \"expression/optional-access\"\n      case None => ()\n    }\n  }\n  if kind == \"statement/let\" || kind == \"statement/const\" ||\n    kind == \"statement/return\" {\n    return found.field == \"value\"\n  }\n  if kind == \"statement/assign\" {\n    return found.field == \"target\" || found.field == \"value\"\n  }\n  if kind == \"statement/using\" {\n    return found.field == \"value\" || found.field == \"body\"\n  }\n  if kind.startsWith(\"statement/\") {\n    return kind == \"statement/expression\"\n  }\n  true\n}\n\nfunction initializationViolation(\n  state: CheckerState,\n  module: ModuleSyntax,\n  runtimeBindingIndexes: Map<int, int>,\n  cutoff: int,\n  node: SyntaxNode,\n) -> Option<SyntaxNode> {\n  if node.kind == \"expression/identifier\" {\n    return if initializationReferenceViolation(\n      state,\n      module,\n      runtimeBindingIndexes,\n      cutoff,\n      node,\n    ) {\n      Some(node)\n    } else {\n      None\n    }\n  }\n  for found in node.children {\n    if initializationChildIsImmediate(node, found) {\n      match initializationViolation(\n        state,\n        module,\n        runtimeBindingIndexes,\n        cutoff,\n        found,\n      ) {\n        case Some(violation) => return Some(violation)\n        case None => ()\n      }\n    }\n  }\n  None\n}\n\nfunction reportInitializationViolation(\n  state: CheckerState,\n  module: ModuleSyntax,\n  violation: Option<SyntaxNode>,\n) -> () {\n  match violation {\n    case Some(found) => addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5002\",\n      \"`{text(module.source, found)}` is not bound\",\n      \"\",\n      found,\n    )\n    case None => ()\n  }\n}\n\nfunction checkTopLevelInitializationOrder(\n  state: CheckerState,\n  module: ModuleSyntax,\n) -> () {\n  let runtimeBindingIndexes = topLevelRuntimeBindingIndexes(module)\n  let mut cutoff = 0\n  for statement in module.root.children {\n    let item = unwrapExport(statement)\n    if item.kind == \"statement/let\" {\n      match child(item, \"value\") {\n        case Some(found) => reportInitializationViolation(\n          state,\n          module,\n          initializationViolation(\n            state,\n            module,\n            runtimeBindingIndexes,\n            cutoff,\n            found,\n          ),\n        )\n        case None => ()\n      }\n    } else if item.kind == \"statement/using\" {\n      match child(item, \"value\") {\n        case Some(found) => reportInitializationViolation(\n          state,\n          module,\n          initializationViolation(\n            state,\n            module,\n            runtimeBindingIndexes,\n            cutoff,\n            found,\n          ),\n        )\n        case None => ()\n      }\n      match child(item, \"body\") {\n        case Some(found) => reportInitializationViolation(\n          state,\n          module,\n          initializationViolation(\n            state,\n            module,\n            runtimeBindingIndexes,\n            cutoff,\n            found,\n          ),\n        )\n        case None => ()\n      }\n    } else if item.kind == \"statement/assign\" {\n      for field in [\"target\", \"value\"] {\n        match child(item, field) {\n          case Some(found) => reportInitializationViolation(\n            state,\n            module,\n            initializationViolation(\n              state,\n              module,\n              runtimeBindingIndexes,\n              cutoff,\n              found,\n            ),\n          )\n          case None => ()\n        }\n      }\n    } else if item.kind == \"statement/while\" {\n      match child(item, \"condition\") {\n        case Some(found) => reportInitializationViolation(\n          state,\n          module,\n          initializationViolation(\n            state,\n            module,\n            runtimeBindingIndexes,\n            cutoff,\n            found,\n          ),\n        )\n        case None => ()\n      }\n    } else if item.kind == \"statement/expression\" ||\n      item.kind == \"statement/return\" {\n      for found in item.children {\n        reportInitializationViolation(\n          state,\n          module,\n          initializationViolation(\n            state,\n            module,\n            runtimeBindingIndexes,\n            cutoff,\n            found,\n          ),\n        )\n      }\n    }\n    cutoff += 1\n  }\n  ()\n}\n\nfunction checkModuleBodies(service: CheckerService, state: CheckerState, module: ModuleSyntax) -> () {\n  checkRecordDefaults(service, state, module)\n  for statement in module.root.children {\n    checkImplBodies(service, state, module, statement)\n    match functionDeclaration(unwrapExport(statement)) {\n      case Some(declaration) => checkFunctionDeclaration(\n        service,\n        state,\n        module,\n        declaration,\n      )\n      case None => if !staticTopLevelItem(unwrapExport(statement)) {\n        checkStatement(\n          service,\n          state,\n          module.moduleIndex,\n          module.source,\n          statement,\n        )\n      }\n    }\n  }\n  checkTopLevelInitializationOrder(state, module)\n  ()\n}\n\nexport function checkFunctionBodies(service: CheckerService, state: CheckerState) -> () {\n  // The resolver supplies dependency order, so inferred exported bindings\n  // are available before a consumer checks its own initializers.\n  let ordered = state.modules\n  for module in ordered {\n    precheckTopLevelBindings(service, state, module)\n  }\n  advanceConstantRenderEpoch(state)\n  for module in ordered {\n    checkModuleBodies(service, state, module)\n  }\n  ()\n}\n\nfunction captureScopeAncestors(\n  state: CheckerState,\n  indexes: Map<string, Set<int>>,\n  moduleIndex: int,\n  ordinal: int,\n) -> Set<int> {\n  let key = scopeKey(moduleIndex, ordinal)\n  match indexes.get(key) {\n    case Some(found) => return found\n    case None => ()\n  }\n  let mut ancestors: Set<int> = set {}\n  let mut current = ordinal\n  while current >= 0 {\n    ancestors.add(current)\n    match scopeFor(state, moduleIndex, current) {\n      case Some(scope) => {\n        current = scope.parentOrdinal\n      }\n      case None => {\n        current = -1\n      }\n    }\n  }\n  let mut target = indexes\n  target.insert(key, ancestors)\n  ancestors\n}\n\nfunction namespaceCaptureTarget(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> Option<CaptureTarget> {\n  let segments = reference.name.split(\".\")\n  if segments.length < 2 {\n    return None\n  }\n  let alias = match segments.get(0) {\n    case Some(found) => found\n    case None => return None\n  }\n  let index = match state.namespaceImportIndexes.get(\n      definitionNameKey(reference.moduleIndex, alias),\n  ) {\n    case Some(found) => found\n    case None => return None\n  }\n  let declaration = match state.resolved.declarations.get(index) {\n    case Some(found) => found\n    case None => return None\n  }\n  let unknown = emptyType(\"unknown\")\n  Some(CaptureTarget {\n    declaration: declaration,\n    name: declaration.name,\n    typeValue: flattenType(unknown),\n    ambient: true,\n  })\n}\n\nfunction captureTargetForReference(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> Option<CaptureTarget> {\n  if reference.namespace != \"value\" {\n    return None\n  }\n  if reference.role == \"namespace-member\" {\n    return namespaceCaptureTarget(state, reference)\n  }\n  if reference.targetModuleIndex != reference.moduleIndex {\n    return None\n  }\n  let bindingIndex = typedNodeIndex(\n    state,\n    reference.targetModuleIndex,\n    \"binding\",\n    reference.targetLo,\n    reference.targetHi,\n  )\n  let declarationIndex = typedNodeIndex(\n    state,\n    reference.targetModuleIndex,\n    \"declaration\",\n    reference.targetLo,\n    reference.targetHi,\n  )\n  let declaredIndex = if bindingIndex > declarationIndex {\n    bindingIndex\n  } else {\n    declarationIndex\n  }\n  let observedIndex = if declaredIndex >= 0 {\n    declaredIndex\n  } else {\n    typedNodeIndex(\n      state,\n      reference.moduleIndex,\n      \"expression\",\n      reference.lo,\n      reference.hi,\n    )\n  }\n  let typedNode = match state.nodes.get(observedIndex) {\n    case Some(found) => found\n    case None => return None\n  }\n  let declaration = match declarationFor(\n      state,\n      reference.targetModuleIndex,\n      reference.targetLo,\n      reference.targetHi,\n  ) {\n    case Some(found) => found\n    case None => return None\n  }\n  Some(CaptureTarget {\n    declaration: declaration,\n    name: reference.name,\n    typeValue: typedNode.typeValue,\n    ambient: typedNode.ambient,\n  })\n}\n\nfunction capturesForReference(\n  state: CheckerState,\n  scopeAncestorIndexes: Map<string, Set<int>>,\n  reference: PreviewResolvedReference,\n) -> Array<PreviewTypedCapture> {\n  let mut captures: Array<PreviewTypedCapture> = []\n  let target = match captureTargetForReference(state, reference) {\n    case Some(found) => found\n    case None => return captures\n  }\n  let declarationAncestors = captureScopeAncestors(\n    state,\n    scopeAncestorIndexes,\n    reference.moduleIndex,\n    target.declaration.scopeOrdinal,\n  )\n  let mut current = reference.scopeOrdinal\n  while current >= 0 {\n    match scopeFor(state, reference.moduleIndex, current) {\n      case Some(scope) => {\n        if (scope.kind == \"function\" || scope.kind == \"lambda\") &&\n          !declarationAncestors.contains(scope.ordinal) {\n          captures.push(PreviewTypedCapture {\n            moduleIndex: reference.moduleIndex,\n            closureLo: scope.lo,\n            closureHi: scope.hi,\n            referenceLo: reference.lo,\n            referenceHi: reference.hi,\n            declarationLo: target.declaration.lo,\n            declarationHi: target.declaration.hi,\n            name: target.name,\n            typeValue: target.typeValue,\n            ambient: target.ambient,\n          })\n        }\n        current = scope.parentOrdinal\n      }\n      case None => {\n        current = -1\n      }\n    }\n  }\n  captures\n}\n\nfunction capturesAreSame(\n  left: PreviewTypedCapture,\n  right: PreviewTypedCapture,\n) -> bool {\n  left.moduleIndex == right.moduleIndex &&\n  left.closureLo == right.closureLo &&\n  left.closureHi == right.closureHi &&\n  left.referenceLo == right.referenceLo &&\n  left.referenceHi == right.referenceHi &&\n  left.declarationLo == right.declarationLo &&\n  left.declarationHi == right.declarationHi &&\n  left.name == right.name\n}\n\nfunction sortAndDeduplicateCaptures(state: CheckerState) -> () {\n  let mut target = state.captures\n  target.sortBy((capture) => capture.name)\n  target.sortBy((capture) => capture.declarationHi)\n  target.sortBy((capture) => capture.declarationLo)\n  target.sortBy((capture) => capture.referenceHi)\n  target.sortBy((capture) => capture.referenceLo)\n  target.sortBy((capture) => capture.closureHi)\n  target.sortBy((capture) => capture.closureLo)\n  target.sortBy((capture) => capture.moduleIndex)\n  target.sortBy((capture) => moduleIdentityAt(state, capture.moduleIndex))\n  let mut index = 1\n  while index < target.length {\n    let previous = match target.get(index - 1) {\n      case Some(value) => value\n      case None => return ()\n    }\n    let current = match target.get(index) {\n      case Some(value) => value\n      case None => return ()\n    }\n    if capturesAreSame(previous, current) {\n      target.removeAt(index)\n    } else {\n      index += 1\n    }\n  }\n}\n\nexport function deriveCaptures(state: CheckerState) -> () {\n  let mut scopeAncestorIndexes: Map<string, Set<int>> = map {}\n  let mut captures = state.captures\n  for reference in state.resolved.references {\n    for capture in capturesForReference(\n      state,\n      scopeAncestorIndexes,\n      reference,\n    ) {\n      captures.push(capture)\n    }\n  }\n  sortAndDeduplicateCaptures(state)\n  ()\n}\n\nfunction lispexRuleFactoryCallIndexes(\n  calls: Array<PreviewTypedCall>,\n) -> Map<string, Array<int>> {\n  let mut indexes: Map<string, Array<int>> = map {}\n  let mut index = 0\n  for call in calls {\n    if call.arguments.length == 0 &&\n      call.targetIdentity.startsWith(\"topaz.lispex-rule-handle/v1:\") {\n      let key = definitionNameKey(call.moduleIndex, call.targetIdentity)\n      match indexes.get(key) {\n        case Some(found) => {\n          let mut targets = found\n          targets.push(index)\n        }\n        case None => indexes.insert(key, [index])\n      }\n    }\n    index += 1\n  }\n  indexes\n}\n\nexport function diagnoseLispexRuleFactoryEscapes(state: CheckerState) -> () {\n  let callIndexes = lispexRuleFactoryCallIndexes(state.calls)\n  for reference in state.resolved.references {\n    if reference.namespace != \"value\" ||\n      reference.targetModule != \"std.lispex.rules\" ||\n      reference.targetName == \"\" {\n      continue\n    }\n    let expected = \"topaz.lispex-rule-handle/v1:{reference.targetName}\"\n    let mut direct = false\n    match callIndexes.get(definitionNameKey(reference.moduleIndex, expected)) {\n      case Some(indexes) => for index in indexes {\n        match state.calls.get(index) {\n          case Some(call) => if reference.lo >= call.calleeLo &&\n            reference.hi <= call.calleeHi {\n            direct = true\n          }\n          case None => ()\n        }\n      }\n      case None => ()\n    }\n    if !direct {\n      addDiagnostic(\n        state,\n        reference.moduleIndex,\n        \"TPZ5500\",\n        \"a generated Lispex rule factory may only appear as the direct callee of a zero-argument call\",\n        \"\",\n        SyntaxNode {\n          kind: \"identifier\",\n          lo: reference.lo,\n          hi: reference.hi,\n          field: \"\",\n          index: 0,\n          attributes: [],\n          children: [],\n        },\n      )\n    }\n  }\n  ()\n}\n\nrecord DeclarationIndexes {\n  spans: Map<string, int>,\n  valuesByModule: Map<string, Array<int>>,\n  namespaceImports: Map<string, int>,\n}\n\nexport record CheckerIndexes {\n  declarations: Map<string, int>,\n  valueDeclarationsByModule: Map<string, Array<int>>,\n  namespaceImports: Map<string, int>,\n  references: Map<string, int>,\n  scopes: Map<string, int>,\n}\n\nfunction declarationIndexes(resolved: ResolveResult) -> DeclarationIndexes {\n  let mut spans = emptyStringIntMap()\n  let mut valuesByModule: Map<string, Array<int>> = map {}\n  let mut namespaceImports = emptyStringIntMap()\n  let mut index = 0\n  for declaration in resolved.declarations {\n    let span = spanKey(declaration.moduleIndex, declaration.lo, declaration.hi)\n    match spans.get(span) {\n      case Some(_) => ()\n      case None => spans.insert(span, index)\n    }\n    let scopeName = \"lexical:{declaration.moduleIndex}:{declaration.scopeOrdinal}:{declaration.namespace}:{declaration.name}\"\n    match spans.get(scopeName) {\n      case Some(_) => ()\n      case None => spans.insert(scopeName, index)\n    }\n    if declaration.scopeOrdinal == 0 {\n      let name = \"original:{declaration.moduleIndex}:{declaration.namespace}:{declaration.name}\"\n      match spans.get(name) {\n        case Some(_) => ()\n        case None => spans.insert(name, index) }\n    }\n    if declaration.namespace == \"value\" {\n      let key = \"{declaration.moduleIndex}\"\n      match valuesByModule.get(key) {\n        case Some(found) => {\n          let mut targets = found\n          targets.push(index)\n        }\n        case None => valuesByModule.insert(key, [index])\n      }\n    }\n    if declaration.namespace == \"module\" &&\n      declaration.declarationKind == \"namespace-import\" {\n      let name = definitionNameKey(declaration.moduleIndex, declaration.name)\n      match namespaceImports.get(name) {\n        case Some(_) => ()\n        case None => namespaceImports.insert(name, index)\n      }\n    }\n    index += 1\n  }\n  DeclarationIndexes {\n    spans: spans,\n    valuesByModule: valuesByModule,\n    namespaceImports: namespaceImports,\n  }\n}\n\nfunction referenceSpanIndexes(resolved: ResolveResult) -> Map<string, int> {\n  let mut indexes = emptyStringIntMap()\n  let mut index = 0\n  for reference in resolved.references {\n    let key = spanKey(reference.moduleIndex, reference.lo, reference.hi)\n    match indexes.get(key) {\n      case Some(_) => ()\n      case None => indexes.insert(key, index)\n    }\n    index += 1\n  }\n  indexes\n}\n\nfunction scopeOrdinalIndexes(resolved: ResolveResult) -> Map<string, int> {\n  let mut indexes = emptyStringIntMap()\n  let mut index = 0\n  for scope in resolved.scopes {\n    let key = scopeKey(scope.moduleIndex, scope.ordinal)\n    match indexes.get(key) {\n      case Some(_) => ()\n      case None => indexes.insert(key, index)\n    }\n    index += 1\n  }\n  indexes\n}\n\nexport function checkerIndexes(resolved: ResolveResult) -> CheckerIndexes {\n  let declarations = declarationIndexes(resolved)\n  CheckerIndexes {\n    declarations: declarations.spans,\n    valueDeclarationsByModule: declarations.valuesByModule,\n    namespaceImports: declarations.namespaceImports,\n    references: referenceSpanIndexes(resolved),\n    scopes: scopeOrdinalIndexes(resolved),\n  }\n}\n\nexport function initialCheckerState(\n  resolved: ResolveResult,\n  modules: Array<ModuleSyntax>,\n  indexes: CheckerIndexes,\n  languageMode: string = \"topaz-5.20\",\n) -> CheckerState {\n  CheckerState {\n    languageMode: languageMode,\n    constantRenderEpoch: [0],\n    resolved: resolved,\n    modules: modules,\n    declarationIndexes: indexes.declarations,\n    valueDeclarationIndexesByModule: indexes.valueDeclarationsByModule,\n    namespaceImportIndexes: indexes.namespaceImports,\n    referenceIndexes: indexes.references,\n    scopeIndexes: indexes.scopes,\n    symbolIndexes: emptyStringIntMap(),\n    nodeIndexes: emptyStringIntMap(),\n    callIndexes: emptyStringIntMap(),\n    functionIndexes: emptyStringIntMap(),\n    functionNameIndexes: emptyStringIntMap(),\n    receiverMethodIndexes: emptyStringIntMap(),\n    protocolIndexes: emptyStringIntMap(),\n    conformanceIndexes: emptyStringIntMap(),\n    conformanceTypeIndexes: emptyStringIntMap(),\n    recordIndexes: emptyStringIntMap(),\n    enumIndexes: emptyStringIntMap(),\n    newtypeIndexes: emptyStringIntMap(),\n    aliasIndexes: emptyStringIntMap(),\n    symbols: [],\n    records: [],\n    enums: [],\n    newtypes: [],\n    aliases: [],\n    functions: [],\n    receiverMethods: [],\n    protocols: [],\n    pendingFunctions: [],\n    functionAliases: emptyStringIntMap(),\n    boundBuiltins: map {},\n    conformances: [],\n    typeParameters: [],\n    activeFunctions: [],\n    expectedReturns: [],\n    returnJoins: [],\n    expectedExpressions: [],\n    bareBindingExpressions: [],\n    literalJoinContexts: [],\n    branchJoinContexts: [],\n    statementExpressionContexts: [],\n    typeCapabilitySuppressions: [],\n    loopFrames: [],\n    loopFloors: [],\n    pipeValues: [],\n    nodes: [],\n    calls: [],\n    captures: [],\n    diagnostics: [],\n    inferenceSolutions: map {},\n    nextInference: 0,\n  }\n}\n",
      "sourceSha256": "620b57f69d6133ad274e7314f84c9f52e96f445d6a483f9152c3e294595df704"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/builtin_signatures.tpz",
      "language": "topaz",
      "bytes": 19672,
      "sha256": "d39c56a894a273ca893f9d44a1b49524479515010e8298f01ea597887982d8ad",
      "content": "// Pure parameter/default metadata shared by direct and bound builtin calls.\nimport checker_types { TypeValue }\nimport checker.model { CallSignature, lengthUnit }\n\nexport function stringElementType(value: TypeValue) -> bool {\n  if value.kind == \"primitive\" || value.kind == \"literal\" { return value.name == \"string\" }\n  if value.kind != \"union\" || value.members.length == 0 { return false }\n  for member in value.members { if !stringElementType(member) { return false } }\n  true\n}\n\nexport function builtinNamespaceFamily(namespace: string) -> string {\n  match namespace {\n    case \"Array\" | \"Set\" | \"Bytes\" | \"ByteBuffer\" | \"Map\" =>\n      \"collection\"\n    case \"Math\" | \"Codec\" | \"Hash\" => \"numeric-binary\"\n    case \"FS\" | \"Encoding\" | \"Cli\" | \"Path\" | \"Regex\" => \"host\"\n    case \"CSV\" | \"TOML\" | \"JSON\" => \"structured-data\"\n    case \"URL\" | \"Date\" | \"BigInt\" | \"Decimal\" | \"RoundingMode\" |\n      \"Test\" => \"scalar\"\n    case \"Show\" | \"Eq\" | \"Order\" => \"protocol\"\n    case _ => \"\"\n  }\n}\n\nexport function requiredCallSignature(\n  parameterNames: Array<string>,\n  variadic: bool,\n) -> CallSignature {\n  let mut defaults: Array<bool> = []\n  for _ in parameterNames {\n    defaults.push(false)\n  }\n  CallSignature {\n    parameterNames: parameterNames,\n    parameterDefaults: defaults,\n    parameterCount: parameterNames.length,\n    variadic: variadic,\n    positionalOnlyIdentity: \"\",\n  }\n}\n\nexport function defaultedCallSignature(\n  parameterNames: Array<string>,\n  parameterDefaults: Array<bool>,\n) -> CallSignature {\n  CallSignature {\n    parameterNames: parameterNames,\n    parameterDefaults: parameterDefaults,\n    parameterCount: parameterNames.length,\n    variadic: false,\n    positionalOnlyIdentity: \"\",\n  }\n}\n\nexport function positionalOnlyCallSignature(\n  identity: string,\n  parameterNames: Array<string>,\n) -> CallSignature {\n  CallSignature {\n    ...requiredCallSignature(parameterNames, false),\n    positionalOnlyIdentity: identity,\n  }\n}\n\nfunction collectionStaticCallSignature(\n  namespace: string,\n  name: string,\n) -> Option<CallSignature> {\n  if (namespace == \"Array\" || namespace == \"Set\") && name == \"of\" {\n    return Some(requiredCallSignature([], true))\n  }\n  if namespace == \"Map\" {\n    return match name {\n      case \"new\" => Some(requiredCallSignature([], false))\n      case \"ofEntries\" => Some(requiredCallSignature([\"entries\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"Bytes\" {\n    return match name {\n      case \"empty\" => Some(requiredCallSignature([], false))\n      case \"encodeUtf8\" | \"fromHex\" | \"fromBase64\" =>\n        Some(requiredCallSignature([\"s\"], false))\n      case \"fromArray\" => Some(requiredCallSignature([\"values\"], false))\n      case \"concat\" => Some(requiredCallSignature([\"a\", \"b\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"ByteBuffer\" {\n    return match name {\n      case \"allocate\" => Some(defaultedCallSignature(\n        [\"length\", \"value\"],\n        [false, true],\n      ))\n      case \"fromBytes\" => Some(requiredCallSignature([\"value\"], false))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction numericBinaryStaticCallSignature(\n  namespace: string,\n  name: string,\n) -> Option<CallSignature> {\n  if namespace == \"Math\" {\n    return match name {\n      case \"sqrt\" | \"abs\" | \"floor\" | \"ceil\" | \"round\" |\n        \"sin\" | \"cos\" | \"tan\" | \"isNaN\" | \"isFinite\" =>\n        Some(requiredCallSignature([\"x\"], false))\n      case \"parseFloat\" => Some(requiredCallSignature([\"s\"], false))\n      case \"min\" | \"max\" => Some(requiredCallSignature([\"a\", \"b\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"Codec\" {\n    return match name {\n      case \"zstdCompress\" => Some(defaultedCallSignature(\n        [\"bytes\", \"level\"],\n        [false, true],\n      ))\n      case \"gzipCompress\" | \"gzipDecompress\" | \"deflateCompress\" |\n        \"deflateFixedCompress\" | \"zlibFixedCompress\" |\n        \"reedSolomon255223Protect\" | \"deflateDecompress\" |\n        \"zstdDecompress\" => Some(requiredCallSignature([\"bytes\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"Hash\" {\n    return match name {\n      case \"sha256\" | \"sha512\" | \"crc32\" =>\n        Some(requiredCallSignature([\"data\"], false))\n      case \"hmacSha256\" => Some(requiredCallSignature(\n        [\"key\", \"message\"],\n        false,\n      ))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction hostStaticCallSignature(\n  namespace: string,\n  name: string,\n) -> Option<CallSignature> {\n  if namespace == \"FS\" {\n    return match name {\n      case \"readText\" | \"readBytes\" | \"list\" =>\n        Some(requiredCallSignature([\"path\"], false))\n      case \"writeText\" => Some(requiredCallSignature(\n        [\"path\", \"text\"],\n        false,\n      ))\n      case \"writeBytes\" => Some(requiredCallSignature(\n        [\"path\", \"bytes\"],\n        false,\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Encoding\" {\n    return match name {\n      case \"utf8Encode\" | \"hexDecode\" | \"base64Decode\" =>\n        Some(requiredCallSignature([\"text\"], false))\n      case \"utf8Decode\" | \"hexEncode\" | \"base64Encode\" =>\n        Some(requiredCallSignature([\"bytes\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"Cli\" {\n    return match name {\n      case \"hasFlag\" | \"option\" | \"options\" =>\n        Some(requiredCallSignature([\"args\", \"name\"], false))\n      case \"positionals\" => Some(requiredCallSignature([\"args\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"Path\" &&\n    (name == \"from\" || name == \"cwdRelative\" || name == \"project\") {\n    return Some(requiredCallSignature([\"text\"], false))\n  }\n  if namespace == \"Regex\" && name == \"compile\" {\n    return Some(requiredCallSignature([\"pattern\"], false))\n  }\n  None\n}\n\nfunction structuredDataStaticCallSignature(\n  namespace: string,\n  name: string,\n) -> Option<CallSignature> {\n  if namespace == \"CSV\" {\n    return match name {\n      case \"parse\" | \"parseWithHeader\" =>\n        Some(requiredCallSignature([\"text\"], false))\n      case \"stringify\" => Some(requiredCallSignature([\"rows\"], false))\n      case \"stringifyWithHeader\" => Some(requiredCallSignature(\n        [\"rows\", \"columns\"],\n        false,\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"TOML\" {\n    return match name {\n      case \"parse\" => Some(requiredCallSignature([\"text\"], false))\n      case \"stringify\" | \"toJson\" | \"fromJson\" =>\n        Some(requiredCallSignature([\"value\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"JSON\" {\n    return match name {\n      case \"parseAs\" | \"parse\" =>\n        Some(requiredCallSignature([\"text\"], false))\n      case \"decode\" | \"stringify\" =>\n        Some(requiredCallSignature([\"value\"], false))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction scalarTestStaticCallSignature(\n  namespace: string,\n  name: string,\n) -> Option<CallSignature> {\n  if namespace == \"URL\" && name == \"parse\" {\n    return Some(requiredCallSignature([\"text\"], false))\n  }\n  if namespace == \"Date\" {\n    return match name {\n      case \"fromYmd\" => Some(requiredCallSignature(\n        [\"year\", \"month\", \"day\"],\n        false,\n      ))\n      case \"parseIso\" => Some(requiredCallSignature([\"text\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"BigInt\" {\n    return match name {\n      case \"fromInt\" => Some(requiredCallSignature([\"n\"], false))\n      case \"parse\" => Some(requiredCallSignature([\"text\", \"radix\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"Decimal\" {\n    return match name {\n      case \"fromInt\" => Some(requiredCallSignature([\"n\"], false))\n      case \"parse\" => Some(requiredCallSignature([\"text\"], false))\n      case _ => None\n    }\n  }\n  if namespace == \"Test\" {\n    return match name {\n      case \"assert\" => Some(defaultedCallSignature(\n        [\"condition\", \"message\"],\n        [false, true],\n      ))\n      case \"assertEq\" | \"assertNe\" => Some(requiredCallSignature(\n        [\"actual\", \"expected\"],\n        false,\n      ))\n      case \"assertContains\" => Some(requiredCallSignature(\n        [\"text\", \"needle\"],\n        false,\n      ))\n      case \"assertOk\" | \"assertErr\" | \"assertSome\" | \"assertNone\" =>\n        Some(requiredCallSignature([\"value\"], false))\n      case \"assertGolden\" => Some(requiredCallSignature(\n        [\"path\", \"actual\"],\n        false,\n      ))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction containerReceiverCallSignature(\n  receiver: TypeValue,\n  name: string,\n) -> Option<CallSignature> {\n  if receiver.kind != \"constructor\" {\n    return None\n  }\n  if receiver.name == \"Option\" {\n    return match name {\n      case \"okOr\" => Some(requiredCallSignature([\"error\"], false))\n      case \"okOrElse\" | \"map\" | \"flatMap\" =>\n        Some(requiredCallSignature([\"f\"], false))\n      case _ => None\n    }\n  }\n  if receiver.name == \"Result\" {\n    return match name {\n      case \"map\" | \"flatMap\" => Some(requiredCallSignature([\"f\"], false))\n      case _ => None\n    }\n  }\n  if receiver.name == \"Array\" {\n    return match name {\n      case \"get\" => Some(requiredCallSignature([\"i\"], false))\n      case \"slice\" => Some(requiredCallSignature([\"start\", \"end\"], false))\n      case \"map\" | \"sortedBy\" | \"filter\" | \"sortBy\" | \"retain\" =>\n        Some(requiredCallSignature([\"f\"], false))\n      case \"join\" => Some(requiredCallSignature([\"sep\"], false))\n      case \"reduce\" => Some(requiredCallSignature([\"initial\", \"f\"], false))\n      case \"indexOf\" | \"push\" => Some(requiredCallSignature([\"x\"], false))\n      case \"insert\" => Some(requiredCallSignature(\n        [\"index\", \"value\"],\n        false,\n      ))\n      case \"removeAt\" => Some(requiredCallSignature([\"index\"], false))\n      case \"sorted\" | \"pop\" | \"clear\" | \"reverse\" | \"sort\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.name == \"Map\" {\n    return match name {\n      case \"insert\" => Some(requiredCallSignature([\"k\", \"v\"], false))\n      case \"get\" | \"remove\" | \"containsKey\" =>\n        Some(requiredCallSignature([\"k\"], false))\n      case \"getOr\" => Some(requiredCallSignature([\"k\", \"default\"], false))\n      case \"isEmpty\" | \"clear\" => Some(requiredCallSignature([], false))\n      case \"update\" => Some(requiredCallSignature(\n        [\"k\", \"initial\", \"f\"],\n        false,\n      ))\n      case \"mapValues\" | \"filter\" =>\n        Some(requiredCallSignature([\"f\"], false))\n      case _ => None\n    }\n  }\n  if receiver.name == \"Set\" {\n    return match name {\n      case \"add\" | \"remove\" | \"contains\" =>\n        Some(requiredCallSignature([\"x\"], false))\n      case \"union\" | \"intersection\" | \"difference\" =>\n        Some(requiredCallSignature([\"other\"], false))\n      case \"isEmpty\" | \"toArray\" | \"clear\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction scalarReceiverCallSignature(\n  receiver: TypeValue,\n  name: string,\n) -> Option<CallSignature> {\n  if (receiver.kind == \"primitive\" || receiver.kind == \"literal\") &&\n    receiver.name == \"int\" {\n    return match name {\n      case \"atLeast\" => Some(requiredCallSignature([\"min\"], false))\n      case \"atMost\" => Some(requiredCallSignature([\"max\"], false))\n      case _ => None\n    }\n  }\n  if (receiver.kind == \"primitive\" || receiver.kind == \"literal\") &&\n    receiver.name == \"string\" {\n    return match name {\n      case \"startsWith\" => Some(requiredCallSignature([\"prefix\"], false))\n      case \"endsWith\" => Some(requiredCallSignature([\"suffix\"], false))\n      case \"contains\" | \"indexOf\" | \"lastIndexOf\" =>\n        Some(requiredCallSignature([\"sub\"], false))\n      case \"codePointAt\" => Some(requiredCallSignature([\"i\"], false))\n      case \"split\" => Some(requiredCallSignature([\"sep\"], false))\n      case \"slice\" => Some(requiredCallSignature([\"start\", \"end\"], false))\n      case \"replace\" => Some(requiredCallSignature([\"old\", \"new\"], false))\n      case \"scalars\" | \"trim\" | \"trimStart\" | \"trimEnd\" | \"byteLength\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction runtimeReceiverCallSignature(\n  receiver: TypeValue,\n  name: string,\n) -> Option<CallSignature> {\n  if receiver.kind == \"file\" {\n    return match name {\n      case \"write\" => Some(requiredCallSignature([\"s\"], false))\n      case \"read\" | \"close\" => Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"json-value\" {\n    return match name {\n      case \"get\" => Some(requiredCallSignature([\"key\"], false))\n      case \"at\" => Some(requiredCallSignature([\"index\"], false))\n      case \"kind\" | \"isNull\" | \"asString\" | \"asBool\" | \"asInt\" |\n        \"numberText\" | \"length\" | \"asArray\" | \"keys\" | \"values\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"bytes\" {\n    return match name {\n      case \"get\" => Some(requiredCallSignature([\"index\"], false))\n      case \"slice\" => Some(requiredCallSignature([\"start\", \"end\"], false))\n      case \"decodeUtf8\" | \"toHex\" | \"toBase64\" | \"length\" |\n        \"isEmpty\" | \"toArray\" => Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"byte-buffer\" {\n    return match name {\n      case \"get\" => Some(requiredCallSignature([\"index\"], false))\n      case \"set\" => Some(requiredCallSignature([\"index\", \"value\"], false))\n      case \"fill\" => Some(requiredCallSignature(\n        [\"start\", \"length\", \"value\"],\n        false,\n      ))\n      case \"copy\" => Some(requiredCallSignature(\n        [\"source\", \"sourceStart\", \"targetStart\", \"length\"],\n        false,\n      ))\n      case \"length\" | \"toBytes\" => Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"path\" {\n    return match name {\n      case \"join\" => Some(requiredCallSignature([\"child\"], false))\n      case \"withExtension\" => Some(requiredCallSignature([\"ext\"], false))\n      case \"parent\" | \"fileName\" | \"extension\" | \"normalize\" | \"toString\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"regex\" {\n    return match name {\n      case \"isMatch\" | \"find\" | \"findAll\" | \"split\" =>\n        Some(requiredCallSignature([\"text\"], false))\n      case \"replaceAll\" => Some(requiredCallSignature(\n        [\"text\", \"replacement\"],\n        false,\n      ))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"url\" {\n    return match name {\n      case \"scheme\" | \"path\" | \"toString\" | \"host\" | \"fragment\" | \"query\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"date\" {\n    return match name {\n      case \"addDays\" => Some(requiredCallSignature([\"days\"], false))\n      case \"toIso\" | \"year\" | \"month\" | \"day\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"big-int\" {\n    return match name {\n      case \"toString\" => Some(requiredCallSignature([\"radix\"], false))\n      case \"div\" | \"mod\" => Some(requiredCallSignature([\"other\"], false))\n      case \"toInt\" => Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  if receiver.kind == \"decimal\" {\n    return match name {\n      case \"round\" => Some(defaultedCallSignature(\n        [\"scale\", \"mode\"],\n        [false, true],\n      ))\n      case \"div\" => Some(defaultedCallSignature(\n        [\"other\", \"scale\", \"mode\"],\n        [false, false, true],\n      ))\n      case \"toString\" | \"scale\" | \"toInt\" =>\n        Some(requiredCallSignature([], false))\n      case _ => None\n    }\n  }\n  None\n}\n\nexport function builtinReceiverCallSignature(\n  receiver: TypeValue,\n  name: string,\n  languageMode: string = \"topaz-5.20\",\n) -> Option<CallSignature> {\n  if languageMode == \"topaz-5.21\" {\n    if receiver.name == \"int\" {\n      if name == \"and\" || name == \"or\" || name == \"xor\" { return Some(requiredCallSignature([\"other\"], false)) }\n      if name == \"shift\" { return Some(requiredCallSignature([\"count\"], false)) }\n      if name == \"toBigInt\" || name == \"toDecimal\" { return Some(requiredCallSignature([], false)) }\n    }\n    if receiver.name == \"string\" && name == \"encodeUtf8\" { return Some(requiredCallSignature([], false)) }\n    if receiver.kind == \"constructor\" && (receiver.name == \"Set\" || receiver.name == \"Range\") {\n      if name == \"map\" || name == \"filter\" { return Some(requiredCallSignature([\"f\"], false)) }\n      if name == \"reduce\" { return Some(requiredCallSignature([\"initial\", \"f\"], false)) }\n    }\n    if receiver.kind == \"constructor\" && receiver.name == \"Result\" {\n      if name == \"mapErr\" { return Some(requiredCallSignature([\"f\"], false)) }\n      if name == \"unwrapOr\" { return Some(requiredCallSignature([\"default\"], false)) }\n    }\n    if receiver.kind == \"constructor\" && receiver.name == \"Array\" && receiver.arguments.length == 1 && stringElementType(receiver.arguments[0]) {\n      if name == \"hasFlag\" || name == \"option\" || name == \"options\" { return Some(requiredCallSignature([\"name\"], false)) }\n      if name == \"positionals\" { return Some(requiredCallSignature([], false)) }\n    }\n    if receiver.kind == \"bytes\" {\n      if name == \"concat\" { return Some(requiredCallSignature([\"b\"], false)) }\n      if name == \"hmacSha256\" { return Some(requiredCallSignature([\"message\"], false)) }\n      if name == \"zstdCompress\" { return Some(defaultedCallSignature([\"level\"], [true])) }\n      if name == \"sha256\" || name == \"sha512\" || name == \"crc32\" || name == \"gzipCompress\" || name == \"gzipDecompress\" || name == \"deflateCompress\" || name == \"deflateFixedCompress\" || name == \"zlibFixedCompress\" || name == \"reedSolomon255223Protect\" || name == \"deflateDecompress\" || name == \"zstdDecompress\" { return Some(requiredCallSignature([], false)) }\n    }\n    if (receiver.kind == \"json-value\" && name == \"decode\") || (receiver.kind == \"toml-value\" && name == \"toJson\") { return Some(requiredCallSignature([], false)) }\n    if lengthUnit(receiver) != \"\" {return if name == \"resolve\" {Some(requiredCallSignature([\"fontSize\"],false))} else {Some(requiredCallSignature([],false))}}\n    if receiver.name == \"float\" {\n      if name == \"atMost\" || name == \"atLeast\" { return Some(requiredCallSignature([\"b\"], false)) }\n      if name == \"trunc\" || name == \"floor\" || name == \"ceil\" || name == \"round\" || name == \"sqrt\" || name == \"abs\" || name == \"sin\" || name == \"cos\" || name == \"tan\" || name == \"isNaN\" || name == \"isFinite\" { return Some(requiredCallSignature([], false)) }\n    }\n    if receiver.name == \"int\" && (name == \"toFloat\" || name == \"toCodePoint\") { return Some(requiredCallSignature([], false)) }\n    if receiver.name == \"string\" {\n      if name == \"parseFloat\" || name == \"toInt\" { return Some(requiredCallSignature([], false)) }\n      if name == \"toIntRadix\" { return Some(requiredCallSignature([\"radix\"], false)) }\n    }\n  }\n  if receiver.kind == \"union\" {\n    for member in receiver.members {\n      match builtinReceiverCallSignature(member, name, languageMode) {\n        case Some(found) => return Some(found)\n        case None => ()\n      }\n    }\n    return None\n  }\n  match containerReceiverCallSignature(receiver, name) {\n    case Some(found) => return Some(found)\n    case None => ()\n  }\n  match scalarReceiverCallSignature(receiver, name) {\n    case Some(found) => return Some(found)\n    case None => ()\n  }\n  runtimeReceiverCallSignature(receiver, name)\n}\n\n\nexport function staticBuiltinDataCallSignature(namespace: string, name: string) -> Option<CallSignature> {\n  match builtinNamespaceFamily(namespace) {\n    case \"collection\" => collectionStaticCallSignature(namespace, name)\n    case \"numeric-binary\" => numericBinaryStaticCallSignature(namespace, name)\n    case \"host\" => hostStaticCallSignature(namespace, name)\n    case \"structured-data\" => structuredDataStaticCallSignature(namespace, name)\n    case \"scalar\" => scalarTestStaticCallSignature(namespace, name)\n    case _ => None\n  }\n}\n",
      "sourceSha256": "d39c56a894a273ca893f9d44a1b49524479515010e8298f01ea597887982d8ad"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/call_complete.tpz",
      "language": "topaz",
      "bytes": 61473,
      "sha256": "4260fb5bd202ff7b12c98fcc6445c2adc2527686a67869fdaa4bd44181a1c7f4",
      "content": "import checker.builtin_signatures { builtinReceiverCallSignature }\n// Argument inference and completion of checker call preparations.\n// call_plan selects signatures; this leaf binds actuals and resolves remaining\n// type variables through the shared expression callbacks.\n\nimport types { SyntaxNode, PreviewCheckDiagnostic }\nimport checker_types { TypeValue }\nimport checker.model {\n  CallArgumentPlan,\n  CallPreparation,\n  CallResultCandidates,\n  CallSignature,\n  CheckerService,\n  CheckerState,\n  CompletedCall,\n  InferredCallArguments,\n  LeadingCallArgument,\n  TypeBinding,\n  constructor,\n  emptyType,\n  functionType,\n  literal,\n  nominal,\n  rigid,\n  serviceInferExpression,\n}\nimport checker.type_algebra {\n  hasHole,\n  hasPartialHole,\n  solvePartialTypeAgainst,\n  transformTypeComponents,\n  typeContains,\n  typeEqual,\n  typeText,\n  unionType,\n  widen,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  addNode,\n  child,\n  children,\n  containsString,\n  functionDefinitionForReference,\n  replaceNodeType,\n  text,\n}\nimport checker.nominals { substitute }\nimport checker.protocols_methods {\n  newtypeDefinitionForType,\n  receiverMethodCallSignature,\n  receiverMethodType,\n}\nimport checker.members_capabilities {\n  applyBindings,\n  bindingIndex,\n  checkFunctionBounds,\n  collectTypeBindings,\n  comparableType,\n  conformanceTypeText,\n  gateCollectionKey,\n  iterableElement,\n  jsonCapability,\n  memberType,\n  orderCapability,\n  instantiateCallType,\n  protocolCallResult,\n  rigidOrUnionRigid,\n  rigidProtocolBound,\n  scopeCallParameters,\n  typeBindingKey,\n  typeConforms,\n}\nimport checker.call_facts {\n  addCall,\n  argumentValue,\n  builtinCallTypeParameters,\n  builtinNamespaceObject,\n  canonicalBoundaryTarget,\n  boundBuiltinForCallee,\n  contextualBuiltinArgumentType,\n  contextualBuiltinCall,\n  contextualGeneratedLispexCall,\n  contextualStandardWrapperCall,\n  currentExpectedExpression,\n  containsPlaceholder,\n  expressionResultIsDelegated,\n  expressionResultNode,\n  inferExpressionWithResultContext,\n  inferExpressionWithExpected,\n  isBareBindingExpression,\n  calleeReference,\n  refineExpressionToExpected,\n  reportExpectedType,\n  reportRemovedStaticMember,\n  unshadowedIdentifier,\n}\nimport checker.expression_core {\n  checkNominalConstructionContext,\n  inferLambda,\n  needsInwardCallContext,\n  pipePlaceholderContext,\n  specializeGenericFunctionValue,\n  wrapOptionalResult,\n}\nimport checker.call_plan {\n  builtinMemberCallSignature,\n  callArgumentExpectedType,\n  callSlotExpectedType,\n  declaredCallSignature,\n  callTypeParameters,\n  explicitCallBindings,\n  inferCallCallee,\n  nominalConstructorCallResult,\n  planSignatureArguments,\n  planTypedCallArguments,\n  unknownCallArgumentPlan,\n  userProtocolCallSignature,\n  userProtocolCallTarget,\n}\n\nfunction unsolvedCallExpectation(\n  value: TypeValue,\n  parameters: Array<TypeValue>,\n) -> Option<TypeValue> {\n  for parameter in parameters {\n    if typeEqual(value, parameter) {\n    // A generic parameter is a pass-through inference context. An unannotated\n    // callable parameter is an actual unknown expectation and cannot solve a\n    // polymorphic constructor's missing type argument.\n      return Some(TypeValue {\n        ...emptyType(\"unknown\"),\n        origin: \"generic-call-expectation\",\n        value: typeBindingKey(parameter),\n      })\n    }\n  }\n  None\n}\n\nexport function callArgumentInferenceContext(\n  expected: TypeValue,\n  parameters: Array<TypeValue>,\n) -> TypeValue {\n  transformTypeComponents(\n    expected,\n    (value: TypeValue) => unsolvedCallExpectation(value, parameters),\n  )\n}\n\nfunction restoreCallArgumentSchemeVariables(\n  actual: TypeValue,\n  parameters: Array<TypeValue>,\n) -> TypeValue {\n  // check_expr(Array) can return its partial expectation. Such a component\n  // is the original scheme variable, not new Unknown evidence for that slot.\n  transformTypeComponents(actual, (component: TypeValue) => {\n    if component.kind == \"unknown\" && component.origin == \"generic-call-expectation\" {\n      for parameter in parameters {\n        if component.value == typeBindingKey(parameter) { return Some(parameter) }\n      }\n    }\n    None\n  })\n}\n\nexport function inferContextualCallArgument(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  expected: Option<TypeValue>,\n  checkResult: bool = true,\n) -> TypeValue {\n  if node.kind == \"expression/parenthesized\" {\n    match child(node, \"operand\") {\n      case Some(operand) => {\n        let inferred = inferContextualCallArgument(service, state, moduleIndex, source, operand, expected, checkResult)\n        addNode(state, moduleIndex, \"expression\", node, inferred)\n        return inferred\n      }\n      case None => ()\n    }\n  }\n  match expected {\n    case Some(context) => {\n      if node.kind == \"expression/lambda\" && context.kind == \"function\" {\n        let inferred = inferLambda(service, state, moduleIndex, source, node, Some(context))\n        addNode(state, moduleIndex, \"expression\", node, inferred)\n        return inferred\n      }\n      if context.kind == \"function\" {\n        match calleeReference(state, moduleIndex, node) {\n          case Some(reference) => match functionDefinitionForReference(state, reference) {\n            case Some(definition) => if definition.typeParameters.length > 0 {\n              let declared = serviceInferExpression(service, state, moduleIndex, source, node)\n              return specializeGenericFunctionValue(state, moduleIndex, node, declared, context)\n            }\n            case None => ()\n          }\n          case None => ()\n        }\n      }\n      inferExpressionWithResultContext(service, state, moduleIndex, source, node, context, true, checkResult)\n    }\n    case None => serviceInferExpression(service, state, moduleIndex, source, node)\n  }\n}\n\n// Temporarily transport, then restore, every diagnostic in the call's owner order.\nfunction takeCallDiagnostics(state: CheckerState, start: int) -> Array<PreviewCheckDiagnostic> {\n  let mut result: Array<PreviewCheckDiagnostic> = []\n  let mut index = start\n  let mut diagnostics = state.diagnostics\n  while index < diagnostics.length { result.push(diagnostics[index]); index += 1 }\n  while diagnostics.length > start { diagnostics.pop() }\n  result\n}\n\nexport function inferCallArguments(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  preparation: CallPreparation,\n) -> InferredCallArguments {\n  let callee = preparation.callee\n  let calleeType = preparation.declaredType\n  let argumentSlots = preparation.argumentPlan.slots\n  let mut inferredTypes: Array<TypeValue> = []\n  let mut inferredNodes: Array<SyntaxNode> = []\n  let mut contextualActuals: Array<TypeValue> = []\n  let mut argumentBindings = preparation.bindings\n  while contextualActuals.length < preparation.contextualType.parameters.length {\n    contextualActuals.push(emptyType(\"unknown\"))\n  }\n  let arguments = children(node, \"arguments\")\n  let mut argumentDiagnostics: Array<Array<PreviewCheckDiagnostic>> = []\n  let mut deferred: Array<bool> = []\n  let mut order: Array<int> = []\n  let mut index = 0\n  for argument in arguments {\n    order.push(index)\n    argumentDiagnostics.push([])\n    deferred.push(needsInwardCallContext(state, moduleIndex, source, argumentValue(argument), None))\n    inferredTypes.push(emptyType(\"unknown\"))\n    inferredNodes.push(argumentValue(argument))\n    index += 1\n  }\n  let protocol = match preparation.userProtocolTarget {\n    case Some(_) => true\n    case None => false\n  }\n  let mut conformance = if protocol { \"pending\" } else { \"not-protocol\" }\n  if protocol && preparation.argumentPlan.resultUnknown {\n    conformance = \"invalid\"\n  } else if protocol && (arguments.length == 0 || preparation.argumentPlan.leadingSlot == 0) {\n    let observed = InferredCallArguments {\n      types: inferredTypes, nodes: inferredNodes, protocolConformance: conformance,\n    }\n    conformance = userProtocolCallConformance(state, moduleIndex, preparation, observed)\n    gateUserProtocolCall(state, moduleIndex, preparation, observed, conformance)\n  }\n  // Type dependencies follow parameter slots. The call's evaluation plan\n  // continues to preserve the source order of argument effects.\n  order.sortBy((position: int) => match argumentSlots.get(position) {\n    case Some(slot) => if slot >= 0 { slot } else { calleeType.parameters.length }\n    case None => calleeType.parameters.length\n  })\n  // Each preparation pass consumes fixed slots, then spread evidence, then\n  // scalar tail evidence (stage0 apply_scheme_result). A later source spread\n  // must solve its scheme variables before an earlier scalar is checked.\n  // Keep this separate from diagnostic replay and saved-placeholder selection.\n  let mut evidenceOrder = order.map((position: int) => position)\n  evidenceOrder.sortBy((position: int) => match argumentSlots.get(position) {\n    case Some(slot) => if slot >= 0 { slot } else if slot == -1 &&\n      arguments[position].kind == \"call-argument/spread\" {\n      calleeType.parameters.length\n    } else { calleeType.parameters.length + 1 }\n    case None => calleeType.parameters.length + 1\n  })\n  let frame = match state.pipeValues.get(state.pipeValues.length - 1) {\n    case Some(found) => if found.moduleIndex == moduleIndex && found.stage.lo == node.lo && found.stage.hi == node.hi { Some(found) } else { None }\n    case None => None\n  }\n  // A placeholder can receive the saved input after an earlier fixed seed.\n  // Admit independent evidence from those earlier slots before inferring the\n  // saved callback. Do not reschedule later slots or variadic tails: each\n  // argument still owns the substitution available at its original check.\n  let mut placeholderSlot = calleeType.parameters.length\n  if match frame { case Some(_) => true; case None => false } &&\n    match preparation.leading { case Some(_) => false; case None => true } {\n    for position in order {\n      let slot = argumentSlots[position]\n      if slot >= 0 && containsPlaceholder(argumentValue(arguments[position])) &&\n        slot < placeholderSlot { placeholderSlot = slot }\n    }\n    for position in order {\n      let slot = argumentSlots[position]\n      if slot >= 0 && slot < placeholderSlot {\n        let argument = arguments[position]\n        let expected = callArgumentExpectedType(\n          applyBindings(preparation.contextualType, argumentBindings), argument, slot)\n        deferred[position] = needsInwardCallContext(state, moduleIndex, source,\n          argumentValue(argument), expected)\n      }\n    }\n  }\n  let deferLeading = match frame {\n    case Some(saved) => needsInwardCallContext(state, moduleIndex, source, saved.node, None)\n    case None => false\n  }\n  let mut leadingDiagnostics: Array<PreviewCheckDiagnostic> = []\n  let mut leadingCheckDiagnostics: Array<PreviewCheckDiagnostic> = []\n  for dependent in [false, true] {\n    match frame {\n      case Some(saved) => if deferLeading == dependent {\n        let diagnosticStart = state.diagnostics.length\n        let mut expected: Option<TypeValue> = None\n        match preparation.leading {\n          case Some(_) => { expected = callSlotExpectedType(applyBindings(preparation.contextualType, argumentBindings), preparation.argumentPlan.leadingSlot, false) }\n          case None => {\n            for position in order {\n              let argument = arguments[position]\n              if match expected { case Some(_) => false; case None => true } && containsPlaceholder(argumentValue(argument)) {\n                expected = pipePlaceholderContext(argumentValue(argument), callArgumentExpectedType(applyBindings(preparation.contextualType, argumentBindings), argument, argumentSlots[position]))\n              }\n            }\n          }\n        }\n        let actual = match saved.values.get(0) {\n          case Some(found) => found\n          case None => {\n            // Saved pipe inputs share the direct argument's inference holes;\n            // an unsolved call parameter must not constrain a callback result.\n            let context = match expected {\n              case Some(found) => Some(callArgumentInferenceContext(found, preparation.schemeParameters))\n              case None => None\n            }\n            let mut pipeValues = state.pipeValues\n            pipeValues.pop()\n            let inferred = inferContextualCallArgument(service, state, moduleIndex, source, saved.node, context, false)\n            let mut savedValues = saved.values\n            savedValues.push(inferred)\n            pipeValues.push(saved)\n            inferred\n          }\n        }\n        if protocol && conformance != \"invalid\" && preparation.argumentPlan.leadingSlot == 0 {\n          let observed = InferredCallArguments { types: inferredTypes, nodes: inferredNodes, protocolConformance: conformance }\n          conformance = userProtocolCallConformance(state, moduleIndex, preparation, observed)\n          gateUserProtocolCall(state, moduleIndex, preparation, observed, conformance)\n        }\n        leadingDiagnostics = takeCallDiagnostics(state, diagnosticStart)\n        match preparation.leading {\n          case Some(_) => match callSlotExpectedType(calleeType, preparation.argumentPlan.leadingSlot, false) {\n            case Some(want) => collectTypeBindings(want, actual, argumentBindings, true, preparation.schemeParameters)\n            case None => ()\n          }\n          case None => ()\n        }\n        if !protocol && preparation.projectedMember == \"\" && calleeType.kind != \"newtype\" {\n          refineLeadingCallArgument(state, moduleIndex,\n            callArgumentInferenceContext(applyBindings(preparation.contextualType,\n              argumentBindings), preparation.schemeParameters),\n            preparation.argumentPlan, preparation.leading, preparation.diagnosticNode)\n        }\n        leadingCheckDiagnostics = takeCallDiagnostics(state, diagnosticStart)\n      }\n      case None => ()\n    }\n    for position in evidenceOrder {\n    if deferred[position] == dependent {\n    let diagnosticStart = state.diagnostics.length\n    let argument = arguments[position]\n    let valueNode = argumentValue(argument)\n    let slot = match argumentSlots.get(position) {\n      case Some(found) => found\n      case None => -2\n    }\n    let declaredExpected = contextualBuiltinArgumentType(\n      state,\n      moduleIndex,\n      source,\n      callee,\n      slot,\n      contextualActuals,\n      callArgumentExpectedType(if protocol {\n        protocolRefinementType(preparation, conformance, argumentBindings)\n      } else { preparation.contextualType }, argument, slot),\n    )\n    // Earlier actuals specialize a later callback before its body is checked.\n    // A still-unsolved builtin scheme variable is an inference hole, not a\n    // rigid requirement imposed on the callback's result.\n    let expected = match declaredExpected {\n      case Some(found) => Some(callArgumentInferenceContext(\n        applyBindings(found, argumentBindings),\n        preparation.schemeParameters))\n      case None => None\n    }\n    // Ordinary unsolved tails supply outward evidence. Contextual tails\n    // check against the partial expectation. Both spread and scalar tails\n    // use this infer/check_expr split in stage0's preparation passes.\n    let inferenceExpected = if slot == -1 && !dependent &&\n      match expected {\n        case Some(context) => typeContains(context, (part: TypeValue) =>\n          part.kind == \"unknown\" && part.origin == \"generic-call-expectation\")\n        case None => false\n      } { None } else { expected }\n    let inferred = restoreCallArgumentSchemeVariables(if protocol && conformance != \"invalid\" && slot == 0 {\n      serviceInferExpression(service, state, moduleIndex, source, valueNode)\n    } else {\n      inferContextualCallArgument(service, state, moduleIndex, source, valueNode, inferenceExpected)\n    }, preparation.schemeParameters)\n    inferredTypes[position] = inferred\n    // Bind the receiver against its original scheme, never a caller rigid\n    // substituted into the contextual signature by an explicit type argument.\n    let bindingExpected = callArgumentExpectedType(if calleeType.kind == \"newtype\" { newtypeCallType(state, moduleIndex, node, calleeType) } else { calleeType }, argument, slot)\n    match bindingExpected {\n      case Some(found) => collectTypeBindings(found, inferred, argumentBindings, true,\n        preparation.schemeParameters)\n      case None => ()\n    }\n    // The argument owns the substitution available immediately after its own\n    // inference. A later callback may solve more variables, but must not cause\n    // this argument to be compared again (stage0 check_call_argument).\n    if !protocol && preparation.projectedMember == \"\" && calleeType.kind != \"newtype\" {\n      match declaredExpected {\n        case Some(want) => refineCallArgument(state, moduleIndex, valueNode,\n          inferred, callArgumentInferenceContext(applyBindings(want, argumentBindings),\n            preparation.schemeParameters), argumentBindings,\n          slot == -1 && argument.kind == \"call-argument/spread\" && !dependent &&\n            match inferenceExpected { case Some(_) => false; case None => true })\n        case None => ()\n      }\n    }\n    if slot >= 0 && slot < contextualActuals.length {\n      contextualActuals[slot] = inferred\n    }\n    if protocol && conformance != \"invalid\" {\n      if slot == 0 {\n        let observed = InferredCallArguments {\n          types: inferredTypes, nodes: inferredNodes, protocolConformance: conformance,\n        }\n        conformance = userProtocolCallConformance(state, moduleIndex, preparation, observed)\n        gateUserProtocolCall(state, moduleIndex, preparation, observed, conformance)\n      } else {\n        match callArgumentExpectedType(\n          protocolRefinementType(preparation, conformance, argumentBindings), argument, slot) {\n          case Some(want) => {\n            let refined = refineExpressionToExpected(state, moduleIndex, valueNode,\n              applyBindings(inferred, argumentBindings), want)\n            reportExpectedType(state, moduleIndex, valueNode, want, refined)\n          }\n          case None => ()\n        }\n      }\n    }\n    argumentDiagnostics[position] = takeCallDiagnostics(state, diagnosticStart)\n    }\n    }\n  }\n  let mut diagnostics = state.diagnostics\n  // Recovered duplicate/overflow arguments have no parameter owner. Rust checks\n  // their inner errors after planning, before replaying owned slot diagnostics.\n  // Move only diagnostics: each expression above was inferred exactly once.\n  for position in order {\n    if argumentSlots[position] == -2 {\n      for diagnostic in argumentDiagnostics[position] { diagnostics.push(diagnostic) }\n    }\n  }\n  for diagnostic in leadingDiagnostics { diagnostics.push(diagnostic) }\n  match frame { case Some(saved) => for diagnostic in saved.diagnostics { diagnostics.push(diagnostic) }; case None => () }\n  // Input inference precedes callee diagnostics; the argument comparison\n  // follows them even though it was computed with the earlier substitution.\n  for diagnostic in leadingCheckDiagnostics { diagnostics.push(diagnostic) }\n  // Replay spread diagnostics before variadic scalars, as apply_scheme_result\n  // does in stage0. Buffer diagnostics only: keep argument inference and its\n  // shared substitution in the existing order above.\n  let mut hasSpreadTail = false\n  for position in order {\n    if argumentSlots[position] == -1 &&\n      arguments[position].kind == \"call-argument/spread\" { hasSpreadTail = true }\n  }\n  let mut variadicDiagnostics: Array<PreviewCheckDiagnostic> = []\n  for position in order {\n    if argumentSlots[position] == -2 { continue }\n    let scalarTail = hasSpreadTail && argumentSlots[position] == -1 &&\n      arguments[position].kind != \"call-argument/spread\"\n    for diagnostic in argumentDiagnostics[position] {\n      if scalarTail { variadicDiagnostics.push(diagnostic) }\n      else { diagnostics.push(diagnostic) }\n    }\n  }\n  for diagnostic in variadicDiagnostics { diagnostics.push(diagnostic) }\n  if conformance == \"invalid\" {\n    match preparation.userProtocolTarget {\n      case Some(target) => addDiagnostic(state, moduleIndex, \"TPZ5004\",\n        \"a protocol call `{target.protocolName}.{target.method.name}(…)` takes positional arguments only\",\n        \"\", preparation.diagnosticNode)\n      case None => ()\n    }\n  }\n  InferredCallArguments {\n    types: inferredTypes,\n    nodes: inferredNodes,\n    protocolConformance: conformance,\n  }\n}\n\nfunction protocolRefinementType(\n  preparation: CallPreparation,\n  conformance: string,\n  bindings: Array<TypeBinding>,\n) -> TypeValue {\n  if conformance != \"reject\" && conformance != \"defer\" {\n    return applyBindings(preparation.declaredType, bindings)\n  }\n  let mut unknowns: Array<TypeBinding> = []\n  for parameter in preparation.schemeParameters {\n    unknowns.push(TypeBinding { name: typeBindingKey(parameter), typeValue: emptyType(\"unknown\") })\n  }\n  applyBindings(preparation.declaredType, unknowns)\n}\n\nexport function leadingCallActuals(\n  leading: Option<LeadingCallArgument>,\n) -> Array<TypeValue> {\n  match leading {\n    case Some(argument) => match argument.values.get(0) { case Some(found) => [found]; case None => [] }\n    case None => []\n  }\n}\n\nfunction completeCallActuals(\n  leading: Option<LeadingCallArgument>,\n  explicit: Array<TypeValue>,\n) -> Array<TypeValue> {\n  let mut actuals = leadingCallActuals(leading)\n  for actual in explicit {\n    actuals.push(actual)\n  }\n  actuals\n}\n\nfunction collectCallResultBindings(\n  state: CheckerState,\n  node: SyntaxNode,\n  calleeType: TypeValue,\n  bindings: Array<TypeBinding>,\n  parameters: Array<TypeValue>,\n) -> () {\n  let mut inferredBindings = bindings\n  match currentExpectedExpression(state, node) {\n    case Some(expectedResult) => match calleeType.result.get(0) {\n      case Some(declaredResult) => collectTypeBindings(\n        declaredResult,\n        expectedResult,\n        inferredBindings,\n        false,\n        parameters,\n      )\n      case None => ()\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction collectCallInputTypeBindings(\n  node: SyntaxNode,\n  calleeType: TypeValue,\n  argumentPlan: CallArgumentPlan,\n  actuals: Array<TypeValue>,\n  leading: Option<LeadingCallArgument>,\n  bindings: Array<TypeBinding>,\n  parameters: Array<TypeValue>,\n) -> () {\n  let mut inferredBindings = bindings\n  match leading {\n    case Some(argument) => match callSlotExpectedType(\n      calleeType,\n      argumentPlan.leadingSlot,\n      false,\n    ) {\n      case Some(expected) => collectTypeBindings(\n        expected,\n        match argument.values.get(0) { case Some(found) => found; case None => emptyType(\"unknown\") },\n        inferredBindings,\n        true,\n        parameters,\n      )\n      case None => ()\n    }\n    case None => ()\n  }\n  let mut index = 0\n  for argument in children(node, \"arguments\") {\n    let slot = match argumentPlan.slots.get(index) {\n      case Some(found) => found\n      case None => -2\n    }\n    match callArgumentExpectedType(calleeType, argument, slot) {\n      case Some(expected) => match actuals.get(index) {\n        case Some(actual) => collectTypeBindings(\n          expected,\n          actual,\n          inferredBindings,\n          true,\n          parameters,\n        )\n        case None => ()\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  ()\n}\n\nfunction projectedCallMember(\n  source: Bytes,\n  callee: SyntaxNode,\n  receiverType: TypeValue,\n) -> string {\n  if !rigidOrUnionRigid(receiverType) ||\n    (callee.kind != \"expression/member\" &&\n      callee.kind != \"expression/optional-access\") {\n    return \"\"\n  }\n  match child(callee, \"field\") {\n    case Some(field) => text(source, field)\n    case None => \"\"\n  }\n}\n\nfunction specializeCallCallee(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  callee: SyntaxNode,\n  calleeType: TypeValue,\n  actuals: Array<TypeValue>,\n  bindings: Array<TypeBinding>,\n) -> TypeValue {\n  match contextualStandardWrapperCall(\n    state,\n    moduleIndex,\n    node,\n    callee,\n    calleeType,\n    actuals,\n  ) {\n    case Some(found) => found\n    case None => match contextualGeneratedLispexCall(\n      state,\n      moduleIndex,\n      source,\n      node,\n      callee,\n      actuals,\n    ) {\n      case Some(found) => found\n      case None => match contextualBuiltinCall(\n        state,\n        moduleIndex,\n        source,\n        node,\n        callee,\n        calleeType,\n      ) {\n        case Some(found) => found\n        case None => applyBindings(calleeType, bindings)\n      }\n    }\n  }\n}\n\nfunction unboundBuiltinCallTypeParameter(\n  value: TypeValue,\n  parameters: Array<TypeValue>,\n  bindings: Array<TypeBinding>,\n) -> Option<TypeValue> {\n  for parameter in parameters {\n    if typeEqual(value, parameter) && bindingIndex(bindings, typeBindingKey(parameter)) < 0 {\n      // Keep the invocation's variable identity for cross-branch solving.\n      // An actual Unknown input already has a binding and stays Unknown.\n      return Some(TypeValue {\n        ...emptyType(\"unknown\"),\n        origin: \"generic-call-result\",\n        value: typeBindingKey(parameter),\n      })\n    }\n  }\n  None\n}\n\nfunction preserveUnboundBuiltinCallTypeParameters(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n  receiverType: TypeValue,\n  schemeParameters: Array<TypeValue>,\n  bindings: Array<TypeBinding>,\n  specialized: TypeValue,\n) -> TypeValue {\n  let parameters = builtinCallTypeParameters(\n    service,\n    state,\n    moduleIndex,\n    source,\n    callee,\n    receiverType,\n  )\n  if parameters.length == 0 {\n    return specialized\n  }\n  transformTypeComponents(\n    specialized,\n    (component: TypeValue) => unboundBuiltinCallTypeParameter(\n      component,\n      schemeParameters,\n      bindings,\n    ),\n  )\n}\n\nfunction refineCallArgument(\n  state: CheckerState,\n  moduleIndex: int,\n  actualNode: SyntaxNode,\n  actualType: TypeValue,\n  expectedType: TypeValue,\n  bindings: Array<TypeBinding>,\n  preserveIndependentShape: bool = false,\n) -> () {\n  let specializedActual = applyBindings(actualType, bindings)\n  if !typeEqual(specializedActual, actualType) {\n    replaceNodeType(state, moduleIndex, \"expression\", actualNode, specializedActual)\n  }\n  let refined = if preserveIndependentShape && hasPartialHole(specializedActual) &&\n    !hasHole(expectedType) {\n    let completed = solvePartialTypeAgainst(state, specializedActual, expectedType)\n    replaceNodeType(state, moduleIndex, \"expression\", actualNode, completed)\n    completed\n  } else {\n    refineExpressionToExpected(state, moduleIndex, actualNode, specializedActual, expectedType)\n  }\n  if !expressionResultIsDelegated(actualNode) {\n    reportExpectedType(state, moduleIndex, expressionResultNode(actualNode), expectedType, refined)\n  }\n}\n\nfunction refineCallArguments(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  calleeType: TypeValue,\n  argumentSlots: Array<int>,\n  skipFirstSlot: bool,\n  actuals: Array<TypeValue>,\n  actualNodes: Array<SyntaxNode>,\n  bindings: Array<TypeBinding>,\n) -> () {\n  let arguments = children(node, \"arguments\")\n  let mut index = 0\n  while index < actuals.length {\n    let expected = match arguments.get(index) {\n      case Some(argument) => match argumentSlots.get(index) {\n        case Some(slot) => if skipFirstSlot && slot == 0 {\n          None\n        } else {\n          callArgumentExpectedType(calleeType, argument, slot)\n        }\n        case None => None\n      }\n      case None => None\n    }\n    match expected {\n      case Some(expectedType) => match actualNodes.get(index) {\n        case Some(actualNode) => match actuals.get(index) {\n          case Some(actualType) => refineCallArgument(\n            state, moduleIndex, actualNode, actualType, expectedType, bindings)\n          case None => ()\n        }\n        case None => ()\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  ()\n}\n\nfunction refineLeadingCallArgument(\n  state: CheckerState,\n  moduleIndex: int,\n  calleeType: TypeValue,\n  argumentPlan: CallArgumentPlan,\n  leading: Option<LeadingCallArgument>,\n  diagnosticNode: SyntaxNode,\n) -> () {\n  match leading {\n    case Some(argument) => match callSlotExpectedType(\n      calleeType,\n      argumentPlan.leadingSlot,\n      false,\n    ) {\n      case Some(expected) => {\n        let refined = refineExpressionToExpected(\n          state,\n          moduleIndex,\n          argument.node,\n          match argument.values.get(0) { case Some(found) => found; case None => emptyType(\"unknown\") },\n          expected,\n        )\n        reportExpectedType(\n          state,\n          moduleIndex,\n          diagnosticNode,\n          expected,\n          refined,\n        )\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n}\n\nfunction callResultType(\n  specializedCallee: TypeValue,\n  calleeType: TypeValue,\n  constructorResult: Option<TypeValue>,\n  protocolResult: Option<TypeValue>,\n  bindings: Array<TypeBinding>,\n) -> TypeValue {\n  match specializedCallee.result.get(0) {\n    case Some(found) => found\n    case None => match constructorResult {\n      case Some(found) => found\n      case None => match protocolResult {\n        case Some(found) => found\n        case None => match calleeType.result.get(0) {\n          case Some(found) => applyBindings(found, bindings)\n          case None => if calleeType.kind == \"nominal-record\" {\n            calleeType\n          } else {\n            emptyType(\"unknown\")\n          }\n        }\n      }\n    }\n  }\n}\n\nrecord BuiltinCallTarget {\n  namespace: string,\n  member: string,\n}\n\nfunction builtinCallTarget(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n) -> BuiltinCallTarget {\n  match boundBuiltinForCallee(state, moduleIndex, callee) {\n    case Some(bound) => {\n      if bound.target == \"builtin::JsonDecode\" { return BuiltinCallTarget { namespace: \"JSON\", member: \"decode\" } }\n      if bound.boundary.length == 2 { return BuiltinCallTarget { namespace: bound.boundary[0], member: bound.boundary[1] } }\n      return BuiltinCallTarget { namespace: \"\", member: bound.member }\n    }\n    case None => ()\n  }\n  let boundary = canonicalBoundaryTarget(state, moduleIndex, source, callee)\n  if boundary.length == 2 { return BuiltinCallTarget { namespace: boundary[0], member: boundary[1] } }\n  if callee.kind != \"expression/member\" &&\n    callee.kind != \"expression/optional-access\" {\n    return BuiltinCallTarget { namespace: \"\", member: \"\" }\n  }\n  let object = match child(callee, \"object\") {\n    case Some(found) => found\n    case None => return BuiltinCallTarget { namespace: \"\", member: \"\" }\n  }\n  if state.languageMode == \"topaz-5.21\" {\n    match child(callee, \"field\") {\n      case Some(field) => if text(source, field) == \"decode\" && serviceInferExpression(service, state, moduleIndex, source, object).kind == \"json-value\" { return BuiltinCallTarget { namespace: \"JSON\", member: \"decode\" } }\n      case None => ()\n    }\n  }\n  BuiltinCallTarget {\n    namespace: if builtinNamespaceObject(\n      service,\n      state,\n      moduleIndex,\n      source,\n      object,\n    ) {\n      text(source, object)\n    } else {\n      \"\"\n    },\n    member: match child(callee, \"field\") {\n      case Some(found) => text(source, found)\n      case None => \"\"\n    },\n  }\n}\n\nfunction preparedCallActual(\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n  slot: int,\n) -> Option<TypeValue> {\n  match preparation.leading {\n    case Some(argument) => if preparation.argumentPlan.leadingSlot == slot {\n      return Some(match argument.values.get(0) { case Some(found) => found; case None => emptyType(\"unknown\") })\n    }\n    case None => ()\n  }\n  let mut index = 0\n  for actual in inferred.types {\n    match preparation.argumentPlan.slots.get(index) {\n      case Some(actualSlot) => if actualSlot == slot {\n        return Some(actual)\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  None\n}\n\nfunction preparedCallActualNode(\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n  slot: int,\n) -> Option<SyntaxNode> {\n  match preparation.leading {\n    case Some(argument) => if preparation.argumentPlan.leadingSlot == slot {\n      return Some(preparation.diagnosticNode)\n    }\n    case None => ()\n  }\n  let mut index = 0\n  for actualNode in inferred.nodes {\n    match preparation.argumentPlan.slots.get(index) {\n      case Some(actualSlot) => if actualSlot == slot {\n        return Some(actualNode)\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  None\n}\n\nfunction userProtocolCallConformance(\n  state: CheckerState,\n  moduleIndex: int,\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n) -> string {\n  let target = match preparation.userProtocolTarget {\n    case Some(found) => found\n    case None => return \"not-protocol\"\n  }\n  match preparedCallActual(preparation, inferred, 0) {\n    case Some(actual) => {\n      let value = widen(actual)\n      if hasHole(value) {\n        \"defer\"\n      } else if typeConforms(\n        state,\n        moduleIndex,\n        value,\n        target.protocolName,\n      ) {\n        \"accept\"\n      } else {\n        \"reject\"\n      }\n    }\n    case None => \"defer\"\n  }\n}\n\nfunction gateUserProtocolCall(\n  state: CheckerState,\n  moduleIndex: int,\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n  conformance: string,\n) -> () {\n  let target = match preparation.userProtocolTarget {\n    case Some(found) => found\n    case None => return ()\n  }\n  let actualCount = inferred.types.length + match preparation.leading {\n    case Some(_) => 1\n    case None => 0\n  }\n  if conformance == \"accept\" ||\n    (conformance == \"defer\" && actualCount == 0) {\n    let expectedCount = target.method.typeValue.parameters.length\n    if actualCount != expectedCount {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"`{target.protocolName}.{target.method.name}` takes {expectedCount} argument\" +\n          if expectedCount == 1 { \"\" } else { \"s\" } +\n          \", found {actualCount}\",\n        \"\",\n        preparation.diagnosticNode,\n      )\n    }\n  }\n  if conformance != \"reject\" {\n    return ()\n  }\n  match preparedCallActual(preparation, inferred, 0) {\n    case Some(actual) => {\n      let value = widen(actual)\n      let nominal = value.kind == \"nominal-record\" ||\n        value.kind == \"enum\" || value.kind == \"newtype\" ||\n        value.kind == \"foreign\" || value.kind == \"rigid\"\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5522\",\n        if nominal {\n          \"`{conformanceTypeText(state, moduleIndex, actual)}` does not conform to `{target.protocolName}`\"\n        } else {\n          \"`{typeText(actual)}` does not conform to `{target.protocolName}`: a protocol receiver must be a record/enum/newtype\"\n        },\n        \"\",\n        match preparedCallActualNode(preparation, inferred, 0) {\n          case Some(found) => found\n          case None => preparation.diagnosticNode\n        },\n      )\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction gatePreparedCallCapabilities(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n  bindings: Array<TypeBinding>,\n  rawResult: TypeValue,\n) -> () {\n  let target = builtinCallTarget(\n    service,\n    state,\n    moduleIndex,\n    source,\n    preparation.callee,\n  )\n  let bareCallContext = match currentExpectedExpression(state, node) {\n    case Some(_) => false\n    case None => true\n  }\n  let bareBindingCall = isBareBindingExpression(state, node)\n  let unknownExpectation = match currentExpectedExpression(state, node) {\n    case Some(expected) => expected.kind == \"unknown\" && expected.origin == \"\" ||\n      expected.kind == \"inference-variable\"\n    case None => false\n  }\n  let constructorName = if unshadowedIdentifier(state, moduleIndex, preparation.callee) {\n    text(source, preparation.callee)\n  } else { \"\" }\n  if (constructorName == \"Ok\" || constructorName == \"Err\" || constructorName == \"Some\") &&\n    (bareBindingCall || unknownExpectation) && hasHole(rawResult) {\n    let mut unknownInput = false\n    for actual in inferred.types { if hasHole(actual) { unknownInput = true } }\n    if !unknownInput {\n      addDiagnostic(state, moduleIndex, \"TPZ5020\",\n        \"this expression needs a contextual type (§22.1): annotate the binding or surrounding expectation\",\n        \"\", preparation.diagnosticNode)\n    }\n  }\n  if bareCallContext && bareBindingCall &&\n    target.namespace == \"Map\" && target.member == \"new\" &&\n    hasHole(rawResult) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5020\",\n      \"this expression needs a contextual type (§22.1): annotate the binding or surrounding expectation\",\n      \"\",\n      preparation.diagnosticNode,\n    )\n  }\n  if preparation.callee.kind == \"expression/identifier\" &&\n    unshadowedIdentifier(state, moduleIndex, preparation.callee) &&\n    (text(source, preparation.callee) == \"map\" ||\n      text(source, preparation.callee) == \"filter\" ||\n      text(source, preparation.callee) == \"reduce\") {\n    match preparedCallActual(preparation, inferred, 0) {\n      case Some(iterable) => if iterableElement(iterable).kind == \"unknown\" &&\n        !hasHole(iterable) {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5001\",\n          \"`{typeText(iterable)}` is not iterable (§10)\",\n          \"\",\n          match preparedCallActualNode(preparation, inferred, 0) {\n            case Some(actualNode) => actualNode\n            case None => preparation.diagnosticNode\n          },\n        )\n      }\n      case None => ()\n    }\n    if bareCallContext && hasHole(rawResult) {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5020\",\n        \"this expression needs a contextual type (§22.1): annotate the binding or surrounding expectation\",\n        \"\",\n        preparation.diagnosticNode,\n      )\n    }\n  }\n  if bareCallContext &&\n    ((target.namespace == \"Set\" && target.member == \"of\") ||\n      (target.namespace == \"Map\" &&\n        (target.member == \"new\" || target.member == \"ofEntries\"))) &&\n    rawResult.kind == \"constructor\" {\n    match rawResult.arguments.get(0) {\n      case Some(key) => if !hasHole(key) { gateCollectionKey(\n        service,\n        state,\n        moduleIndex,\n        preparation.diagnosticNode,\n        key,\n      ) }\n      case None => ()\n    }\n  }\n  if target.namespace == \"\" &&\n    (target.member == \"sorted\" || target.member == \"sort\") &&\n    preparation.receiverType.kind == \"constructor\" &&\n    preparation.receiverType.name == \"Array\" {\n    match preparation.receiverType.arguments.get(0) {\n      case Some(element) => {\n        let specialized = applyBindings(element, bindings)\n        if orderCapability(\n          state,\n          moduleIndex,\n          specialized,\n          [],\n        ) == \"reject\" {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5007\",\n            \"`{typeText(specialized)}` is not ordered comparable, so `.{target.member}()` cannot sort it\",\n            \"\",\n            preparation.diagnosticNode,\n          )\n        }\n      }\n      case None => ()\n    }\n  }\n  if target.namespace == \"\" &&\n    (target.member == \"sortedBy\" || target.member == \"sortBy\") {\n    match preparedCallActual(preparation, inferred, 0) {\n      case Some(callback) => if callback.kind == \"function\" {\n        match callback.result.get(0) {\n          case Some(result) => {\n            let key = applyBindings(result, bindings)\n            if orderCapability(state, moduleIndex, key, []) == \"reject\" {\n              addDiagnostic(\n                state,\n                moduleIndex,\n                \"TPZ5007\",\n                \"the `{target.member}` key type `{typeText(key)}` is not ordered comparable, so `.{target.member}()` cannot sort it\",\n                \"\",\n                preparation.diagnosticNode,\n              )\n            }\n          }\n          case None => ()\n        }\n      }\n      case None => ()\n    }\n  }\n  if target.namespace == \"JSON\" && target.member == \"stringify\" {\n    match preparedCallActual(preparation, inferred, 0) {\n      case Some(actual) => {\n        let value = applyBindings(actual, bindings)\n        if jsonCapability(state, moduleIndex, value, [], false) == \"reject\" &&\n          !rigidProtocolBound(state, value, \"JSON\") {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5533\",\n            \"`{typeText(value)}` is not JSON-encodable, so `json.stringify` cannot encode it\",\n            \"\",\n            preparation.diagnosticNode,\n          )\n        }\n      }\n      case None => ()\n    }\n  }\n  if target.namespace == \"JSON\" &&\n    (target.member == \"parseAs\" || target.member == \"decode\") {\n    let jsonName = if state.languageMode == \"topaz-5.21\" {\n      if target.member == \"decode\" { \"decode\" } else { \"json.{target.member}\" }\n    } else { \"JSON.{target.member}\" }\n    let typeArguments = children(node, \"typeArguments\")\n    if typeArguments.length == 0 {\n      if bareCallContext {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5020\",\n          \"this expression needs a contextual type (§22.1): annotate the binding or surrounding expectation\",\n          \"\",\n          preparation.diagnosticNode,\n        )\n      }\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5534\",\n        \"`{jsonName}` requires an explicit type argument, e.g. `{jsonName}<User>(...)`\",\n        \"\",\n        preparation.diagnosticNode,\n      )\n    } else if rawResult.kind == \"constructor\" && rawResult.name == \"Result\" {\n      match rawResult.arguments.get(0) {\n        case Some(value) => if jsonCapability(\n          state,\n          moduleIndex,\n          value,\n          [],\n          true,\n        ) == \"reject\" {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5534\",\n            \"`{typeText(value)}` is not JSON-decodable, so `{jsonName}` cannot decode into it\",\n            \"\",\n            preparation.diagnosticNode,\n          )\n        }\n        case None => ()\n      }\n    }\n  }\n  if target.namespace == \"Test\" &&\n    (target.member == \"assertEq\" || target.member == \"assertNe\") {\n    match preparedCallActual(preparation, inferred, 0) {\n      case Some(value) => {\n        let actual = applyBindings(value, bindings)\n        if !comparableType(state, moduleIndex, actual, []) {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5007\",\n            \"`{typeText(actual)}` is not comparable, so `test.{target.member}` cannot compare it\",\n            \"\",\n            preparation.diagnosticNode,\n          )\n        }\n      }\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction checkedCallResultCandidates(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n  calleeType: TypeValue,\n) -> CallResultCandidates {\n  let nominal = nominalConstructorCallResult(\n    state,\n    moduleIndex,\n    source,\n    callee,\n  )\n  let protocol = protocolCallResult(service, state, moduleIndex, source, callee)\n  let nominalKnown = match nominal {\n    case Some(_) => true\n    case None => false\n  }\n  let protocolKnown = match protocol {\n    case Some(_) => true\n    case None => false\n  }\n  if !hasHole(calleeType) &&\n    calleeType.kind != \"function\" &&\n    calleeType.kind != \"nominal-record\" &&\n    calleeType.kind != \"newtype\" &&\n    !nominalKnown &&\n    !protocolKnown {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5005\",\n      \"`{typeText(calleeType)}` is not callable\",\n      \"\",\n      if callee.kind == \"expression/member\" ||\n        callee.kind == \"expression/optional-access\" {\n        match child(callee, \"field\") {\n          case Some(field) => field\n          case None => callee\n        }\n      } else {\n        callee\n      },\n    )\n  }\n  CallResultCandidates { nominal: nominal, protocol: protocol }\n}\n\nfunction newtypeCallType(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  declared: TypeValue,\n) -> TypeValue {\n  match newtypeDefinitionForType(state, moduleIndex, declared) {\n    case Some(definition) => {\n      if definition.typeParameters.length == 0 {\n        return functionType([definition.base], [], declared)\n      }\n      match currentExpectedExpression(state, node) {\n        case Some(expected) => if expected.kind == declared.kind &&\n          expected.identity == declared.identity && expected.origin == declared.origin &&\n          expected.arguments.length == definition.typeParameters.length {\n          let base = substitute(definition.base, definition.typeParameters, expected.arguments)\n          return functionType([base], [], expected)\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  declared\n}\n\nfunction planNewtypeArguments(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  diagnosticNode: SyntaxNode,\n  callee: TypeValue,\n  callType: TypeValue,\n  hasLeading: bool,\n) -> CallArgumentPlan {\n  let arguments = children(node, \"arguments\")\n  let actualCount = arguments.length + if hasLeading { 1 } else { 0 }\n  let mut valid = actualCount == 1\n  for argument in arguments {\n    if argument.kind == \"call-argument/named\" || argument.kind == \"call-argument/spread\" {\n      valid = false\n    }\n  }\n  if !valid {\n    let base = match callType.parameters.get(0) {\n      case Some(value) => typeText(value)\n      case None => \"?\"\n    }\n    addDiagnostic(state, moduleIndex, \"TPZ5004\",\n      \"newtype `{callee.identity}` constructor takes 1 argument (the `{base}` to wrap), found {actualCount}\",\n      \"\", diagnosticNode)\n  }\n  let mut slots: Array<int> = []\n  for argument in arguments { slots.push(if valid { 0 } else { -2 }) }\n  CallArgumentPlan { slots: slots, leadingSlot: if hasLeading && valid { 0 } else { -2 },\n    resultUnknown: false }\n}\n\nexport function prepareCall(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  diagnosticNode: SyntaxNode,\n  leading: Option<LeadingCallArgument>,\n) -> CallPreparation {\n  let callee = match child(node, \"callee\") {\n    case Some(found) => found\n    case None => node\n  }\n  let inferredCallee = inferCallCallee(\n    service,\n    state,\n    moduleIndex,\n    source,\n    diagnosticNode,\n    callee,\n  )\n  let referencedDefinition = match calleeReference(\n    state,\n    moduleIndex,\n    callee,\n  ) {\n    case Some(reference) => functionDefinitionForReference(state, reference)\n    case None => None\n  }\n  let userProtocolTarget = userProtocolCallTarget(\n    service, state, moduleIndex, source, callee)\n  let parameters = callTypeParameters(service, state, moduleIndex, source,\n    callee, inferredCallee.receiverType, referencedDefinition,\n    userProtocolTarget, inferredCallee.declaredType)\n  let schemeParameters = scopeCallParameters(parameters, moduleIndex, node)\n  let declaredType = instantiateCallType(inferredCallee.declaredType,\n    parameters, schemeParameters)\n  let bindings = explicitCallBindings(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    diagnosticNode,\n    callee,\n    referencedDefinition,\n    inferredCallee.optionalContainer == \"\",\n    inferredCallee.receiverType,\n    match userProtocolTarget {\n      case Some(_) => []\n      case None => schemeParameters\n    },\n  )\n  match currentExpectedExpression(state, node) {\n    case Some(expectedResult) => match declaredType.result.get(0) {\n      case Some(declaredResult) => collectTypeBindings(\n        declaredResult,\n        expectedResult,\n        bindings,\n        false,\n        schemeParameters,\n      )\n      case None => ()\n    }\n    case None => ()\n  }\n  let hasLeading = match leading {\n    case Some(_) => true\n    case None => false\n  }\n  let contextualType = applyBindings(\n    newtypeCallType(state, moduleIndex, diagnosticNode, declaredType), bindings)\n  let projectedMember = projectedCallMember(\n    source,\n    callee,\n    inferredCallee.receiverType,\n  )\n  let callSignature = match referencedDefinition {\n    case Some(definition) => Some(declaredCallSignature(definition))\n    case None => match userProtocolTarget {\n      case Some(target) => Some(userProtocolCallSignature(target))\n      case None => match inferredCallee.builtinSignature {\n        case Some(signature) => Some(signature)\n        case None => if state.languageMode == \"topaz-5.21\" &&\n          inferredCallee.receiverType.kind == \"unknown\" {\n          // An unresolved receiver has no builtin parameter names. Its first\n          // inference owns the diagnostic; do not infer it again for a call plan.\n          None\n        } else {\n          builtinMemberCallSignature(\n            service,\n            state,\n            moduleIndex,\n            source,\n            node,\n            callee,\n          )\n        }\n      }\n    }\n  }\n  let deferProtocolArity = match userProtocolTarget {\n    case Some(_) => true\n    case None => false\n  }\n  let argumentPlan = if declaredType.kind == \"newtype\" &&\n    contextualType.kind == \"function\" {\n    planNewtypeArguments(state, moduleIndex, node, diagnosticNode,\n      declaredType, contextualType, hasLeading)\n  } else if projectedMember != \"\" {\n    unknownCallArgumentPlan(node)\n  } else { match callSignature {\n    case Some(signature) => planSignatureArguments(\n      state,\n      moduleIndex,\n      source,\n      node,\n      diagnosticNode,\n      signature,\n      hasLeading,\n      deferProtocolArity,\n    )\n    case None => planTypedCallArguments(\n      state,\n      moduleIndex,\n      node,\n      diagnosticNode,\n      contextualType,\n      hasLeading,\n    )\n  } }\n  CallPreparation {\n    callee: callee,\n    diagnosticNode: diagnosticNode,\n    declaredType: declaredType,\n    contextualType: contextualType,\n    schemeParameters: schemeParameters,\n    receiverType: inferredCallee.receiverType,\n    optionalContainer: inferredCallee.optionalContainer,\n    referencedDefinition: referencedDefinition,\n    userProtocolTarget: userProtocolTarget,\n    argumentPlan: argumentPlan,\n    bindings: bindings,\n    leading: leading,\n    projectedMember: projectedMember,\n  }\n}\n\nrecord ProjectedArmCallResult {\n  status: string,\n  resultType: TypeValue,\n}\n\nfunction projectedArmCalleeType(\n  state: CheckerState,\n  moduleIndex: int,\n  receiverType: TypeValue,\n  member: string,\n) -> TypeValue {\n  match receiverMethodType(state, moduleIndex, receiverType, member) {\n    case Some(found) => found\n    case None => memberType(state, moduleIndex, receiverType, member)\n  }\n}\n\nfunction projectedArmCallSignature(\n  state: CheckerState,\n  moduleIndex: int,\n  receiverType: TypeValue,\n  member: string,\n) -> Option<CallSignature> {\n  match receiverMethodCallSignature(\n    state,\n    moduleIndex,\n    receiverType,\n    member,\n  ) {\n    case Some(found) => Some(found)\n    case None => builtinReceiverCallSignature(receiverType, member, state.languageMode)\n  }\n}\n\nfunction completeProjectedArmCall(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n  receiverType: TypeValue,\n) -> ProjectedArmCallResult {\n  let declaredCallee = projectedArmCalleeType(\n    state,\n    moduleIndex,\n    receiverType,\n    preparation.projectedMember,\n  )\n  let parameters = callTypeParameters(service, state, moduleIndex, source,\n    preparation.callee, receiverType, None, None, declaredCallee)\n  let scheme = scopeCallParameters(parameters, moduleIndex, node)\n  let calleeType = instantiateCallType(declaredCallee, parameters, scheme)\n  if calleeType.kind == \"unknown\" {\n    return ProjectedArmCallResult {\n      status: \"absent\",\n      resultType: emptyType(\"unknown\"),\n    }\n  }\n  if calleeType.kind != \"function\" {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5005\",\n      \"`{typeText(calleeType)}` is not callable\",\n      \"\",\n      match child(preparation.callee, \"field\") {\n        case Some(field) => field\n        case None => preparation.callee\n      },\n    )\n    return ProjectedArmCallResult {\n      status: \"not-callable\",\n      resultType: emptyType(\"unknown\"),\n    }\n  }\n  let diagnosticNode = match child(preparation.callee, \"field\") {\n    case Some(field) => field\n    case None => preparation.diagnosticNode\n  }\n  let hasLeading = match preparation.leading {\n    case Some(_) => true\n    case None => false\n  }\n  let argumentPlan = match projectedArmCallSignature(\n    state,\n    moduleIndex,\n    receiverType,\n    preparation.projectedMember,\n  ) {\n    case Some(signature) => planSignatureArguments(\n      state,\n      moduleIndex,\n      source,\n      node,\n      diagnosticNode,\n      signature,\n      hasLeading,\n      false,\n    )\n    case None => planTypedCallArguments(\n      state,\n      moduleIndex,\n      node,\n      diagnosticNode,\n      calleeType,\n      hasLeading,\n    )\n  }\n  let mut bindings: Array<TypeBinding> = []\n  collectCallInputTypeBindings(\n    node,\n    calleeType,\n    argumentPlan,\n    inferred.types,\n    preparation.leading,\n    bindings,\n    scheme,\n  )\n  let specialized = applyBindings(calleeType, bindings)\n  refineCallArguments(\n    state,\n    moduleIndex,\n    node,\n    specialized,\n    argumentPlan.slots,\n    false,\n    inferred.types,\n    inferred.nodes,\n    bindings,\n  )\n  refineLeadingCallArgument(\n    state,\n    moduleIndex,\n    specialized,\n    argumentPlan,\n    preparation.leading,\n    diagnosticNode,\n  )\n  let rawResult = if argumentPlan.resultUnknown {\n    emptyType(\"unknown\")\n  } else {\n    match specialized.result.get(0) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n  }\n  gatePreparedCallCapabilities(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    CallPreparation {\n      ...preparation,\n      diagnosticNode: diagnosticNode,\n      declaredType: calleeType,\n      contextualType: calleeType,\n      schemeParameters: scheme,\n      receiverType: receiverType,\n      optionalContainer: \"\",\n      referencedDefinition: None,\n      userProtocolTarget: None,\n      argumentPlan: argumentPlan,\n      bindings: bindings,\n      projectedMember: \"\",\n    },\n    inferred,\n    bindings,\n    rawResult,\n  )\n  ProjectedArmCallResult {\n    status: \"callable\",\n    resultType: rawResult,\n  }\n}\n\nfunction projectedMemberCallResult(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n) -> TypeValue {\n  let receiverType = preparation.receiverType\n  if receiverType.kind != \"union\" {\n    let projection = \"CallOf<{typeText(receiverType)}, {preparation.projectedMember}>\"\n    return rigid(\n      projection,\n      \"projection:{projection}\",\n    )\n  }\n  let mut results: Array<TypeValue> = []\n  for arm in receiverType.members {\n    if arm.kind == \"literal\" && arm.name == \"null\" {\n      continue\n    }\n    if rigidOrUnionRigid(arm) {\n      let projection = \"CallOf<{typeText(arm)}, {preparation.projectedMember}>\"\n      results.push(rigid(\n        projection,\n        \"projection:{projection}\",\n      ))\n      continue\n    }\n    let completed = completeProjectedArmCall(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n      preparation,\n      inferred,\n      arm,\n    )\n    if completed.status == \"not-callable\" {\n      return emptyType(\"unknown\")\n    }\n    if completed.status == \"absent\" {\n      let projection = \"CallOf<{typeText(receiverType)}, {preparation.projectedMember}>\"\n      return rigid(\n        projection,\n        \"projection:{projection}\",\n      )\n    }\n    results.push(completed.resultType)\n  }\n  unionType(results)\n}\n\nfunction completeProjectedMemberCall(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n) -> CompletedCall {\n  let specialized = applyBindings(\n    preparation.declaredType,\n    preparation.bindings,\n  )\n  let observedCallee = wrapOptionalResult(\n    specialized,\n    preparation.optionalContainer,\n  )\n  replaceNodeType(\n    state,\n    moduleIndex,\n    \"expression\",\n    preparation.callee,\n    observedCallee,\n  )\n  let rawResult = projectedMemberCallResult(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    preparation,\n    inferred,\n  )\n  CompletedCall {\n    calleeType: observedCallee,\n    resultType: wrapOptionalResult(rawResult, preparation.optionalContainer),\n  }\n}\n\nexport function completePreparedCall(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  preparation: CallPreparation,\n  inferred: InferredCallArguments,\n) -> CompletedCall {\n  if preparation.declaredType.kind == \"newtype\" &&\n    preparation.contextualType.kind == \"function\" {\n    refineCallArguments(state, moduleIndex, node, preparation.contextualType,\n      preparation.argumentPlan.slots, false, inferred.types, inferred.nodes, [])\n    refineLeadingCallArgument(state, moduleIndex, preparation.contextualType,\n      preparation.argumentPlan, preparation.leading, preparation.diagnosticNode)\n    return CompletedCall {\n      calleeType: preparation.declaredType,\n      resultType: match preparation.contextualType.result.get(0) {\n        case Some(result) => result\n        case None => preparation.declaredType\n      },\n    }\n  }\n  if preparation.projectedMember != \"\" {\n    return completeProjectedMemberCall(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n      preparation,\n      inferred,\n    )\n  }\n  let mut bindings = preparation.bindings\n  // Inputs were bound and checked in inference order. Completion may retry\n  // the result context, but never feeds later evidence back into earlier args.\n  collectCallResultBindings(\n    state,\n    node,\n    preparation.declaredType,\n    bindings,\n    preparation.schemeParameters,\n  )\n  let actuals = completeCallActuals(preparation.leading, inferred.types)\n  let boundSpecialized = specializeCallCallee(\n    state,\n    moduleIndex,\n    source,\n    node,\n    preparation.callee,\n    preparation.declaredType,\n    actuals,\n    bindings,\n  )\n  let specialized = preserveUnboundBuiltinCallTypeParameters(\n    service,\n    state,\n    moduleIndex,\n    source,\n    preparation.callee,\n    preparation.receiverType,\n    preparation.schemeParameters,\n    bindings,\n    boundSpecialized,\n  )\n  let observedCallee = wrapOptionalResult(\n    specialized,\n    preparation.optionalContainer,\n  )\n  replaceNodeType(\n    state,\n    moduleIndex,\n    \"expression\",\n    preparation.callee,\n    observedCallee,\n  )\n  let candidates = checkedCallResultCandidates(\n    service,\n    state,\n    moduleIndex,\n    source,\n    preparation.callee,\n    preparation.declaredType,\n  )\n  match candidates.nominal {\n    case Some(value) => { let _ = checkNominalConstructionContext(state, moduleIndex, node, value) }\n    case None => ()\n  }\n  let rawResult = if preparation.argumentPlan.resultUnknown {\n    emptyType(\"unknown\")\n  } else {\n    callResultType(\n      specialized,\n      preparation.declaredType,\n      candidates.nominal,\n      candidates.protocol,\n      bindings,\n    )\n  }\n  gatePreparedCallCapabilities(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    preparation,\n    inferred,\n    bindings,\n    rawResult,\n  )\n  let result = wrapOptionalResult(rawResult, preparation.optionalContainer)\n  match preparation.referencedDefinition {\n    case Some(definition) => checkFunctionBounds(\n      state,\n      moduleIndex,\n      preparation.diagnosticNode,\n      definition,\n      preparation.schemeParameters,\n      bindings,\n    )\n    case None => ()\n  }\n  CompletedCall {\n    calleeType: observedCallee,\n    resultType: result,\n  }\n}\n\nexport function inferCall(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  match child(node, \"callee\") {\n    case Some(callee) => {\n      if reportRemovedStaticMember(state, moduleIndex, source, callee) {\n        return emptyType(\"unknown\")\n      }\n      match nominalConstructorCallResult(state, moduleIndex, source, callee) {\n        case Some(value) => if value.kind == \"enum\" &&\n          children(node, \"typeArguments\").length == 0 &&\n          checkNominalConstructionContext(state, moduleIndex, node, value) {\n          // Stage 0 rejects the enum instantiation before checking payloads.\n          // Infer arguments without a declared payload expectation and recover\n          // with Unknown, rather than exposing the enum's rigid parameters.\n          for argument in children(node, \"arguments\") {\n            let _ = serviceInferExpression(\n              service, state, moduleIndex, source, argumentValue(argument))\n          }\n          return emptyType(\"unknown\")\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  let preparation = prepareCall(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    node,\n    None,\n  )\n  let inferred = inferCallArguments(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    preparation,\n  )\n  let completed = completePreparedCall(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    preparation,\n    inferred,\n  )\n  addCall(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    preparation.callee,\n    completed.calleeType,\n    preparation.receiverType,\n    completed.resultType,\n  )\n  completed.resultType\n}\n",
      "sourceSha256": "4260fb5bd202ff7b12c98fcc6445c2adc2527686a67869fdaa4bd44181a1c7f4"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/call_facts.tpz",
      "language": "topaz",
      "bytes": 68013,
      "sha256": "3666ed4d02430a8fffdce700e8b3d4899356164f7a48d8ad6449d372625e2e60",
      "content": "import common.standard_migration { removedStaticHint }\nimport checker.builtin_signatures { builtinNamespaceFamily, requiredCallSignature, defaultedCallSignature, builtinReceiverCallSignature, staticBuiltinDataCallSignature }\n// Owns typed-call observations and the expected-expression and pipe stacks.\n// call_plan selects signatures; call_complete performs argument solving, keeping\n// the mutually recursive expression service out of both modules.\n\nimport types {\n  PreviewCallArgument,\n  PreviewCallEvaluation,\n  PreviewResolvedReference,\n  PreviewTypedCall,\n  SyntaxNode,\n}\nimport checker_types { TypeValue }\nimport unicode { didYouMean }\nimport checker.model {\n  lengthType,\n  BuiltinFunction,\n  BoundBuiltin,\n  CallSignature,\n  CheckerService,\n  CheckerState,\n  ExpectedExpressionContext,\n  ProtocolDefinition,\n  constructor,\n  emptyType,\n  functionType,\n  literal,\n  primitive,\n  rigid,\n  serviceInferExpression,\n}\nimport checker.type_algebra {\n  assignable,\n  diagnosticTypeText,\n  flattenType,\n  flattenedHasHole,\n  hasHole,\n  typeEqual,\n  typeText,\n  unionType,\n  widen,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  addNode,\n  child,\n  children,\n  declarationFor,\n  declarationOriginForReference,\n  definitionNameKey,\n  moduleAt,\n  moduleIdentityAt,\n  protocolDefinition,\n  referenceFor,\n  replaceNodeType,\n  resolvedTypeFromFact,\n  scopeFor,\n  scopeIsWithin,\n  spanKey,\n  symbolTypeAt,\n  text,\n  unwrapExport,\n}\nimport checker.protocols_methods {\n  receiverMethodTargetIdentity,\n  referenceTargetType,\n}\nimport checker.members_capabilities {\n  builtinNamespaceMemberType,\n  standardBoundary,\n  iterableElement,\n}\n\nexport function argumentValue(argument: SyntaxNode) -> SyntaxNode {\n  if argument.kind == \"call-argument/named\" || argument.kind == \"call-argument/spread\" {\n    match child(argument, \"value\") {\n      case Some(found) => found\n      case None => argument\n    }\n  } else {\n    argument\n  }\n}\n\n// A declaration signature belongs to the callable itself. References used\n// while evaluating a receiver or producing a callable are different calls.\nexport function calleeReference(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> Option<PreviewResolvedReference> {\n  if node.kind == \"expression/parenthesized\" {\n    return match child(node, \"operand\") {\n      case Some(operand) => calleeReference(state, moduleIndex, operand)\n      case None => None\n    }\n  }\n  if node.kind == \"expression/identifier\" {\n    return referenceFor(state, moduleIndex, node.lo, node.hi)\n  }\n  if node.kind == \"expression/member\" {\n    match child(node, \"field\") {\n      case Some(field) => return referenceFor(state, moduleIndex, field.lo, field.hi)\n      case None => ()\n    }\n  }\n  None\n}\n\nfunction callableReferenceInNode(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> Option<PreviewResolvedReference> {\n  if node.kind == \"expression/identifier\" {\n    return referenceFor(state, moduleIndex, node.lo, node.hi)\n  }\n  if node.kind == \"expression/parenthesized\" {\n    return match child(node, \"operand\") {\n      case Some(operand) => callableReferenceInNode(state, moduleIndex, operand)\n      case None => None\n    }\n  }\n  if node.kind == \"expression/member\" ||\n    node.kind == \"expression/optional-access\" {\n    return match child(node, \"field\") {\n      case Some(field) => referenceFor(state, moduleIndex, field.lo, field.hi)\n      case None => None\n    }\n  }\n  None\n}\n\nfunction referenceTargetIdentity(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> string {\n  match declarationFor(\n    state,\n    reference.targetModuleIndex,\n    reference.targetLo,\n    reference.targetHi,\n  ) {\n    case Some(declaration) => if declaration.targetModule != \"\" &&\n      declaration.targetName != \"\" {\n      \"{declaration.targetModule}::{declaration.targetName}\"\n    } else if reference.targetModule != \"\" && reference.targetName != \"\" {\n      \"{reference.targetModule}::{reference.targetName}\"\n    } else {\n      \"\"\n    }\n    case None => if reference.targetModule != \"\" && reference.targetName != \"\" {\n      \"{reference.targetModule}::{reference.targetName}\"\n    } else {\n      \"\"\n    }\n  }\n}\n\nfunction callMethodClass(name: string) -> string {\n  match name {\n    case \"map\" | \"filter\" | \"reduce\" | \"flatMap\" | \"mapErr\" => \"higher-order\"\n    case \"okOrElse\" => \"lazy-callback\"\n    case \"push\" | \"insert\" | \"set\" | \"remove\" | \"update\" | \"clear\" |\n      \"extend\" | \"add\" => \"mutator\"\n    case \"read\" | \"write\" | \"close\" | \"open\" => \"resource\"\n    case _ => \"other\"\n  }\n}\n\nexport function builtinMutator(receiver: TypeValue, name: string) -> bool {\n  if receiver.kind == \"union\" {\n    for member in receiver.members {\n      if builtinMutator(member, name) {\n        return true\n      }\n    }\n    return false\n  }\n  if receiver.kind == \"constructor\" && receiver.name == \"Array\" {\n    return name == \"push\" || name == \"pop\" || name == \"clear\" ||\n      name == \"reverse\" || name == \"insert\" || name == \"removeAt\" ||\n      name == \"sort\" || name == \"sortBy\" || name == \"retain\"\n  }\n  if receiver.kind == \"constructor\" && receiver.name == \"Map\" {\n    return name == \"insert\" || name == \"remove\" || name == \"clear\" ||\n      name == \"update\"\n  }\n  if receiver.kind == \"constructor\" && receiver.name == \"Set\" {\n    return name == \"add\" || name == \"remove\" || name == \"clear\"\n  }\n  receiver.kind == \"byte-buffer\" &&\n    (name == \"set\" || name == \"fill\" || name == \"copy\")\n}\n\nfunction requiredBuiltinFunction(\n  parameters: Array<TypeValue>,\n  result: TypeValue,\n  parameterNames: Array<string>,\n) -> BuiltinFunction {\n  BuiltinFunction {\n    typeValue: functionType(parameters, [], result),\n    callSignature: requiredCallSignature(parameterNames, false),\n  }\n}\n\nfunction defaultedBuiltinFunction(\n  parameters: Array<TypeValue>,\n  result: TypeValue,\n  parameterNames: Array<string>,\n  parameterDefaults: Array<bool>,\n) -> BuiltinFunction {\n  BuiltinFunction {\n    typeValue: functionType(parameters, [], result),\n    callSignature: defaultedCallSignature(\n      parameterNames,\n      parameterDefaults,\n    ),\n  }\n}\n\nexport function builtinFunction(name: string, languageMode: string = \"topaz-5.20\") -> Option<BuiltinFunction> {\n  if languageMode == \"topaz-5.21\" && (name == \"toFloat\" || name == \"toInt\" || name == \"toIntRadix\" || name == \"fromCodePoint\" || name == \"map\" || name == \"filter\" || name == \"reduce\" || name == \"print\" || name == \"input\" || name == \"open\" || name == \"assert\") { return None }\n  match name {\n    case \"print\" => Some(requiredBuiltinFunction(\n      [primitive(\"string\")],\n      primitive(\"unit\"),\n      [\"value\"],\n    ))\n    case \"toInt\" => Some(requiredBuiltinFunction(\n      [primitive(\"string\")],\n      constructor(\"Option\", [primitive(\"int\")]),\n      [\"text\"],\n    ))\n    case \"toIntRadix\" => Some(requiredBuiltinFunction(\n      [primitive(\"string\"), primitive(\"int\")],\n      constructor(\"Option\", [primitive(\"int\")]),\n      [\"text\", \"radix\"],\n    ))\n    case \"fromCodePoint\" => Some(requiredBuiltinFunction(\n      [primitive(\"int\")],\n      constructor(\"Option\", [primitive(\"string\")]),\n      [\"n\"],\n    ))\n    case \"toFloat\" => Some(requiredBuiltinFunction(\n      [primitive(\"int\")],\n      primitive(\"float\"),\n      [\"n\"],\n    ))\n    case \"map\" => {\n      let input = rigid(\"T\", \"builtin::map\")\n      let output = rigid(\"U\", \"builtin::map\")\n      Some(requiredBuiltinFunction(\n        [\n          emptyType(\"unknown\"),\n          functionType([input], [], output),\n        ],\n        constructor(\"Array\", [output]),\n        [\"xs\", \"f\"],\n      ))\n    }\n    case \"filter\" => {\n      let input = rigid(\"T\", \"builtin::filter\")\n      Some(requiredBuiltinFunction(\n        [\n          emptyType(\"unknown\"),\n          functionType([input], [], primitive(\"bool\")),\n        ],\n        constructor(\"Array\", [input]),\n        [\"xs\", \"f\"],\n      ))\n    }\n    case \"reduce\" => {\n      let input = rigid(\"T\", \"builtin::reduce\")\n      let output = rigid(\"U\", \"builtin::reduce\")\n      Some(requiredBuiltinFunction(\n        [\n          emptyType(\"unknown\"),\n          output,\n          functionType([output, input], [], output),\n        ],\n        output,\n        [\"xs\", \"initial\", \"f\"],\n      ))\n    }\n    case \"input\" => Some(requiredBuiltinFunction(\n      [],\n      primitive(\"string\"),\n      [],\n    ))\n    case \"open\" => Some(requiredBuiltinFunction(\n      [primitive(\"string\")],\n      constructor(\"Result\", [emptyType(\"file\"), primitive(\"string\")]),\n      [\"path\"],\n    ))\n    case \"assert\" => Some(defaultedBuiltinFunction(\n      [primitive(\"bool\"), primitive(\"string\")],\n      primitive(\"unit\"),\n      [\"condition\", \"message\"],\n      [false, true],\n    ))\n    case \"Some\" => {\n      let value = rigid(\"T\", \"builtin::Some\")\n      Some(requiredBuiltinFunction(\n        [value],\n        constructor(\"Option\", [value]),\n        [\"value\"],\n      ))\n    }\n    case \"Ok\" => {\n      let value = rigid(\"T\", \"builtin::Ok\")\n      let error = rigid(\"E\", \"builtin::Ok\")\n      Some(requiredBuiltinFunction(\n        [value],\n        constructor(\"Result\", [value, error]),\n        [\"value\"],\n      ))\n    }\n    case \"Err\" => {\n      let value = rigid(\"T\", \"builtin::Err\")\n      let error = rigid(\"E\", \"builtin::Err\")\n      Some(requiredBuiltinFunction(\n        [error],\n        constructor(\"Result\", [value, error]),\n        [\"error\"],\n      ))\n    }\n    case _ => None\n  }\n}\n\nfunction builtinFunctionType(name: string, languageMode: string = \"topaz-5.20\") -> Option<TypeValue> {\n  match builtinFunction(name, languageMode) {\n    case Some(found) => Some(found.typeValue)\n    case None => None\n  }\n}\n\nexport function builtinIdentifierType(name: string, languageMode: string = \"topaz-5.20\") -> Option<TypeValue> {\n  match builtinFunctionType(name, languageMode) {\n    case Some(found) => if name == \"Some\" || name == \"Ok\" ||\n      name == \"Err\" || name == \"map\" || name == \"filter\" ||\n      name == \"reduce\" {\n      Some(emptyType(\"unknown\"))\n    } else {\n      Some(found)\n    }\n    case None => None\n  }\n}\n\nexport function isBuiltinNamespace(name: string) -> bool {\n  builtinNamespaceFamily(name) != \"\"\n}\n\nfunction unboundFunctionSuggestionNames() -> Array<string> {\n  [\n    \"print\",\n    \"toInt\",\n    \"toIntRadix\",\n    \"fromCodePoint\",\n    \"toFloat\",\n    \"map\",\n    \"filter\",\n    \"reduce\",\n    \"input\",\n    \"open\",\n    \"assert\",\n    \"Some\",\n    \"Ok\",\n    \"Err\",\n  ]\n}\n\nexport function numericMigrationHint(state: CheckerState, name: string) -> string {\n  if state.languageMode != \"topaz-5.21\" { return \"\" }\n  match name {\n    case \"Math\" => \"; use float receiver methods and string.parseFloat() in 5.21\"\n    case \"toFloat\" => \"; use int.toFloat() in 5.21\"\n    case \"toInt\" => \"; use string.toInt() in 5.21\"\n    case \"toIntRadix\" => \"; use string.toIntRadix(radix) in 5.21\"\n    case \"fromCodePoint\" => \"; use int.toCodePoint() in 5.21\"\n    case \"map\" => \"; use xs.map(f) in 5.21\"\n    case \"filter\" => \"; use xs.filter(f) in 5.21\"\n    case \"reduce\" => \"; use xs.reduce(initial, f) in 5.21\"\n    case \"print\" => \"; import std.io and use io.writeLine(value) in 5.21\"\n    case \"input\" => \"; import std.io and use io.readStdin() in 5.21\"\n    case \"open\" => \"; import std.io and use io.open(...) in 5.21\"\n    case \"assert\" => \"; import std.test and use test.assert(...) in 5.21\"\n    case _ => \"\"\n  }\n}\n\nexport function unboundSuggestion(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> string {\n  let migration = numericMigrationHint(state, reference.name)\n  if migration != \"\" { return migration }\n  let mut candidates: Array<string> = []\n  match state.valueDeclarationIndexesByModule.get(\"{reference.moduleIndex}\") {\n    case Some(indexes) => for index in indexes {\n      match state.resolved.declarations.get(index) {\n        case Some(declaration) => if scopeIsWithin(\n          state,\n          reference.moduleIndex,\n          reference.scopeOrdinal,\n          declaration.scopeOrdinal,\n        ) {\n          candidates.push(declaration.name)\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  for candidate in unboundFunctionSuggestionNames() {\n    match builtinIdentifierType(candidate, state.languageMode) { case Some(_) => candidates.push(candidate); case None => () }\n  }\n  candidates.push(\"None\")\n  didYouMean(reference.name, candidates)\n}\n\nexport function unboundCalleeSuggestion(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> string {\n  let migration = numericMigrationHint(state, reference.name)\n  if migration != \"\" { return migration }\n  let mut candidates: Array<string> = []\n  let mut seen: Set<string> = set {}\n  let mut scopeOrdinal = reference.scopeOrdinal\n  while scopeOrdinal >= 0 {\n    match state.valueDeclarationIndexesByModule.get(\"{reference.moduleIndex}\") {\n      case Some(indexes) => for index in indexes {\n        match state.resolved.declarations.get(index) {\n          case Some(declaration) => if declaration.scopeOrdinal == scopeOrdinal {\n            match symbolTypeAt(\n              state,\n              reference.moduleIndex,\n              declaration.lo,\n              declaration.hi,\n            ) {\n              case Some(typeValue) => if !seen.contains(declaration.name) {\n                seen.add(declaration.name)\n                if typeValue.kind == \"function\" {\n                  candidates.push(declaration.name)\n                }\n              }\n              case None => ()\n            }\n          }\n          case None => ()\n        }\n      }\n      case None => ()\n    }\n    scopeOrdinal = match scopeFor(state, reference.moduleIndex, scopeOrdinal) {\n      case Some(scope) => scope.parentOrdinal\n      case None => -1\n    }\n  }\n  for candidate in unboundFunctionSuggestionNames() {\n    if !seen.contains(candidate) {\n      match builtinIdentifierType(candidate, state.languageMode) { case Some(_) => candidates.push(candidate); case None => () }\n    }\n  }\n  didYouMean(reference.name, candidates)\n}\n\nexport function diagnoseUnboundReferences(state: CheckerState) -> () {\n  for reference in state.resolved.references {\n    if reference.targetModuleIndex >= 0 ||\n      reference.namespace != \"value\" ||\n      reference.role == \"read\" ||\n      generatedLispexIntrinsic(state, reference.moduleIndex, reference.name) ||\n      reference.name == \"None\" ||\n      isBuiltinNamespace(reference.name) ||\n      match builtinIdentifierType(reference.name, state.languageMode) {\n        case Some(_) => true\n        case None => false\n      } {\n      continue\n    }\n    addDiagnostic(\n      state,\n      reference.moduleIndex,\n      \"TPZ5002\",\n      \"`{reference.name}` is not bound{unboundSuggestion(state, reference)}\",\n      \"\",\n      SyntaxNode {\n        kind: \"identifier\",\n        lo: reference.lo,\n        hi: reference.hi,\n        field: \"\",\n        index: 0,\n        attributes: [],\n        children: [],\n      },\n    )\n  }\n  ()\n}\n\nexport function currentFunctionReturn(state: CheckerState) -> Option<TypeValue> {\n  if state.expectedReturns.length == 0 {\n    return None\n  }\n  match state.expectedReturns.get(state.expectedReturns.length - 1) {\n    case Some(context) => Some(context.typeValue)\n    case None => None\n  }\n}\n\nexport function isBareBindingExpression(state: CheckerState, node: SyntaxNode) -> bool {\n  match state.bareBindingExpressions.get(state.bareBindingExpressions.length - 1) {\n    case Some(value) => value.kind == node.kind && value.lo == node.lo && value.hi == node.hi\n    case None => false\n  }\n}\n\nexport function currentExpectedExpression(\n  state: CheckerState,\n  expression: SyntaxNode,\n) -> Option<TypeValue> {\n  if state.expectedExpressions.length == 0 {\n    return None\n  }\n  match state.expectedExpressions.get(state.expectedExpressions.length - 1) {\n    case Some(context) => if context.kind == expression.kind &&\n      context.lo == expression.lo && context.hi == expression.hi {\n      Some(context.typeValue)\n    } else {\n      None\n    }\n    case None => None\n  }\n}\n\nexport function inferExpressionWithExpected(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n  expected: TypeValue,\n  contextual: bool,\n) -> TypeValue {\n  inferExpressionWithResultContext(service, state, moduleIndex, source,\n    expression, expected, contextual, true)\n}\n\n// The enclosing callable can own the result comparison while its body still\n// needs the expected type to infer parameters and polymorphic constructions.\nexport function inferExpressionWithResultContext(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n  expected: TypeValue,\n  contextual: bool,\n  checkResult: bool,\n) -> TypeValue {\n  let mut expectedExpressions = state.expectedExpressions\n  expectedExpressions.push(ExpectedExpressionContext {\n    kind: expression.kind,\n    lo: expression.lo,\n    hi: expression.hi,\n    typeValue: expected,\n    checkResult: checkResult,\n  })\n  let inferred = if contextual {\n    inferExpressionContext(service, state, moduleIndex, source, expression)\n  } else {\n    serviceInferExpression(service, state, moduleIndex, source, expression)\n  }\n  expectedExpressions.pop()\n  inferred\n}\n\nexport function currentExpressionChecksResult(\n  state: CheckerState,\n  expression: SyntaxNode,\n) -> bool {\n  match state.expectedExpressions.get(state.expectedExpressions.length - 1) {\n    case Some(context) => if context.kind == expression.kind &&\n      context.lo == expression.lo && context.hi == expression.hi {\n      context.checkResult\n    } else {\n      true\n    }\n    case None => true\n  }\n}\n\nfunction appendReturnType(state: CheckerState, value: TypeValue) -> () {\n  if state.returnJoins.length == 0 {\n    return ()\n  }\n  let index = state.returnJoins.length - 1\n  match state.returnJoins.get(index) {\n    case Some(found) => {\n      let mut values = found\n      values.push(value)\n      let mut joins = state.returnJoins\n      joins[index] = values\n    }\n    case None => ()\n  }\n  ()\n}\n\nexport function checkReturn(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> () {\n  let value = child(node, \"value\")\n  match state.expectedReturns.get(state.expectedReturns.length - 1) {\n    case None => {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"`return` outside a function\",\n        \"\",\n        node,\n      )\n      match value {\n        case Some(found) => {\n          let _ = serviceInferExpression(service, state, moduleIndex, source, found)\n        }\n        case None => ()\n      }\n    }\n    case Some(context) => {\n      let expected = context.typeValue\n      let inferred = match value {\n        case Some(found) => if expected.kind == \"unknown\" {\n          serviceInferExpression(service, state, moduleIndex, source, found)\n        } else {\n          inferExpressionWithResultContext(service, state, moduleIndex, source,\n            found, expected, false, context.checkResult)\n        }\n        case None => primitive(\"unit\")\n      }\n      // Both contextual and inferred callables retain every actual return type.\n      appendReturnType(state, inferred)\n      if context.checkResult && expected.kind != \"unknown\" {\n        let valueNode = match value {\n          case Some(found) => found\n          case None => node\n        }\n        let refined = refineExpressionToExpected(state, moduleIndex, valueNode,\n          inferred, expected)\n        reportExpectedType(state, moduleIndex, valueNode, expected, refined)\n      }\n    }\n  }\n  ()\n}\n\nexport function builtinCallTypeParameters(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n  receiverType: TypeValue,\n) -> Array<string> {\n  let empty: Array<string> = []\n  match boundBuiltinForCallee(state, moduleIndex, callee) { case Some(bound) => return bound.typeParameters; case None => () }\n  let boundary = canonicalBoundaryTarget(state, moduleIndex, source, callee)\n  if boundary.length == 2 && boundary[0] == \"JSON\" && (boundary[1] == \"parseAs\" || boundary[1] == \"stringify\") { return [\"T\"] }\n  if boundary.length == 2 && boundary[0] == \"Test\" {\n    if boundary[1] == \"assertEq\" || boundary[1] == \"assertNe\" || boundary[1] == \"assertSome\" || boundary[1] == \"assertNone\" { return [\"T\"] }\n    if boundary[1] == \"assertOk\" || boundary[1] == \"assertErr\" { return [\"T\", \"E\"] }\n  }\n  if callee.kind == \"expression/identifier\" {\n    if !unshadowedIdentifier(state, moduleIndex, callee) {\n      return empty\n    }\n    return match text(source, callee) {\n      case \"Some\" => [\"T\"]\n      case \"Ok\" | \"Err\" => [\"T\", \"E\"]\n      case \"map\" | \"reduce\" => [\"T\", \"U\"]\n      case \"filter\" => [\"T\"]\n      case _ => empty\n    }\n  }\n  if callee.kind != \"expression/member\" {\n    return empty\n  }\n  let object = match child(callee, \"object\") {\n    case Some(found) => found\n    case None => return empty\n  }\n  let field = match child(callee, \"field\") {\n    case Some(found) => text(source, found)\n    case None => return empty\n  }\n  if !builtinNamespaceObject(service, state, moduleIndex, source, object) {\n    if state.languageMode == \"topaz-5.21\" && receiverType.kind == \"json-value\" && field == \"decode\" { return [\"T\"] }\n    if receiverType.kind != \"constructor\" {\n      return empty\n    }\n    return match receiverType.name {\n      case \"Option\" => match field {\n        case \"okOr\" | \"okOrElse\" | \"map\" | \"flatMap\" => [\"U\"]\n        case _ => empty\n      }\n      case \"Result\" => match field {\n        case \"mapErr\" => [\"F\"]\n        case \"map\" | \"flatMap\" => [\"U\"]\n        case _ => empty\n      }\n      case \"Set\" | \"Range\" => if state.languageMode == \"topaz-5.21\" && (field == \"map\" || field == \"reduce\") { [\"U\"] } else { empty }\n      case \"Array\" => match field {\n        case \"map\" | \"reduce\" => [\"U\"]\n        case \"sortedBy\" | \"sortBy\" => [\"K\"]\n        case _ => empty\n      }\n      case \"Map\" => if field == \"mapValues\" { [\"W\"] } else { empty }\n      case _ => empty\n    }\n  }\n  match text(source, object) {\n    case \"Array\" | \"Set\" => if field == \"of\" { [\"T\"] } else { empty }\n    case \"Map\" => if field == \"new\" || field == \"ofEntries\" {\n      [\"K\", \"V\"]\n    } else {\n      empty\n    }\n    case \"JSON\" => if field == \"parseAs\" || field == \"decode\" ||\n      field == \"stringify\" {\n      [\"T\"]\n    } else {\n      empty\n    }\n    case \"Test\" => match field {\n      case \"assertEq\" | \"assertNe\" | \"assertSome\" | \"assertNone\" => [\"T\"]\n      case \"assertOk\" | \"assertErr\" => [\"T\", \"E\"]\n      case _ => empty\n    }\n    case _ => empty\n  }\n}\n\nexport function contextualBuiltinCall(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n  callee: SyntaxNode,\n  calleeType: TypeValue,\n) -> Option<TypeValue> {\n  if !unshadowedIdentifier(state, moduleIndex, callee) {\n    return None\n  }\n  let name = text(source, callee)\n  if name != \"Ok\" && name != \"Err\" {\n    return None\n  }\n  let expected = match currentExpectedExpression(state, expression) {\n    case Some(found) => found\n    case None => return None\n  }\n  if expected.kind != \"constructor\" ||\n    expected.name != \"Result\" ||\n    expected.arguments.length != 2 || hasHole(expected) {\n    return None\n  }\n  let parameter = if name == \"Ok\" {\n    expected.arguments.get(0)\n  } else {\n    expected.arguments.get(1)\n  }\n  match parameter {\n    case Some(found) => Some(functionType([found], [], expected))\n    case None => Some(calleeType)\n  }\n}\n\nexport function contextualBuiltinArgumentType(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n  argumentIndex: int,\n  actuals: Array<TypeValue>,\n  fallback: Option<TypeValue>,\n) -> Option<TypeValue> {\n  if !unshadowedIdentifier(state, moduleIndex, callee) {\n    return fallback\n  }\n  let name = text(source, callee)\n  if argumentIndex == 1 && (name == \"map\" || name == \"filter\") {\n    match actuals.get(0) {\n      case Some(collection) => {\n        let input = iterableElement(collection)\n        match fallback {\n          case Some(callback) => match callback.result.get(0) {\n            case Some(output) => return Some(functionType(\n              [input], callback.variadic, output))\n            case None => ()\n          }\n          case None => ()\n        }\n      }\n      case None => ()\n    }\n  }\n  if argumentIndex == 2 && name == \"reduce\" {\n    let input = match actuals.get(0) {\n      case Some(collection) => iterableElement(collection)\n      case None => emptyType(\"unknown\")\n    }\n    let output = match actuals.get(1) {\n      case Some(initial) => widen(initial)\n      case None => emptyType(\"unknown\")\n    }\n    return Some(functionType(\n      [output, input],\n      [],\n      output,\n    ))\n  }\n  fallback\n}\n\nexport function contextualStandardWrapperCall(\n  state: CheckerState,\n  moduleIndex: int,\n  expression: SyntaxNode,\n  callee: SyntaxNode,\n  calleeType: TypeValue,\n  actuals: Array<TypeValue>,\n) -> Option<TypeValue> {\n  if callee.kind != \"expression/member\" &&\n    callee.kind != \"expression/optional-access\" {\n    return None\n  }\n  if calleeType.kind != \"unknown\" {\n    return None\n  }\n  match moduleAt(state, moduleIndex) {\n    case Some(module) => if !module.identity.startsWith(\"std.\") {\n      return None\n    }\n    case None => return None\n  }\n  let expected = match currentExpectedExpression(state, expression) {\n    case Some(found) => found\n    case None => return None\n  }\n  let mut parameters: Array<TypeValue> = []\n  for actual in actuals {\n    parameters.push(widen(actual))\n  }\n  match moduleAt(state, moduleIndex) {\n    case Some(module) => {\n      let field = match child(callee, \"field\") {\n        case Some(found) => text(module.source, found)\n        case None => \"\"\n      }\n      if module.identity == \"std.decimal\" &&\n        ((field == \"round\" && parameters.length == 1) ||\n        (field == \"div\" && parameters.length == 2)) {\n        parameters.push(emptyType(\"rounding-mode\"))\n      }\n    }\n    case None => ()\n  }\n  Some(functionType(parameters, [], expected))\n}\n\nexport function boundBuiltinForCallee(state: CheckerState, moduleIndex: int, callee: SyntaxNode) -> Option<BoundBuiltin> {\n  let reference = match calleeReference(state, moduleIndex, callee) { case Some(value) => value; case None => return None }\n  let declaration = match declarationOriginForReference(state, reference) { case Some(value) => value; case None => return None }\n  state.boundBuiltins.get(spanKey(declaration.moduleIndex, declaration.lo, declaration.hi))\n}\n\nexport function recordBoundBuiltin(\n  service: CheckerService, state: CheckerState, moduleIndex: int, source: Bytes,\n  declaration: SyntaxNode, value: SyntaxNode, valueType: TypeValue,\n) -> () {\n  if valueType.kind != \"function\" { return () }\n  let key = spanKey(moduleIndex, declaration.lo, declaration.hi)\n  match boundBuiltinForCallee(state, moduleIndex, value) {\n    case Some(found) => { let mut bindings = state.boundBuiltins; bindings.insert(key, found); return () }\n    case None => ()\n  }\n  let mut receiver = emptyType(\"unknown\")\n  let mut member = \"\"\n  let mut boundary = canonicalBoundaryTarget(state, moduleIndex, source, value)\n  let mut signature: Option<CallSignature> = None\n  if boundary.length == 2 {\n    member = boundary[1]\n    if boundary[0] == \"\" { match builtinFunction(member, \"topaz-5.20\") { case Some(found) => { signature = Some(found.callSignature) }; case None => () } }\n    else { signature = staticBuiltinDataCallSignature(boundary[0], member) }\n  } else if value.kind == \"expression/member\" {\n    let object = match child(value, \"object\") { case Some(found) => found; case None => return () }\n    let field = match child(value, \"field\") { case Some(found) => found; case None => return () }\n    member = text(source, field)\n    if builtinNamespaceObject(service, state, moduleIndex, source, object) {\n      boundary = [text(source, object), member]\n      signature = staticBuiltinDataCallSignature(boundary[0], member)\n    } else {\n      receiver = serviceInferExpression(service, state, moduleIndex, source, object)\n      signature = builtinReceiverCallSignature(receiver, member, state.languageMode)\n    }\n  } else { return () }\n  match signature { case None => return (); case Some(_) => () }\n  let target = if boundary.length == 2 && boundary[0] == \"JSON\" && member == \"parseAs\" { \"builtin::JsonParseAs\" }\n    else if boundary.length == 2 && boundary[0] == \"JSON\" && member == \"parse\" { \"builtin::JsonParse\" }\n    else if boundary.length == 2 && boundary[0] == \"JSON\" && member == \"stringify\" { \"builtin::JsonStringify\" }\n    else if receiver.kind == \"json-value\" && member == \"decode\" { \"builtin::JsonDecode\" } else { \"\" }\n  let metadata = BoundBuiltin { typeValue: valueType, receiverType: receiver, member: member, boundary: boundary,\n    typeParameters: builtinCallTypeParameters(service, state, moduleIndex, source, value, receiver), signature: signature, target: target }\n  let mut bindings = state.boundBuiltins\n  bindings.insert(key, metadata)\n  ()\n}\n\nexport function canonicalBoundaryTarget(state: CheckerState, moduleIndex: int, source: Bytes, callee: SyntaxNode) -> Array<string> {\n  if state.languageMode != \"topaz-5.21\" { return [] }\n  if callee.kind == \"expression/identifier\" {\n    match moduleAt(state, moduleIndex) {\n      case Some(module) => if module.generatedStd {\n        let binding = standardBoundary(module.identity, text(source, callee))\n        if binding.length == 2 { return binding }\n      }\n      case None => ()\n    }\n  }\n  match calleeReference(state, moduleIndex, callee) {\n    case Some(reference) => {\n      match moduleAt(state, reference.targetModuleIndex) {\n        case Some(module) => if !module.generatedStd { return [] }\n        case None => return []\n      }\n      return match referenceTargetIdentity(state, reference) {\n        case \"std.fs::readText\" => [\"FS\", \"readText\"]\n        case \"std.fs::writeText\" => [\"FS\", \"writeText\"]\n        case \"std.fs::readBytes\" => [\"FS\", \"readBytes\"]\n        case \"std.fs::writeBytes\" => [\"FS\", \"writeBytes\"]\n        case \"std.fs::list\" => [\"FS\", \"list\"]\n        case \"std.io::readStdin\" => [\"\", \"input\"]\n        case \"std.io::open\" => [\"\", \"open\"]\n        case \"std.json::parse\" => [\"JSON\", \"parse\"]\n        case \"std.json::stringify\" => [\"JSON\", \"stringify\"]\n        case \"std.json::parseAs\" => [\"JSON\", \"parseAs\"]\n        case \"std.csv::parse\" => [\"CSV\", \"parse\"]\n        case \"std.csv::parseWithHeader\" => [\"CSV\", \"parseWithHeader\"]\n        case \"std.csv::stringify\" => [\"CSV\", \"stringify\"]\n        case \"std.csv::stringifyWithHeader\" => [\"CSV\", \"stringifyWithHeader\"]\n        case \"std.toml::parse\" => [\"TOML\", \"parse\"]\n        case \"std.toml::stringify\" => [\"TOML\", \"stringify\"]\n        case \"std.toml::fromJson\" => [\"TOML\", \"fromJson\"]\n        case \"std.test::assert\" => [\"Test\", \"assert\"]\n        case \"std.test::assertEq\" => [\"Test\", \"assertEq\"]\n        case \"std.test::assertNe\" => [\"Test\", \"assertNe\"]\n        case \"std.test::assertContains\" => [\"Test\", \"assertContains\"]\n        case \"std.test::assertOk\" => [\"Test\", \"assertOk\"]\n        case \"std.test::assertErr\" => [\"Test\", \"assertErr\"]\n        case \"std.test::assertSome\" => [\"Test\", \"assertSome\"]\n        case \"std.test::assertNone\" => [\"Test\", \"assertNone\"]\n        case \"std.test::assertGolden\" => [\"Test\", \"assertGolden\"]\n        case _ => []\n      }\n    }\n    case None => []\n  }\n}\n\nexport function generatedStandardFunctionType(state: CheckerState, moduleIndex: int, name: string) -> Option<TypeValue> {\n  let module = match moduleAt(state, moduleIndex) { case Some(found) => found; case None => return None }\n  if !module.generatedStd { return None }\n  let binding = standardBoundary(module.identity, name)\n  let namespace = match binding.get(0) { case Some(found) => found; case None => return None }\n  let member = match binding.get(1) { case Some(found) => found; case None => return None }\n  if namespace == \"\" { return builtinFunctionType(member, \"topaz-5.20\") }\n  builtinNamespaceMemberType(namespace, member, \"topaz-5.20\")\n}\n\nexport function generatedLispexIntrinsic(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> bool {\n  match moduleAt(state, moduleIndex) {\n    case Some(module) => if !module.generatedStd {\n      false\n    } else if standardBoundary(module.identity, name).length == 2 {\n      true\n    } else if module.identity == \"std.typeset\" && state.languageMode == \"topaz-5.21\" {\n      name == \"__lengthFromScaledPoints\" || name == \"__lengthFromMilliPoints\"\n    } else if module.identity == \"std.lispex.rules\" {\n      name == \"__lispexRule\"\n    } else if module.identity == \"std.lispex\" {\n      name == \"__lispexValueFromCanonical\" ||\n        name == \"__lispexCanonicalBytes\" ||\n        name == \"__lispexDefaultLimits\" ||\n        name == \"__lispexInspectRule\" ||\n        name == \"__lispexEvaluate\" ||\n        name == \"__lispexEvaluateWithEvidence\" ||\n        name == \"__lispexConsumerArtifactFromBytes\" ||\n        name == \"__lispexConsumerArtifactBytes\" ||\n        name == \"__lispexPortableCoreBytes\" ||\n        name == \"__lispexInspectConsumerArtifact\" ||\n        name == \"__lispexVerifyConsumerArtifact\" ||\n        name == \"__lispexFreshReplay\"\n    } else {\n      false\n    }\n    case None => false\n  }\n}\n\nexport function contextualGeneratedLispexCall(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n  callee: SyntaxNode,\n  actuals: Array<TypeValue>,\n) -> Option<TypeValue> {\n  if callee.kind != \"expression/identifier\" ||\n    !generatedLispexIntrinsic(state, moduleIndex, text(source, callee)) {\n    return None\n  }\n  if text(source,callee) == \"__lengthFromScaledPoints\" || text(source,callee) == \"__lengthFromMilliPoints\" {\n    return Some(functionType([primitive(\"int\")],[],lengthType(\"Pt\")))\n  }\n  let expected = match currentExpectedExpression(state, expression) {\n    case Some(found) => found\n    case None => return None\n  }\n  let mut parameters: Array<TypeValue> = []\n  for actual in actuals {\n    parameters.push(widen(actual))\n  }\n  Some(functionType(parameters, [], expected))\n}\n\nfunction builtinCallIdentity(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n) -> string {\n  match boundBuiltinForCallee(state, moduleIndex, callee) { case Some(bound) => if bound.target != \"\" { return bound.target }; case None => () }\n  let boundary = canonicalBoundaryTarget(state, moduleIndex, source, callee)\n  if boundary.length == 2 && boundary[0] == \"JSON\" && boundary[1] == \"parseAs\" { return \"builtin::JsonParseAs\" }\n  if boundary.length == 2 && boundary[0] == \"JSON\" && boundary[1] == \"parse\" { return \"builtin::JsonParse\" }\n  if boundary.length == 2 && boundary[0] == \"JSON\" && boundary[1] == \"stringify\" { return \"builtin::JsonStringify\" }\n  if state.languageMode == \"topaz-5.21\" && callee.kind == \"expression/member\" {\n    match child(callee, \"field\") {\n      case Some(field) => if text(source, field) == \"decode\" {\n        match child(callee, \"object\") { case Some(object) => if serviceInferExpression(service, state, moduleIndex, source, object).kind == \"json-value\" { return \"builtin::JsonDecode\" }; case None => () }\n      }\n      case None => ()\n    }\n  }\n  if callee.kind == \"expression/identifier\" {\n    let name = text(source, callee)\n    if generatedLispexIntrinsic(state, moduleIndex, name) {\n      return \"builtin::{name}\"\n    }\n    if unshadowedIdentifier(state, moduleIndex, callee) {\n      match builtinFunctionType(name, state.languageMode) {\n        case Some(_) => return \"builtin::{name}\"\n        case None => ()\n      }\n    }\n  }\n  if callee.kind == \"expression/member\" {\n    match child(callee, \"object\") {\n      case Some(object) => {\n        match userProtocolObject(state, moduleIndex, source, object) {\n          case Some(definition) => return \"builtin::{definition.name}\"\n          case None => ()\n        }\n        if builtinNamespaceObject(\n          service,\n          state,\n          moduleIndex,\n          source,\n          object,\n        ) {\n          let name = text(source, object)\n          // JSON static operations have no resolved callable declaration.\n          // Their member plan and checked types carry the invocation.\n          if name == \"JSON\" { return \"\" }\n          return \"builtin::{name}\"\n        }\n      }\n      case None => ()\n    }\n  }\n  \"\"\n}\n\nfunction previewSourceCallArgument(\n  source: Bytes,\n  argument: SyntaxNode,\n  sourceIndex: int,\n) -> PreviewCallArgument {\n  let value = argumentValue(argument)\n  PreviewCallArgument {\n    bindingKind: if argument.kind == \"call-argument/named\" {\n      \"named\"\n    } else if argument.kind == \"call-argument/spread\" {\n      \"spread\"\n    } else {\n      \"positional\"\n    },\n    bindingName: if argument.kind == \"call-argument/named\" {\n      match child(argument, \"name\") {\n        case Some(found) => text(source, found)\n        case None => \"\"\n      }\n    } else {\n      \"\"\n    },\n    sourceIndex: Some(sourceIndex),\n    lo: value.lo,\n    hi: value.hi,\n  }\n}\n\nfunction projectedCallIdentity(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n  reference: Option<PreviewResolvedReference>,\n) -> string {\n  match reference {\n    case Some(found) => if found.targetModule == \"std.lispex.rules\" &&\n      found.targetName != \"\" {\n      return \"topaz.lispex-rule-handle/v1:{found.targetName}\"\n    }\n    case None => ()\n  }\n  // A bound JSON boundary keeps its builtin target through module aliases,\n  // selected imports and value aliases; the std declaration is only the route.\n  match boundBuiltinForCallee(state, moduleIndex, callee) { case Some(bound) => if bound.target != \"\" { return bound.target }; case None => () }\n  let boundary = canonicalBoundaryTarget(state, moduleIndex, source, callee)\n  if boundary.length == 2 && boundary[0] == \"JSON\" {\n    let intrinsic = builtinCallIdentity(service, state, moduleIndex, source, callee)\n    if intrinsic != \"\" { return intrinsic }\n  }\n  let identity = match reference {\n    case Some(found) => referenceTargetIdentity(state, found)\n    case None => \"\"\n  }\n  if identity != \"\" {\n    return identity\n  }\n  builtinCallIdentity(service, state, moduleIndex, source, callee)\n}\n\nrecord CallFactContext {\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  callee: SyntaxNode,\n  calleeType: TypeValue,\n  receiverType: TypeValue,\n  resultType: TypeValue,\n}\n\nrecord CallArgumentObservation {\n  arguments: Array<PreviewCallArgument>,\n  evaluations: Array<PreviewCallEvaluation>,\n}\n\nrecord DirectCallProjection {\n  field: string,\n  calleeType: TypeValue,\n  identity: string,\n  observation: CallArgumentObservation,\n}\n\nfunction callField(source: Bytes, callee: SyntaxNode) -> string {\n  match child(callee, \"field\") {\n    case Some(found) => text(source, found)\n    case None => \"\"\n  }\n}\n\nfunction projectedDirectCalleeType(\n  context: CallFactContext,\n  reference: Option<PreviewResolvedReference>,\n) -> TypeValue {\n  if context.calleeType.kind != \"unknown\" {\n    return context.calleeType\n  }\n  match reference {\n    case Some(foundReference) => match resolvedTypeFromFact(\n      context.state,\n      foundReference,\n    ) {\n      case Some(found) => if found.kind == \"unknown\" {\n        context.calleeType\n      } else {\n        found\n      }\n      case None => context.calleeType\n    }\n    case None => context.calleeType\n  }\n}\n\nfunction directCallArguments(\n  context: CallFactContext,\n  field: string,\n) -> CallArgumentObservation {\n  let mut arguments: Array<PreviewCallArgument> = []\n  let mut evaluations: Array<PreviewCallEvaluation> = [\n    PreviewCallEvaluation {\n      kind: if field == \"\" { \"callee\" } else { \"receiver\" },\n      argumentIndex: -1,\n    },\n  ]\n  if context.callee.kind == \"expression/optional-access\" {\n    evaluations.push(PreviewCallEvaluation {\n      kind: \"optional-guard\",\n      argumentIndex: -1,\n    })\n  }\n  let mut sourceIndex = 0\n  for argument in children(context.node, \"arguments\") {\n    arguments.push(previewSourceCallArgument(context.source, argument, sourceIndex))\n    evaluations.push(PreviewCallEvaluation {\n      kind: \"argument\",\n      argumentIndex: sourceIndex,\n    })\n    sourceIndex += 1\n  }\n  CallArgumentObservation { arguments: arguments, evaluations: evaluations }\n}\n\nfunction directCallProjection(service: CheckerService, context: CallFactContext) -> DirectCallProjection {\n  let field = callField(context.source, context.callee)\n  let reference = callableReferenceInNode(\n    context.state,\n    context.moduleIndex,\n    context.callee,\n  )\n  let receiverIdentity = if field == \"\" {\n    \"\"\n  } else {\n    receiverMethodTargetIdentity(\n      context.state,\n      context.moduleIndex,\n      context.receiverType,\n      field,\n    )\n  }\n  DirectCallProjection {\n    field: field,\n    calleeType: projectedDirectCalleeType(context, reference),\n    identity: if receiverIdentity != \"\" {\n      receiverIdentity\n    } else {\n      projectedCallIdentity(\n        service,\n        context.state,\n        context.moduleIndex,\n        context.source,\n        context.callee,\n        reference,\n      )\n    },\n    observation: directCallArguments(context, field),\n  }\n}\n\nfunction appendCall(state: CheckerState, value: PreviewTypedCall) -> () {\n  let key = spanKey(value.moduleIndex, value.lo, value.hi)\n  let mut indexes = state.callIndexes\n  match indexes.get(key) {\n    case Some(_) => ()\n    case None => indexes.insert(key, state.calls.length)\n  }\n  let mut target = state.calls\n  target.push(value)\n}\n\nexport function addCall(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  callee: SyntaxNode,\n  calleeType: TypeValue,\n  receiverType: TypeValue,\n  resultType: TypeValue,\n) -> () {\n  let context = CallFactContext {\n    state: state,\n    moduleIndex: moduleIndex,\n    source: source,\n    node: node,\n    callee: callee,\n    calleeType: calleeType,\n    receiverType: receiverType,\n    resultType: resultType,\n  }\n  let projected = directCallProjection(service, context)\n  appendCall(state, PreviewTypedCall {\n    moduleIndex: moduleIndex,\n    lo: node.lo,\n    hi: node.hi,\n    calleeLo: callee.lo,\n    calleeHi: callee.hi,\n    calleeType: flattenType(projected.calleeType),\n    resultType: flattenType(context.resultType),\n    targetIdentity: projected.identity,\n    ambient: hasHole(projected.calleeType) || hasHole(context.resultType),\n    calleeKind: if projected.field == \"\" { \"value\" } else { \"member\" },\n    method: projected.field,\n    methodClass: if projected.field == \"\" {\n      \"\"\n    } else {\n      callMethodClass(projected.field)\n    },\n    optional: callee.kind == \"expression/optional-access\",\n    shadowFirst: projected.field == \"mapErr\" || projected.field == \"map\" || projected.field == \"filter\" ||\n      projected.field == \"reduce\" || projected.field == \"flatMap\" ||\n      projected.field == \"okOrElse\",\n    stageMethod: \"\",\n    arguments: projected.observation.arguments,\n    evaluations: projected.observation.evaluations,\n  })\n}\n\nexport function containsPlaceholder(node: SyntaxNode) -> bool {\n  if node.kind == \"expression/placeholder\" {\n    return true\n  }\n  if node.kind == \"expression/pipe\" {\n    return match child(node, \"left\") {\n      case Some(left) => containsPlaceholder(left)\n      case None => false\n    }\n  }\n  for nested in node.children {\n    if containsPlaceholder(nested) {\n      return true\n    }\n  }\n  false\n}\n\nexport function currentPipeValue(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  match state.pipeValues.get(state.pipeValues.length - 1) {\n    case Some(found) => match found.values.get(0) {\n      case Some(value) => value\n      case None => {\n        // A callee can demand the saved input before argument inference. Infer\n        // it once, with the enclosing pipe exposed for placeholders in its lhs.\n        // A placeholder inside a callback must not lend its callable context\n        // to the input. Slice the stacks at the pipe's lexical boundary; keep\n        // the enclosing return-join arrays shared so its returns reach their owner.\n        let inputState = CheckerState {\n          ...state,\n          activeFunctions: state.activeFunctions.slice(0, found.activeFunctionDepth),\n          expectedReturns: state.expectedReturns.slice(0, found.returnDepth),\n          returnJoins: state.returnJoins.slice(0, found.returnDepth),\n          expectedExpressions: state.expectedExpressions.slice(0, found.expectedExpressionDepth),\n          diagnostics: [],\n        }\n        let mut pipeValues = state.pipeValues\n        pipeValues.pop()\n        let value = match currentExpectedExpression(state, node) {\n          case Some(expected) => inferExpressionWithResultContext(\n            service, inputState, found.moduleIndex, source, found.node,\n            expected, true, false)\n          case None => serviceInferExpression(\n            service, inputState, found.moduleIndex, source, found.node)\n        }\n        let mut values = found.values\n        values.push(value)\n        pipeValues.push(found)\n        // Saved input diagnostics precede any stage diagnostics already queued.\n        let mut diagnostics = found.diagnostics\n        let mut index = 0\n        for diagnostic in inputState.diagnostics {\n          diagnostics.insert(index, diagnostic)\n          index += 1\n        }\n        value\n      }\n    }\n    case None => {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"a placeholder `_` is valid only inside a pipeline stage (§11)\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    }\n  }\n}\n\nrecord PipeCallContext {\n  call: CallFactContext,\n  left: SyntaxNode,\n  stage: SyntaxNode,\n  hasPlaceholder: bool,\n}\n\nrecord PipeCallProjection {\n  identity: string,\n  stageMethod: string,\n  observation: CallArgumentObservation,\n}\n\nfunction pipeCallArguments(context: PipeCallContext) -> CallArgumentObservation {\n  let call = context.call\n  let mut arguments: Array<PreviewCallArgument> = []\n  let mut sourceIndex = 0\n  let missingSourceIndex: Option<int> = None\n  if context.stage.kind == \"expression/call\" {\n    for argument in children(context.stage, \"arguments\") {\n      arguments.push(previewSourceCallArgument(\n        call.source,\n        argument,\n        sourceIndex,\n      ))\n      sourceIndex += 1\n    }\n    if !context.hasPlaceholder {\n      arguments.insert(0, PreviewCallArgument {\n        bindingKind: \"inserted-lead\",\n        bindingName: \"\",\n        sourceIndex: missingSourceIndex,\n        lo: context.left.lo,\n        hi: context.left.hi,\n      })\n    }\n  } else {\n    arguments.push(PreviewCallArgument {\n      bindingKind: \"inserted-lead\",\n      bindingName: \"\",\n      sourceIndex: missingSourceIndex,\n      lo: context.left.lo,\n      hi: context.left.hi,\n    })\n  }\n  let mut evaluations: Array<PreviewCallEvaluation> = [\n    PreviewCallEvaluation {\n      kind: if context.hasPlaceholder { \"pipe-lead\" } else { \"argument\" },\n      argumentIndex: if context.hasPlaceholder { -1 } else { 0 },\n    },\n    PreviewCallEvaluation {\n      kind: \"receiver\",\n      argumentIndex: -1,\n    },\n  ]\n  if call.callee.kind == \"expression/optional-access\" {\n    evaluations.push(PreviewCallEvaluation {\n      kind: \"optional-guard\",\n      argumentIndex: -1,\n    })\n  }\n  let mut argumentIndex = 0\n  while argumentIndex < arguments.length {\n    if context.hasPlaceholder || argumentIndex != 0 {\n      evaluations.push(PreviewCallEvaluation {\n        kind: \"argument\",\n        argumentIndex: argumentIndex,\n      })\n    }\n    argumentIndex += 1\n  }\n  CallArgumentObservation { arguments: arguments, evaluations: evaluations }\n}\n\nfunction pipeCallProjection(service: CheckerService, context: PipeCallContext) -> PipeCallProjection {\n  let call = context.call\n  let reference = callableReferenceInNode(\n    call.state,\n    call.moduleIndex,\n    call.callee,\n  )\n  let stageMethod = match child(call.callee, \"field\") {\n    case Some(found) => text(call.source, found)\n    case None => \"\"\n  }\n  let receiverIdentity = if stageMethod == \"\" {\n    \"\"\n  } else {\n    receiverMethodTargetIdentity(\n      call.state,\n      call.moduleIndex,\n      call.receiverType,\n      stageMethod,\n    )\n  }\n  PipeCallProjection {\n    identity: if receiverIdentity != \"\" {\n      receiverIdentity\n    } else {\n      projectedCallIdentity(\n        service,\n        call.state,\n        call.moduleIndex,\n        call.source,\n        call.callee,\n        reference,\n      )\n    },\n    stageMethod: stageMethod,\n    observation: pipeCallArguments(context),\n  }\n}\n\nexport function addPipeCall(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  left: SyntaxNode,\n  stage: SyntaxNode,\n  callee: SyntaxNode,\n  calleeType: TypeValue,\n  receiverType: TypeValue,\n  resultType: TypeValue,\n  hasPlaceholder: bool,\n) -> () {\n  let context = PipeCallContext {\n    call: CallFactContext {\n      state: state,\n      moduleIndex: moduleIndex,\n      source: source,\n      node: node,\n      callee: callee,\n      calleeType: calleeType,\n      receiverType: receiverType,\n      resultType: resultType,\n    },\n    left: left,\n    stage: stage,\n    hasPlaceholder: hasPlaceholder,\n  }\n  let projected = pipeCallProjection(service, context)\n  appendCall(state, PreviewTypedCall {\n    moduleIndex: moduleIndex,\n    lo: node.lo,\n    hi: node.hi,\n    calleeLo: stage.lo,\n    calleeHi: stage.hi,\n    calleeType: flattenType(calleeType),\n    resultType: flattenType(resultType),\n    targetIdentity: projected.identity,\n    ambient: hasHole(calleeType) || hasHole(resultType),\n    calleeKind: \"pipe\",\n    method: \"\",\n    methodClass: \"\",\n    optional: context.call.callee.kind == \"expression/optional-access\",\n    shadowFirst: false,\n    stageMethod: projected.stageMethod,\n    arguments: projected.observation.arguments,\n    evaluations: projected.observation.evaluations,\n  })\n}\n\nfunction replaceCallResultType(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  resultType: TypeValue,\n) -> () {\n  let mut calls = state.calls\n  match state.callIndexes.get(spanKey(moduleIndex, node.lo, node.hi)) {\n    case Some(index) => match calls.get(index) {\n      case Some(call) => {\n        let nextCalleeType = if call.targetIdentity == \"builtin::Map\" &&\n          call.method == \"new\" {\n          flattenType(functionType([], [], resultType))\n        } else {\n          call.calleeType\n        }\n        calls[index] = PreviewTypedCall {\n          moduleIndex: call.moduleIndex,\n          lo: call.lo,\n          hi: call.hi,\n          calleeLo: call.calleeLo,\n          calleeHi: call.calleeHi,\n          calleeType: nextCalleeType,\n          resultType: flattenType(resultType),\n          targetIdentity: call.targetIdentity,\n          ambient: flattenedHasHole(nextCalleeType) || hasHole(resultType),\n          calleeKind: call.calleeKind,\n          method: call.method,\n          methodClass: call.methodClass,\n          optional: call.optional,\n          shadowFirst: call.shadowFirst,\n          stageMethod: call.stageMethod,\n          arguments: call.arguments,\n          evaluations: call.evaluations,\n        }\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction isBuiltinMapNewCall(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> bool {\n  match state.callIndexes.get(spanKey(moduleIndex, node.lo, node.hi)) {\n    case Some(index) => match state.calls.get(index) {\n      case Some(call) => call.targetIdentity == \"builtin::Map\" &&\n        call.method == \"new\"\n      case None => false\n    }\n    case None => false\n  }\n}\n\nexport function inferExpressionContext(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n) -> TypeValue {\n  let mut contexts = state.literalJoinContexts\n  contexts.push(expression.lo)\n  let result = serviceInferExpression(service, state, moduleIndex, source, expression)\n  contexts.pop()\n  result\n}\n\nfunction hasPriorDiagnostic(state: CheckerState) -> bool {\n  state.resolved.diagnostics.length > 0 || state.diagnostics.length > 0\n}\n\nexport function reportExpectedType(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  expected: TypeValue,\n  actual: TypeValue,\n) -> () {\n  // Recovery unknowns can flow through bindings beyond the original error's\n  // span. Keep the existing partial-type recovery for an already rejected unit.\n  if hasHole(actual) && hasPriorDiagnostic(state) { return () }\n  if !hasHole(expected) && !contextualTypeAssignable(expected, actual, false) {\n    let shown = if expected.kind == \"primitive\" {\n      widen(actual)\n    } else {\n      actual\n    }\n    let currentModule = moduleIdentityAt(state, moduleIndex)\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"expected `{diagnosticTypeText(expected, currentModule)}`, found `{diagnosticTypeText(shown, currentModule)}`\",\n      \"\",\n      node,\n    )\n  }\n}\n\nfunction contextualTypesAssignable(\n  expected: Array<TypeValue>,\n  actual: Array<TypeValue>,\n  invariant: bool,\n) -> bool {\n  if expected.length != actual.length { return false }\n  let mut index = 0\n  while index < expected.length {\n    match [expected.get(index), actual.get(index)] {\n      case [Some(wanted), Some(found)] => if !contextualTypeAssignable(wanted, found, invariant) {\n        return false\n      }\n      case _ => return false\n    }\n    index += 1\n  }\n  true\n}\n\n// Unknown components are unconstrained; their concrete siblings are not. Keep\n// ordinary assignability (including collection invariance) once both are known.\nfunction contextualTypeAssignable(expected: TypeValue, actual: TypeValue, invariant: bool) -> bool {\n  if expected.kind == \"unknown\" || expected.kind == \"inference-variable\" ||\n    actual.kind == \"unknown\" || actual.kind == \"inference-variable\" { return true }\n  if !hasHole(expected) && !hasHole(actual) {\n    if invariant { return typeEqual(expected, actual) }\n    return assignable(expected, actual)\n  }\n  if !invariant && actual.kind == \"union\" {\n    for member in actual.members {\n      if !contextualTypeAssignable(expected, member, false) { return false }\n    };\n    return true\n  }\n  if !invariant && expected.kind == \"union\" {\n    for member in expected.members {\n      if contextualTypeAssignable(member, actual, false) { return true }\n    };\n    return false\n  }\n  if expected.kind != actual.kind || expected.name != actual.name ||\n    expected.identity != actual.identity || expected.origin != actual.origin ||\n    expected.fieldNames.length != actual.fieldNames.length { return false }\n  let mut index = 0\n  while index < expected.fieldNames.length {\n    if expected.fieldNames.get(index) != actual.fieldNames.get(index) { return false }\n    index += 1\n  }\n  if expected.kind == \"function\" && !invariant {\n    return contextualTypesAssignable(actual.parameters, expected.parameters, false) &&\n      contextualTypesAssignable(actual.variadic, expected.variadic, false) &&\n      contextualTypesAssignable(expected.result, actual.result, false)\n  }\n  let invariantArguments = invariant ||\n    (expected.kind == \"constructor\" && expected.name != \"Option\" && expected.name != \"Result\") ||\n    expected.kind == \"nominal-record\" || expected.kind == \"enum\" || expected.kind == \"newtype\"\n  contextualTypesAssignable(expected.arguments, actual.arguments, invariantArguments) &&\n    contextualTypesAssignable(expected.members, actual.members, invariant) &&\n    contextualTypesAssignable(expected.fields, actual.fields, invariant) &&\n    contextualTypesAssignable(expected.parameters, actual.parameters, invariant) &&\n    contextualTypesAssignable(expected.variadic, actual.variadic, invariant) &&\n    contextualTypesAssignable(expected.result, actual.result, invariant)\n}\n\nfunction fillContextualTypeList(actual: Array<TypeValue>, expected: Array<TypeValue>) -> Array<TypeValue> {\n  let mut filled: Array<TypeValue> = []\n  let mut index = 0\n  for value in actual {\n    filled.push(match expected.get(index) {\n      case Some(context) => fillContextualTypeHoles(value, context)\n      case None => value\n    })\n    index += 1\n  };\n  filled\n}\n\nfunction fillContextualTypeHoles(actual: TypeValue, expected: TypeValue) -> TypeValue {\n  if actual.kind == \"unknown\" || actual.kind == \"inference-variable\" { return expected }\n  if !hasHole(actual) { return actual }\n  if actual.kind == \"union\" {\n    let mut members: Array<TypeValue> = []\n    for member in actual.members { members.push(fillContextualTypeHoles(member, expected)) };\n    return unionType(members)\n  }\n  if expected.kind == \"union\" {\n    let mut chosen: Option<TypeValue> = None\n    for member in expected.members {\n      if contextualTypeAssignable(member, actual, false) {\n        let filled = fillContextualTypeHoles(actual, member)\n        match chosen {\n          case Some(previous) => if !typeEqual(previous, filled) { return actual }\n          case None => { chosen = Some(filled) }\n        }\n      }\n    };\n    return match chosen { case Some(filled) => filled; case None => actual }\n  }\n  if actual.kind != expected.kind || actual.name != expected.name ||\n    actual.identity != expected.identity || actual.origin != expected.origin { return actual }\n  let mut fields: Array<TypeValue> = []\n  let mut index = 0\n  for field in actual.fields {\n    let mut context = field\n    if actual.fieldNames.get(index) == expected.fieldNames.get(index) {\n      match expected.fields.get(index) { case Some(found) => { context = found }; case None => () }\n    }\n    fields.push(fillContextualTypeHoles(field, context))\n    index += 1\n  };\n  TypeValue { ...actual,\n    arguments: fillContextualTypeList(actual.arguments, expected.arguments),\n    members: fillContextualTypeList(actual.members, expected.members),\n    fields: fields,\n    parameters: fillContextualTypeList(actual.parameters, expected.parameters),\n    variadic: fillContextualTypeList(actual.variadic, expected.variadic),\n    result: fillContextualTypeList(actual.result, expected.result),\n  }\n}\n\nexport function checkExpressionExpected(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  expected: TypeValue,\n) -> TypeValue {\n  checkExpressionExpectedResult(service, state, moduleIndex, source,\n    node, expected, false, true)\n}\n\n// Parentheses carry a type but the enclosed value owns a mismatch's source span.\nexport function expressionResultNode(node: SyntaxNode) -> SyntaxNode {\n  if node.kind == \"expression/parenthesized\" {\n    match child(node, \"operand\") { case Some(inner) => return expressionResultNode(inner); case None => () }\n  }\n  node\n}\n\n// A block's tail already owns its comparison. Branch joins retain their own result.\nexport function expressionResultIsDelegated(node: SyntaxNode) -> bool {\n  let value = expressionResultNode(node)\n  if value.kind != \"expression/block\" { return false }\n  match child(value, \"block\") {\n    case Some(block) => match child(block, \"tail\") { case Some(_) => true; case None => false }\n    case None => false\n  }\n}\n\nexport function checkExpressionExpectedResult(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  expected: TypeValue,\n  contextual: bool,\n  checkResult: bool,\n) -> TypeValue {\n  let inferred = inferExpressionWithResultContext(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    expected,\n    contextual,\n    checkResult,\n  )\n  if !checkResult { return inferred }\n  let refined = refineExpressionToExpected(\n    state,\n    moduleIndex,\n    node,\n    inferred,\n    expected,\n  )\n  if !expressionResultIsDelegated(node) {\n    reportExpectedType(state, moduleIndex, expressionResultNode(node), expected, refined)\n  }\n  refined\n}\n\nexport function isImportNamespace(state: CheckerState, moduleIndex: int, name: string) -> bool {\n  match state.namespaceImportIndexes.get(definitionNameKey(moduleIndex, name)) {\n    case Some(_) => true\n    case None => false\n  }\n}\n\nfunction removedStaticValueIsVisible(\n  state: CheckerState, reference: PreviewResolvedReference,\n) -> bool {\n  if reference.targetModuleIndex < 0 || reference.targetNamespace != \"value\" {\n    return false\n  }\n  let declaration = match declarationFor(state, reference.targetModuleIndex,\n    reference.targetLo, reference.targetHi) {\n    case Some(found) => found\n    case None => return false\n  }\n  // Local lets/consts resolve after their initializer; parameters and pattern\n  // bindings resolve inside their scope. Functions hoist in every scope, and\n  // selected imports are bound before checking the importing module's items.\n  if declaration.scopeOrdinal != 0 || declaration.moduleIndex != reference.moduleIndex ||\n    (declaration.declarationKind != \"let\" && declaration.declarationKind != \"const\") {\n    return true\n  }\n  let module = match moduleAt(state, reference.moduleIndex) {\n    case Some(found) => found\n    case None => return false\n  }\n  let mut bindingEnd = -1\n  let mut inConst = false\n  for statement in module.root.children {\n    let item = unwrapExport(statement)\n    if item.lo <= declaration.lo && declaration.hi <= item.hi {\n      bindingEnd = item.hi\n    }\n    if item.lo <= reference.lo && reference.hi <= item.hi {\n      inConst = item.kind == \"statement/const\"\n    }\n  }\n  // Rust checks module constants first, in textual order: they see earlier\n  // constants but no module lets. Ordinary items see every module constant.\n  if declaration.declarationKind == \"const\" && !inConst { return true }\n  if declaration.declarationKind == \"let\" && inConst { return false }\n  // Use the whole declaration, not its name: a let is absent in its own\n  // initializer, including a lambda or block nested inside that initializer.\n  bindingEnd >= 0 && bindingEnd <= reference.lo\n}\n\n// Removed calls stop before generic solving, so one migration diagnostic owns the refusal.\nexport function reportRemovedStaticMember(\n  state: CheckerState, moduleIndex: int, source: Bytes, node: SyntaxNode,\n) -> bool {\n  if state.languageMode != \"topaz-5.21\" || node.kind != \"expression/member\" { return false }\n  let object = match child(node, \"object\") { case Some(found) => found; case None => return false }\n  if object.kind != \"expression/identifier\" { return false }\n  let field = match child(node, \"field\") { case Some(found) => found; case None => return false }\n  let namespace = text(source, object)\n  let member = text(source, field)\n  let hint = removedStaticHint(namespace, member)\n  if hint == \"\" { return false }\n  // Namespace member resolution records the field, not the head identifier.\n  // The import index covers std and user modules even without a head reference.\n  if isImportNamespace(state, moduleIndex, namespace) { return false }\n  match referenceFor(state, moduleIndex, object.lo, object.hi) {\n    case Some(reference) => {\n      if removedStaticValueIsVisible(state, reference) { return false }\n      // Selected imports retain the target nominal's identity under their alias.\n      // A future value binding with a nominal type is still not in scope.\n      if reference.targetNamespace == \"type\" {\n        match referenceTargetType(state, moduleIndex, object) {\n          case Some(found) => if found.kind == \"nominal-record\" ||\n            found.kind == \"enum\" || found.kind == \"newtype\" { return false }\n          case None => ()\n        }\n      }\n    }\n    case None => ()\n  }\n  if namespace != \"JSON\" {\n    match userProtocolObject(state, moduleIndex, source, object) {\n      case Some(_) => return false\n      case None => ()\n    }\n  }\n  addDiagnostic(state, moduleIndex, \"TPZ5002\",\n    \"`{namespace}.{member}` was removed in 5.21; {hint}\", \"\", field)\n  true\n}\n\nexport function builtinNamespaceObject(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  object: SyntaxNode,\n) -> bool {\n  if object.kind != \"expression/identifier\" ||\n    !isBuiltinNamespace(text(source, object)) ||\n    state.languageMode == \"topaz-5.21\" && text(source, object) == \"Math\" {\n    return false\n  }\n  match referenceFor(state, moduleIndex, object.lo, object.hi) {\n    case Some(reference) => reference.targetModuleIndex < 0 ||\n      reference.targetNamespace == \"type\" &&\n      match referenceTargetType(state, moduleIndex, object) {\n        case Some(_) => false\n        case None => true\n      }\n    case None => true\n  }\n}\n\nexport function userProtocolObject(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  object: SyntaxNode,\n) -> Option<ProtocolDefinition> {\n  if object.kind != \"expression/identifier\" {\n    return None\n  }\n  match referenceFor(state, moduleIndex, object.lo, object.hi) {\n    case Some(reference) => {\n      let name = if reference.targetName == \"\" {\n        text(source, object)\n      } else {\n        reference.targetName\n      }\n      if reference.targetNamespace == \"type\" {\n        return protocolDefinition(state, reference.targetModuleIndex, name)\n      }\n      if reference.targetModuleIndex < 0 && reference.namespace == \"value\" {\n        return protocolDefinition(state, moduleIndex, name)\n      }\n      None\n    }\n    case None => protocolDefinition(state, moduleIndex, text(source, object))\n  }\n}\n\nexport function unshadowedIdentifier(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> bool {\n  if node.kind != \"expression/identifier\" {\n    return false\n  }\n  match referenceFor(state, moduleIndex, node.lo, node.hi) {\n    case Some(reference) => reference.targetModuleIndex < 0\n    case None => true\n  }\n}\n\nfunction suppressExpressionObservation(\n  state: CheckerState,\n  source: Bytes,\n  node: SyntaxNode,\n) -> bool {\n  let suppressStatementFor = if node.kind == \"expression/for\" &&\n    state.statementExpressionContexts.length > 0 {\n    match state.statementExpressionContexts.get(\n      state.statementExpressionContexts.length - 1,\n    ) {\n      case Some(lo) => lo == node.lo\n      case None => false\n    }\n  } else {\n    false\n  }\n  let suppressBuiltinNamespace = node.kind == \"expression/identifier\" &&\n    (text(source, node) == \"Bytes\" || text(source, node) == \"JSON\")\n  suppressStatementFor || suppressBuiltinNamespace\n}\n\nexport function recordInferredExpression(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  result: TypeValue,\n) -> () {\n  if result.kind != \"unknown\" &&\n    !suppressExpressionObservation(state, source, node) {\n    addNode(state, moduleIndex, \"expression\", node, result)\n  }\n}\n\nexport function refineExpressionToExpected(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  inferred: TypeValue,\n  expected: TypeValue,\n) -> TypeValue {\n  let recovery = hasHole(inferred) && hasPriorDiagnostic(state)\n  let filled = if hasHole(inferred) && !hasHole(expected) && !recovery {\n    fillContextualTypeHoles(inferred, expected)\n  } else { inferred }\n  if node.kind == \"expression/record-literal\" &&\n    filled.kind == \"record\" &&\n    expected.kind == \"record\" {\n    let matches = if recovery {\n      assignable(expected, inferred)\n    } else {\n      contextualTypeAssignable(expected, filled, false)\n    }\n    if matches {\n      replaceNodeType(state, moduleIndex, \"expression\", node, expected)\n      return expected\n    }\n  }\n  let contextualBuiltinConstructor = node.kind == \"expression/call\" &&\n    isBuiltinMapNewCall(state, moduleIndex, node)\n  if (hasHole(inferred) || contextualBuiltinConstructor) &&\n    !hasHole(expected) &&\n    (inferred.kind == \"unknown\" ||\n    (inferred.kind == expected.kind && inferred.name == expected.name)) {\n    let refined = if contextualBuiltinConstructor || recovery { expected } else { filled }\n    replaceNodeType(state, moduleIndex, \"expression\", node, refined)\n    if node.kind == \"expression/call\" {\n      replaceCallResultType(state, moduleIndex, node, refined)\n      if contextualBuiltinConstructor {\n        match child(node, \"callee\") {\n          case Some(callee) => replaceNodeType(\n            state,\n            moduleIndex,\n            \"expression\",\n            callee,\n            functionType([], [], refined),\n          )\n          case None => ()\n        }\n      }\n    }\n    refined\n  } else {\n    inferred\n  }\n}\n",
      "sourceSha256": "3666ed4d02430a8fffdce700e8b3d4899356164f7a48d8ad6449d372625e2e60"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/call_plan.tpz",
      "language": "topaz",
      "bytes": 31147,
      "sha256": "182c9ffaebd1d63208a3a82e8d1d208029076991f64546f203b141286548af9a",
      "content": "import checker.builtin_signatures { builtinNamespaceFamily, defaultedCallSignature, requiredCallSignature, positionalOnlyCallSignature, staticBuiltinDataCallSignature, builtinReceiverCallSignature }\n// Call-target selection and named, default, variadic, and spread planning.\n// Plans describe slot ownership only; call_complete performs inference and the\n// checker facade records the resulting typed call.\n\nimport types { SyntaxNode }\nimport checker_types { TypeValue }\nimport checker.model {\n  CallArgumentPlan,\n  CallSignature,\n  CheckerService,\n  CheckerState,\n  FunctionDefinition,\n  TypeBinding,\n  UserProtocolCallTarget,\n  constructor,\n  emptyType,\n  literal,\n  primitive,\n  lengthUnit,\n  rigid,\n  serviceInferExpression,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  addNode,\n  child,\n  children,\n  protocolMethodDefinition,\n  text,\n}\nimport checker.nominals { formType }\nimport checker.type_algebra { flattenType }\nimport checker.protocols_methods {\n  builtinProtocolDefinition,\n  enumDefinitionForType,\n  nominalTypeHead,\n  receiverMethodCallSignature,\n  referenceTargetType,\n}\nimport checker.members_capabilities {\n  bindTypeVariable,\n  builtinNamespaceMemberType,\n  typeArgument,\n}\nimport checker.call_facts {\n  builtinCallTypeParameters,\n  boundBuiltinForCallee,\n  canonicalBoundaryTarget,\n  builtinFunction,\n  builtinNamespaceObject,\n  recordInferredExpression,\n  userProtocolObject,\n}\nimport checker.expression_core {\n  contextualMemberObjectType,\n  inferIdentifierExpression,\n  inferOptionalMemberAccess,\n  inferPlainMemberAccess,\n  optionalReceiver,\n}\n\nexport function nominalConstructorCallResult(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n) -> Option<TypeValue> {\n  if callee.kind == \"expression/identifier\" {\n    match referenceTargetType(state, moduleIndex, callee) {\n      case Some(found) => if found.kind == \"newtype\" {\n        return Some(found)\n      }\n      case None => ()\n    }\n  }\n  if callee.kind == \"expression/member\" {\n    let object = match child(callee, \"object\") {\n      case Some(found) => found\n      case None => return None\n    }\n    let field = match child(callee, \"field\") {\n      case Some(found) => text(source, found)\n      case None => return None\n    }\n    if !nominalTypeHead(state, moduleIndex, object) { return None }\n    let enumType = match referenceTargetType(\n      state,\n      moduleIndex,\n      object,\n    ) {\n      case Some(found) => found\n      case None => return None\n    }\n    match enumDefinitionForType(state, moduleIndex, enumType) {\n      case Some(definition) => for variant in definition.variants {\n        if variant.name == field && variant.payloads.length > 0 {\n          return Some(enumType)\n        }\n      }\n      case None => ()\n    }\n  }\n  None\n}\n\nexport function declaredCallSignature(\n  definition: FunctionDefinition,\n) -> CallSignature {\n  CallSignature {\n    parameterNames: definition.parameterNames,\n    parameterDefaults: definition.parameterDefaults,\n    parameterCount: definition.parameterTypes.length,\n    variadic: definition.variadic.length > 0,\n    positionalOnlyIdentity: \"\",\n  }\n}\n\nfunction staticBuiltinCallSignature(namespace: string, name: string) -> Option<CallSignature> {\n  if builtinNamespaceFamily(namespace) != \"protocol\" { return staticBuiltinDataCallSignature(namespace, name) }\n  match builtinProtocolDefinition(namespace) {\n    case Some(definition) => match protocolMethodDefinition(definition, name) {\n      case Some(method) => {\n        let signature = requiredCallSignature(method.parameterNames, false)\n        Some(CallSignature { ...signature, positionalOnlyIdentity: \"{namespace}.{name}\" })\n      }\n      case None => None\n    }\n    case None => None\n  }\n}\n\nexport function userProtocolCallTarget(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n) -> Option<UserProtocolCallTarget> {\n  if callee.kind != \"expression/member\" {\n    return None\n  }\n  let object = match child(callee, \"object\") {\n    case Some(found) => found\n    case None => return None\n  }\n  let field = match child(callee, \"field\") {\n    case Some(found) => text(source, found)\n    case None => return None\n  }\n  let definition = match userProtocolObject(state, moduleIndex, source, object) {\n    case Some(found) => Some(found)\n    case None => if builtinNamespaceObject(service, state, moduleIndex, source, object) {\n      builtinProtocolDefinition(text(source, object))\n    } else {\n      None\n    }\n  }\n  match definition {\n    case Some(definition) => match protocolMethodDefinition(definition, field) {\n      case Some(method) => Some(UserProtocolCallTarget {\n        protocolName: definition.name,\n        method: method,\n      })\n      case None => None\n    }\n    case None => None\n  }\n}\n\nexport function userProtocolCallSignature(\n  target: UserProtocolCallTarget,\n) -> CallSignature {\n  positionalOnlyCallSignature(\n    \"{target.protocolName}.{target.method.name}\",\n    target.method.parameterNames,\n  )\n}\n\nexport function builtinMemberCallSignature(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  call: SyntaxNode,\n  callee: SyntaxNode,\n) -> Option<CallSignature> {\n  if callee.kind != \"expression/member\" &&\n    callee.kind != \"expression/optional-access\" {\n    return None\n  }\n  let object = match child(callee, \"object\") {\n    case Some(found) => found\n    case None => return None\n  }\n  let field = match child(callee, \"field\") {\n    case Some(found) => found\n    case None => return None\n  }\n  match userProtocolObject(state, moduleIndex, source, object) {\n    case Some(_) => return None\n    case None => ()\n  }\n  if builtinNamespaceObject(service, state, moduleIndex, source, object) {\n    return staticBuiltinCallSignature(\n      text(source, object),\n      text(source, field),\n    )\n  }\n  let objectType = serviceInferExpression(service, state, moduleIndex, source, object)\n  let receiverType = if callee.kind == \"expression/optional-access\" {\n    match optionalReceiver(contextualMemberObjectType(\n      state,\n      call,\n      objectType,\n    )) {\n      case Some(receiver) => receiver.innerType\n      case None => emptyType(\"unknown\")\n    }\n  } else {\n    objectType\n  }\n  match receiverMethodCallSignature(\n    state,\n    moduleIndex,\n    receiverType,\n    text(source, field),\n  ) {\n    case Some(signature) => Some(signature)\n    case None => builtinReceiverCallSignature(receiverType, text(source, field), state.languageMode)\n  }\n}\n\nfunction callParameterIndex(\n  signature: CallSignature,\n  name: string,\n) -> int {\n  let mut index = 0\n  while index < signature.parameterCount {\n    match signature.parameterNames.get(index) {\n      case Some(parameterName) => if parameterName == name {\n        return index\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  -1\n}\n\nfunction reportNamedCallArity(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  signature: CallSignature,\n  filled: Array<bool>,\n  leadingSlot: int,\n  supplied: int,\n  overflow: int,\n) -> () {\n  let mut required = 0\n  let mut missing = false\n  let mut index = 0\n  while index < signature.parameterCount {\n    let defaulted = match signature.parameterDefaults.get(index) {\n      case Some(value) => value\n      case None => false\n    }\n    let present = match filled.get(index) {\n      case Some(value) => value\n      case None => false\n    }\n    if !defaulted {\n      required += 1\n      if !present {\n        missing = true\n      }\n    }\n    index += 1\n  }\n  if overflow > 0 || missing {\n    if signature.positionalOnlyIdentity != \"\" {\n      let noun = if required == 1 { \"argument\" } else { \"arguments\" }\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"`{signature.positionalOnlyIdentity}` takes {required} {noun}, found {supplied}\",\n        \"\",\n        node,\n      )\n    } else if leadingSlot == -2 {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"the pipeline inserts the piped value, but this function takes no parameters\",\n        \"\",\n        node,\n      )\n    } else {\n      let optional = signature.variadic || signature.parameterCount > required\n      let suffix = if optional { \"+\" } else { \"\" }\n      let noun = if required == 1 { \"argument\" } else { \"arguments\" }\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"this call needs {required}{suffix} {noun}, found {supplied}\",\n        \"\",\n        node,\n      )\n    }\n  }\n  ()\n}\n\nrecord NamedCallPlan {\n  slots: Array<int>,\n  filled: Array<bool>,\n  positional: int,\n  sawNamed: bool,\n  sawSpread: bool,\n  overflow: int,\n  leadingSlot: int,\n  invalid: bool,\n}\n\nfunction emptyNamedCallPlan(\n  signature: CallSignature,\n  hasLeading: bool,\n) -> NamedCallPlan {\n  let mut filled: Array<bool> = []\n  let mut index = 0\n  while index < signature.parameterCount {\n    filled.push(false)\n    index += 1\n  }\n  let mut positional = 0\n  let mut overflow = 0\n  let mut leadingSlot = -3\n  if hasLeading {\n    if signature.parameterCount > 0 {\n      filled[0] = true\n      positional = 1\n      leadingSlot = 0\n    } else if signature.variadic {\n      leadingSlot = -1\n    } else {\n      overflow = 1\n      leadingSlot = -2\n    }\n  }\n  NamedCallPlan {\n    slots: [],\n    filled: filled,\n    positional: positional,\n    sawNamed: false,\n    sawSpread: false,\n    overflow: overflow,\n    leadingSlot: leadingSlot,\n    invalid: overflow > 0,\n  }\n}\n\nfunction planNamedSignatureArgument(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  signature: CallSignature,\n  plan: NamedCallPlan,\n  argument: SyntaxNode,\n) -> NamedCallPlan {\n  let nameNode = match child(argument, \"name\") {\n    case Some(found) => found\n    case None => argument\n  }\n  let parameterIndex = callParameterIndex(signature, text(source, nameNode))\n  let available = parameterIndex >= 0 && match plan.filled.get(parameterIndex) {\n    case Some(value) => !value\n    case None => false\n  }\n  let mut slots = plan.slots\n  if available {\n    let mut filled = plan.filled\n    filled[parameterIndex] = true\n    slots.push(parameterIndex)\n  } else {\n    let message = if parameterIndex == 0 && plan.leadingSlot == 0 {\n      \"`{text(source, nameNode)}` is already supplied by the pipeline (§11)\"\n    } else {\n      \"no parameter named `{text(source, nameNode)}`\"\n    }\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      message,\n      \"\",\n      nameNode,\n    )\n    slots.push(-2)\n    return NamedCallPlan {\n      ...plan,\n      sawNamed: true,\n      invalid: true,\n    }\n  }\n  NamedCallPlan { ...plan, sawNamed: true }\n}\n\nfunction hasUnsatisfiedFixedParameter(\n  signature: CallSignature,\n  plan: NamedCallPlan,\n) -> bool {\n  let mut index = plan.positional\n  while index < signature.parameterCount {\n    let filled = match plan.filled.get(index) {\n      case Some(value) => value\n      case None => false\n    }\n    let defaulted = match signature.parameterDefaults.get(index) {\n      case Some(value) => value\n      case None => false\n    }\n    if !filled && !defaulted {\n      return true\n    }\n    index += 1\n  }\n  false\n}\n\nfunction planSpreadSignatureArgument(\n  state: CheckerState,\n  moduleIndex: int,\n  signature: CallSignature,\n  plan: NamedCallPlan,\n  argument: SyntaxNode,\n) -> NamedCallPlan {\n  let mut slots = plan.slots\n  let mut invalid = plan.invalid\n  if plan.sawNamed {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      \"named arguments must follow spread arguments\",\n      \"\",\n      argument,\n    )\n    invalid = true\n  }\n  if !plan.sawSpread && hasUnsatisfiedFixedParameter(signature, plan) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      \"a spread argument cannot skip an unsatisfied fixed parameter\",\n      \"\",\n      argument,\n    )\n    invalid = true\n  }\n  slots.push(-1)\n  NamedCallPlan {\n    ...plan,\n    sawSpread: true,\n    invalid: invalid,\n  }\n}\n\nfunction stageEarlierCallArgumentForSlot(\n  slots: Array<int>,\n  target: int,\n) -> Array<int> {\n  let mut staged = slots\n  let mut index = 0\n  while index < staged.length {\n    match staged.get(index) {\n      case Some(slot) => if slot == target {\n        staged[index] = -2\n        return staged\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  staged\n}\n\nfunction planPositionalSignatureArgument(\n  state: CheckerState,\n  moduleIndex: int,\n  signature: CallSignature,\n  plan: NamedCallPlan,\n  argument: SyntaxNode,\n) -> NamedCallPlan {\n  let mut invalid = plan.invalid\n  if plan.sawNamed {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      \"positional arguments may not follow named arguments\",\n      \"\",\n      argument,\n    )\n    invalid = true\n  }\n  if plan.sawSpread {\n    let mut slots = plan.slots\n    slots.push(-1)\n    return NamedCallPlan {\n      ...plan,\n      slots: slots,\n      invalid: invalid,\n    }\n  }\n  let mut positional = plan.positional\n  if !plan.sawNamed {\n    while positional < signature.parameterCount {\n      let alreadyFilled = match plan.filled.get(positional) {\n        case Some(value) => value\n        case None => false\n      }\n      if !alreadyFilled { break }\n      positional += 1\n    }\n  }\n  let mut slots = plan.slots\n  if positional < signature.parameterCount {\n    if plan.sawNamed {\n      slots = stageEarlierCallArgumentForSlot(slots, positional)\n    }\n    let mut filled = plan.filled\n    filled[positional] = true\n    slots.push(positional)\n    positional += 1\n    NamedCallPlan {\n      ...plan,\n      positional: positional,\n      invalid: invalid,\n    }\n  } else if signature.variadic {\n    slots.push(-1)\n    NamedCallPlan {\n      ...plan,\n      positional: positional,\n      invalid: invalid,\n    }\n  } else {\n    slots.push(-2)\n    NamedCallPlan {\n      ...plan,\n      positional: positional,\n      overflow: plan.overflow + 1,\n      invalid: true,\n    }\n  }\n}\n\nfunction namedCallPlanMissingRequired(\n  signature: CallSignature,\n  plan: NamedCallPlan,\n) -> bool {\n  let mut index = 0\n  while index < signature.parameterCount {\n    let defaulted = match signature.parameterDefaults.get(index) {\n      case Some(value) => value\n      case None => false\n    }\n    let present = match plan.filled.get(index) {\n      case Some(value) => value\n      case None => false\n    }\n    if !defaulted && !present {\n      return true\n    }\n    index += 1\n  }\n  false\n}\n\nfunction planSignatureArgument(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  signature: CallSignature,\n  plan: NamedCallPlan,\n  argument: SyntaxNode,\n) -> NamedCallPlan {\n  match argument.kind {\n    case \"call-argument/named\" => planNamedSignatureArgument(\n      state,\n      moduleIndex,\n      source,\n      signature,\n      plan,\n      argument,\n    )\n    case \"call-argument/spread\" => planSpreadSignatureArgument(\n      state,\n      moduleIndex,\n      signature,\n      plan,\n      argument,\n    )\n    case _ => planPositionalSignatureArgument(\n      state,\n      moduleIndex,\n      signature,\n      plan,\n      argument,\n    )\n  }\n}\n\nfunction callHasSpreadArgument(node: SyntaxNode) -> bool {\n  for argument in children(node, \"arguments\") {\n    if argument.kind == \"call-argument/spread\" {\n      return true\n    }\n  }\n  false\n}\n\nexport function unknownCallArgumentPlan(node: SyntaxNode) -> CallArgumentPlan {\n  let mut slots: Array<int> = []\n  for _ in children(node, \"arguments\") {\n    slots.push(-2)\n  }\n  CallArgumentPlan {\n    slots: slots,\n    leadingSlot: -3,\n    resultUnknown: true,\n  }\n}\n\nexport function planSignatureArguments(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  diagnosticNode: SyntaxNode,\n  signature: CallSignature,\n  hasLeading: bool,\n  deferArity: bool,\n) -> CallArgumentPlan {\n  if signature.positionalOnlyIdentity != \"\" {\n    let mut invalid = false\n    for argument in children(node, \"arguments\") {\n      if argument.kind == \"call-argument/named\" ||\n        argument.kind == \"call-argument/spread\" {\n        invalid = true\n      }\n    }\n    if invalid {\n      if !deferArity { addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"a protocol call `{signature.positionalOnlyIdentity}(…)` takes positional arguments only\",\n        \"\",\n        diagnosticNode,\n      ) }\n      return unknownCallArgumentPlan(node)\n    }\n  }\n  if !signature.variadic && callHasSpreadArgument(node) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      \"spread arguments require a variadic parameter\",\n      \"\",\n      diagnosticNode,\n    )\n    return unknownCallArgumentPlan(node)\n  }\n  let mut plan = emptyNamedCallPlan(signature, hasLeading)\n  for argument in children(node, \"arguments\") {\n    plan = planSignatureArgument(\n      state,\n      moduleIndex,\n      source,\n      signature,\n      plan,\n      argument,\n    )\n  }\n  if !deferArity {\n    reportNamedCallArity(\n      state,\n      moduleIndex,\n      diagnosticNode,\n      signature,\n      plan.filled,\n      plan.leadingSlot,\n      children(node, \"arguments\").length + if hasLeading { 1 } else { 0 },\n      plan.overflow,\n    )\n  }\n  let missingRequired = namedCallPlanMissingRequired(signature, plan)\n  CallArgumentPlan {\n    slots: plan.slots,\n    leadingSlot: plan.leadingSlot,\n    resultUnknown: if deferArity {\n      false\n    } else {\n      plan.invalid || missingRequired\n    },\n  }\n}\n\nrecord TypedCallPlan {\n  slots: Array<int>,\n  nextFixed: int,\n  supplied: int,\n  overflow: bool,\n  leadingSlot: int,\n  sawNamed: bool,\n  sawSpread: bool,\n  invalid: bool,\n  staged: bool,\n}\n\nfunction emptyTypedCallPlan(\n  calleeType: TypeValue,\n  hasLeading: bool,\n) -> TypedCallPlan {\n  if !hasLeading {\n    return TypedCallPlan {\n      slots: [],\n      nextFixed: 0,\n      supplied: 0,\n      overflow: false,\n      leadingSlot: -3,\n      sawNamed: false,\n      sawSpread: false,\n      invalid: false,\n      staged: false,\n    }\n  }\n  if calleeType.parameters.length > 0 {\n    return TypedCallPlan {\n      slots: [],\n      nextFixed: 1,\n      supplied: 1,\n      overflow: false,\n      leadingSlot: 0,\n      sawNamed: false,\n      sawSpread: false,\n      invalid: false,\n      staged: false,\n    }\n  }\n  if calleeType.variadic.length > 0 {\n    return TypedCallPlan {\n      slots: [],\n      nextFixed: 0,\n      supplied: 1,\n      overflow: false,\n      leadingSlot: -1,\n      sawNamed: false,\n      sawSpread: false,\n      invalid: false,\n      staged: false,\n    }\n  }\n  TypedCallPlan {\n    slots: [],\n    nextFixed: 0,\n    supplied: 1,\n    overflow: true,\n    leadingSlot: -2,\n    sawNamed: false,\n    sawSpread: false,\n    invalid: true,\n    staged: false,\n  }\n}\n\nfunction planTypedCallArgument(\n  state: CheckerState,\n  moduleIndex: int,\n  calleeType: TypeValue,\n  plan: TypedCallPlan,\n  argument: SyntaxNode,\n) -> TypedCallPlan {\n  let mut slots = plan.slots\n  if argument.kind == \"call-argument/named\" {\n    slots.push(-2)\n    return TypedCallPlan {\n      ...plan,\n      slots: slots,\n      sawNamed: true,\n      staged: true,\n    }\n  }\n  if argument.kind == \"call-argument/spread\" {\n    let mut invalid = plan.invalid\n    if plan.sawNamed {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"named arguments must follow spread arguments\",\n        \"\",\n        argument,\n      )\n      invalid = true\n    }\n    if !plan.sawSpread && plan.nextFixed < calleeType.parameters.length {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"a spread argument cannot skip an unsatisfied fixed parameter\",\n        \"\",\n        argument,\n      )\n      invalid = true\n    }\n    slots.push(-1)\n    return TypedCallPlan {\n      ...plan,\n      slots: slots,\n      sawSpread: true,\n      invalid: invalid,\n    }\n  }\n  let mut invalid = plan.invalid\n  if plan.sawNamed {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      \"positional arguments may not follow named arguments\",\n      \"\",\n      argument,\n    )\n    invalid = true\n  }\n  if plan.sawSpread {\n    slots.push(-1)\n    return TypedCallPlan {\n      ...plan,\n      slots: slots,\n      supplied: plan.supplied + 1,\n      invalid: invalid,\n    }\n  }\n  if plan.nextFixed < calleeType.parameters.length {\n    slots.push(plan.nextFixed)\n    return TypedCallPlan {\n      ...plan,\n      nextFixed: plan.nextFixed + 1,\n      supplied: plan.supplied + 1,\n      invalid: invalid,\n    }\n  }\n  if calleeType.variadic.length > 0 {\n    slots.push(-1)\n    return TypedCallPlan {\n      ...plan,\n      slots: slots,\n      supplied: plan.supplied + 1,\n      invalid: invalid,\n    }\n  }\n  slots.push(-2)\n  TypedCallPlan {\n    ...plan,\n    nextFixed: plan.nextFixed + 1,\n    supplied: plan.supplied + 1,\n    overflow: true,\n    invalid: true,\n  }\n}\n\nfunction reportTypedCallArity(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  calleeType: TypeValue,\n  required: int,\n  plan: TypedCallPlan,\n) -> () {\n  if calleeType.kind == \"function\" &&\n    (plan.supplied < required || plan.overflow) {\n    if plan.leadingSlot == -2 {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"the pipeline inserts the piped value, but this function takes no parameters\",\n        \"\",\n        node,\n      )\n    } else {\n      let noun = if required == 1 { \"argument\" } else { \"arguments\" }\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"this call needs {required} {noun}, found {plan.supplied}\",\n        \"\",\n        node,\n      )\n    }\n  }\n}\n\nexport function planTypedCallArguments(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  diagnosticNode: SyntaxNode,\n  calleeType: TypeValue,\n  hasLeading: bool,\n) -> CallArgumentPlan {\n  if calleeType.kind == \"function\" &&\n    calleeType.variadic.length == 0 &&\n    callHasSpreadArgument(node) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      \"spread arguments require a variadic parameter\",\n      \"\",\n      diagnosticNode,\n    )\n    return unknownCallArgumentPlan(node)\n  }\n  let mut plan = emptyTypedCallPlan(calleeType, hasLeading)\n  for argument in children(node, \"arguments\") {\n    plan = planTypedCallArgument(\n      state,\n      moduleIndex,\n      calleeType,\n      plan,\n      argument,\n    )\n  }\n  if plan.staged {\n    return unknownCallArgumentPlan(node)\n  }\n  reportTypedCallArity(\n    state,\n    moduleIndex,\n    diagnosticNode,\n    calleeType,\n    calleeType.parameters.length,\n    plan,\n  )\n  CallArgumentPlan {\n    slots: plan.slots,\n    leadingSlot: plan.leadingSlot,\n    resultUnknown: plan.invalid || plan.supplied < calleeType.parameters.length,\n  }\n}\n\nexport function callSlotExpectedType(\n  calleeType: TypeValue,\n  slot: int,\n  spread: bool,\n) -> Option<TypeValue> {\n  if slot >= 0 {\n    return calleeType.parameters.get(slot)\n  }\n  if slot == -1 {\n    return match calleeType.variadic.get(0) {\n      case Some(found) => if spread {\n        Some(constructor(\"Array\", [found]))\n      } else {\n        Some(found)\n      }\n      case None => None\n    }\n  }\n  None\n}\n\nexport function callArgumentExpectedType(\n  calleeType: TypeValue,\n  argument: SyntaxNode,\n  slot: int,\n) -> Option<TypeValue> {\n  callSlotExpectedType(\n    calleeType,\n    slot,\n    argument.kind == \"call-argument/spread\",\n  )\n}\n\nexport record InferredCallCallee {\n  declaredType: TypeValue,\n  receiverType: TypeValue,\n  optionalContainer: string,\n  builtinSignature: Option<CallSignature>,\n}\n\n// A builtin namespace has no receiver value, so its static member carries its\n// parameter names and defaults here, as a canonical boundary target does.\nfunction staticNamespaceCallSignature(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n  memberType: TypeValue,\n) -> Option<CallSignature> {\n  if memberType.kind != \"function\" {\n    return None\n  }\n  let object = match child(callee, \"object\") {\n    case Some(found) => found\n    case None => return None\n  }\n  let field = match child(callee, \"field\") {\n    case Some(found) => found\n    case None => return None\n  }\n  if !builtinNamespaceObject(service, state, moduleIndex, source, object) {\n    return None\n  }\n  staticBuiltinCallSignature(text(source, object), text(source, field))\n}\n\nexport function inferCallCallee(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  callee: SyntaxNode,\n) -> InferredCallCallee {\n  match boundBuiltinForCallee(state, moduleIndex, callee) {\n    case Some(bound) => return InferredCallCallee { declaredType: bound.typeValue, receiverType: bound.receiverType, optionalContainer: \"\", builtinSignature: bound.signature }\n    case None => ()\n  }\n  let boundary = canonicalBoundaryTarget(state, moduleIndex, source, callee)\n  if boundary.length == 2 {\n    if boundary[0] == \"\" {\n      match builtinFunction(boundary[1], \"topaz-5.20\") {\n        case Some(found) => return InferredCallCallee { declaredType: found.typeValue, receiverType: emptyType(\"unknown\"), optionalContainer: \"\", builtinSignature: Some(found.callSignature) }\n        case None => ()\n      }\n    } else {\n      match builtinNamespaceMemberType(boundary[0], boundary[1], \"topaz-5.20\") {\n        case Some(found) => return InferredCallCallee { declaredType: found, receiverType: emptyType(\"unknown\"), optionalContainer: \"\", builtinSignature: staticBuiltinCallSignature(boundary[0], boundary[1]) }\n        case None => ()\n      }\n    }\n  }\n  if callee.kind == \"expression/identifier\" &&\n    match referenceTargetType(state, moduleIndex, callee) {\n      case Some(_) => false\n      case None => true\n    } {\n    match builtinFunction(text(source, callee), state.languageMode) {\n      case Some(found) => {\n        recordInferredExpression(\n          state,\n          moduleIndex,\n          source,\n          callee,\n          found.typeValue,\n        )\n        return InferredCallCallee {\n          declaredType: found.typeValue,\n          receiverType: emptyType(\"unknown\"),\n          optionalContainer: \"\",\n          builtinSignature: Some(found.callSignature),\n        }\n      }\n      case None => ()\n    }\n  }\n  if callee.kind == \"expression/optional-access\" {\n    let optional = inferOptionalMemberAccess(\n      service,\n      state,\n      moduleIndex,\n      source,\n      callee,\n      node,\n    )\n    recordInferredExpression(\n      state,\n      moduleIndex,\n      source,\n      callee,\n      optional.wrappedType,\n    )\n    return InferredCallCallee {\n      declaredType: optional.rawType,\n      receiverType: optional.receiverType,\n      optionalContainer: optional.container,\n      builtinSignature: None,\n    }\n  }\n  if callee.kind == \"expression/member\" {\n    let member = inferPlainMemberAccess(\n      service,\n      state,\n      moduleIndex,\n      source,\n      callee,\n      node,\n      true,\n    )\n    recordInferredExpression(\n      state,\n      moduleIndex,\n      source,\n      callee,\n      member.memberType,\n    )\n    return InferredCallCallee {\n      declaredType: member.memberType,\n      receiverType: member.receiverType,\n      optionalContainer: \"\",\n      builtinSignature: staticNamespaceCallSignature(\n        service,\n        state,\n        moduleIndex,\n        source,\n        callee,\n        member.memberType,\n      ),\n    }\n  }\n  let calleeType = if callee.kind == \"expression/identifier\" {\n    let inferred = inferIdentifierExpression(\n      state,\n      moduleIndex,\n      source,\n      callee,\n      true,\n    )\n    recordInferredExpression(state, moduleIndex, source, callee, inferred)\n    inferred\n  } else {\n    serviceInferExpression(service, state, moduleIndex, source, callee)\n  }\n  InferredCallCallee {\n    declaredType: calleeType,\n    receiverType: emptyType(\"unknown\"),\n    optionalContainer: \"\",\n    builtinSignature: None,\n  }\n}\n\nexport function explicitCallBindings(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  diagnosticNode: SyntaxNode,\n  callee: SyntaxNode,\n  referencedDefinition: Option<FunctionDefinition>,\n  allowTypeArguments: bool,\n  receiverType: TypeValue,\n  parameters: Array<TypeValue>,\n) -> Array<TypeBinding> {\n  let mut bindings: Array<TypeBinding> = []\n  let mut parameterNames: Array<string> = []\n  if allowTypeArguments {\n    for parameter in parameters { parameterNames.push(parameter.name) }\n  }\n  let expectedCount = parameterNames.length\n  let suppliedCount = children(node, \"typeArguments\").length\n  if suppliedCount > 0 && expectedCount == 0 {\n    let argumentSuffix = if suppliedCount == 1 { \"\" } else { \"s\" }\n    let suppliedVerb = if suppliedCount == 1 { \"was\" } else { \"were\" }\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5512\",\n      \"this call is not generic, but {suppliedCount} type argument{argumentSuffix} {suppliedVerb} supplied\",\n      \"\",\n      diagnosticNode,\n    )\n  } else if suppliedCount > 0 && suppliedCount != expectedCount {\n    let expectedSuffix = if expectedCount == 1 { \"\" } else { \"s\" }\n    let suppliedVerb = if suppliedCount == 1 { \"was\" } else { \"were\" }\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5510\",\n      \"this call expects {expectedCount} type argument{expectedSuffix}, but {suppliedCount} {suppliedVerb} supplied\",\n      \"\",\n      diagnosticNode,\n    )\n  }\n  if suppliedCount > 0 && suppliedCount == expectedCount {\n    let mut index = 0\n    for typeArgument in children(node, \"typeArguments\") {\n      match parameterNames.get(index) {\n        case Some(parameterName) => {\n          let value = formType(service, state, moduleIndex, source, typeArgument, [], \"call\")\n          addNode(state, moduleIndex, \"type\", typeArgument, value)\n          match parameters.get(index) {\n            case Some(parameter) => bindTypeVariable(bindings, parameter, value, false)\n            case None => ()\n          }\n        }\n        case None => ()\n      }\n      index += 1\n    }\n  }\n  bindings\n}\n\nexport function callTypeParameters(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n  receiverType: TypeValue,\n  definition: Option<FunctionDefinition>,\n  protocol: Option<UserProtocolCallTarget>,\n  declaredType: TypeValue,\n) -> Array<TypeValue> {\n  let mut parameters: Array<TypeValue> = []\n  match definition {\n    case Some(found) => {\n      let mut index = 0\n      for name in found.typeParameters {\n        match found.typeParameterOrigins.get(index) {\n          case Some(origin) => parameters.push(rigid(name, origin))\n          case None => ()\n        }\n        index += 1\n      }\n      return parameters\n    }\n    case None => ()\n  }\n  match protocol {\n    case Some(target) => {\n      match target.method.typeValue.parameters.get(0) {\n        case Some(parameter) => parameters.push(parameter)\n        case None => ()\n      }\n      return parameters\n    }\n    case None => ()\n  }\n  let atoms = flattenType(declaredType)\n  for name in builtinCallTypeParameters(service, state, moduleIndex, source, callee, receiverType) {\n    for atom in atoms {\n      if atom.kind == \"rigid\" && atom.name == name && atom.origin.startsWith(\"builtin::\") {\n        parameters.push(rigid(name, atom.origin))\n        break\n      }\n    }\n    ()\n  }\n  parameters\n}\n",
      "sourceSha256": "182c9ffaebd1d63208a3a82e8d1d208029076991f64546f203b141286548af9a"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/diagnostics_derives.tpz",
      "language": "topaz",
      "bytes": 10200,
      "sha256": "17945ea7bf5de9f1f8544ddcce963d16e98f5ddc181ea600168d97009c83ad8e",
      "content": "// Diagnostic helpers and validation of declared derive capabilities.\n// The leaf appends stable checker diagnostics to shared state but does not drive\n// type formation or expression inference.\n\nimport types { SyntaxNode }\nimport checker_types { TypeValue }\nimport checker.model {\n  CheckerState,\n  EnumDefinition,\n  RecordDefinition,\n  constructor,\n  literal,\n  nominal,\n  primitive,\n}\nimport checker.type_algebra { widen }\nimport checker.syntax_index {\n  addDiagnostic,\n  child,\n  children,\n  containsString,\n  enumDefinitionIndex,\n  recordDefinitionIndex,\n  text,\n  typeParameterNames,\n  unwrapExport,\n}\nimport checker.nominals { substitute }\nimport checker.protocols_methods {\n  appendConformance,\n  enumDefinitionForType,\n  newtypeDefinitionForType,\n  protocolConformanceIndex,\n  recordDefinitionForType,\n}\nimport checker.members_capabilities {\n  capabilityPath,\n  jsonCapability,\n  nominalCapabilityKey,\n}\n\nfunction deriveTypeCapability(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  protocol: string,\n  seen: Array<string>,\n) -> bool {\n  let widened = widen(value)\n  if widened.kind == \"nominal-record\" {\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return protocol != \"JSON\"\n    }\n    return match recordDefinitionForType(state, moduleIndex, widened) {\n      case Some(definition) => {\n        if definition.typeParameters.length != widened.arguments.length {\n          return false\n        }\n        for field in definition.fields {\n          if !deriveTypeCapability(\n            state,\n            definition.moduleIndex,\n            substitute(\n              field.typeValue,\n              definition.typeParameters,\n              widened.arguments,\n            ),\n            protocol,\n            capabilityPath(seen, key),\n          ) {\n            return false\n          }\n        }\n        true\n      }\n      case None => false\n    }\n  }\n  if widened.kind == \"enum\" {\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return protocol != \"JSON\"\n    }\n    return match enumDefinitionForType(state, moduleIndex, widened) {\n      case Some(definition) => {\n        if definition.typeParameters.length != widened.arguments.length {\n          return false\n        }\n        for variant in definition.variants {\n          for payload in variant.payloads {\n            if !deriveTypeCapability(\n              state,\n              definition.moduleIndex,\n              substitute(\n                payload,\n                definition.typeParameters,\n                widened.arguments,\n              ),\n              protocol,\n              capabilityPath(seen, key),\n            ) {\n              return false\n            }\n          }\n        }\n        true\n      }\n      case None => false\n    }\n  }\n  if widened.kind == \"newtype\" {\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return protocol != \"JSON\"\n    }\n    return match newtypeDefinitionForType(state, moduleIndex, widened) {\n      case Some(definition) => if definition.typeParameters.length !=\n        widened.arguments.length {\n        false\n      } else {\n        deriveTypeCapability(\n          state,\n          definition.moduleIndex,\n          substitute(\n            definition.base,\n            definition.typeParameters,\n            widened.arguments,\n          ),\n          protocol,\n          capabilityPath(seen, key),\n        )\n      }\n      case None => false\n    }\n  }\n  if widened.kind == \"primitive\" {\n    if protocol == \"Eq\" {\n      return true\n    }\n    if protocol == \"Order\" {\n      return widened.name == \"int\" || widened.name == \"string\"\n    }\n    return widened.name == \"int\" || widened.name == \"string\" ||\n      widened.name == \"bool\" || widened.name == \"unit\"\n  }\n  if widened.kind == \"literal\" {\n    if protocol == \"Eq\" {\n      return true\n    }\n    if protocol == \"Order\" {\n      return widened.name == \"int\" || widened.name == \"string\"\n    }\n    return widened.name != \"float\"\n  }\n  if widened.kind == \"union\" {\n    if protocol != \"Eq\" {\n      return false\n    }\n    for member in widened.members {\n      if !deriveTypeCapability(state, moduleIndex, member, protocol, seen) {\n        return false\n      }\n    }\n    return true\n  }\n  if widened.kind == \"record\" {\n    if protocol == \"Order\" {\n      return false\n    }\n    for field in widened.fields {\n      if !deriveTypeCapability(state, moduleIndex, field, protocol, seen) {\n        return false\n      }\n    }\n    return true\n  }\n  if widened.kind == \"constructor\" {\n    if protocol == \"Order\" {\n      return false\n    }\n    if protocol == \"Eq\" {\n      if widened.name == \"Map\" || widened.name == \"Set\" {\n        return false\n      }\n      for argument in widened.arguments {\n        if !deriveTypeCapability(state, moduleIndex, argument, protocol, seen) {\n          return false\n        }\n      }\n      return true\n    }\n    return jsonCapability(state, moduleIndex, widened, seen, false) == \"accept\" &&\n      jsonCapability(state, moduleIndex, widened, seen, true) == \"accept\"\n  }\n  if widened.kind == \"bytes\" || widened.kind == \"path\" ||\n    widened.kind == \"url\" || widened.kind == \"date\" ||\n    widened.kind == \"big-int\" || widened.kind == \"decimal\" {\n    return protocol == \"Eq\" || protocol == \"Order\"\n  }\n  if widened.kind == \"match\" || widened.kind == \"rounding-mode\" {\n    return protocol == \"Eq\"\n  }\n  widened.kind == \"json-value\" && protocol == \"JSON\"\n}\n\nfunction firstRecordDeriveFailure(\n  state: CheckerState,\n  definition: RecordDefinition,\n  protocol: string,\n) -> string {\n  for field in definition.fields {\n    if !deriveTypeCapability(\n      state,\n      definition.moduleIndex,\n      field.typeValue,\n      protocol,\n      [],\n    ) {\n      return \"field `{field.name}`\"\n    }\n  }\n  \"\"\n}\n\nfunction firstEnumDeriveFailure(\n  state: CheckerState,\n  definition: EnumDefinition,\n  protocol: string,\n) -> string {\n  for variant in definition.variants {\n    let mut index = 0\n    for payload in variant.payloads {\n      if !deriveTypeCapability(\n        state,\n        definition.moduleIndex,\n        payload,\n        protocol,\n        [],\n      ) {\n        return \"variant `{variant.name}` payload #{index}\"\n      }\n      index += 1\n    }\n  }\n  \"\"\n}\n\nfunction recordDerivedConformance(\n  state: CheckerState,\n  moduleIndex: int,\n  typeName: string,\n  protocol: string,\n  node: SyntaxNode,\n) -> () {\n  let existingIndex = protocolConformanceIndex(\n    state,\n    moduleIndex,\n    typeName,\n    protocol,\n  )\n  if existingIndex >= 0 {\n    let how = match state.conformances.get(existingIndex) {\n      case Some(existing) => if existing.derived {\n        \"is derived more than once\"\n      } else {\n        \"is already implemented manually\"\n      }\n      case None => \"is derived more than once\"\n    }\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5521\",\n      \"`{typeName}` conformance to `{protocol}` {how}; a conformance must be unique\",\n      \"\",\n      node,\n    )\n  } else {\n    appendConformance(state, moduleIndex, typeName, protocol, true)\n  }\n  ()\n}\n\nexport function checkDerives(state: CheckerState) -> () {\n  for module in state.modules {\n    for statement in module.root.children {\n      let item = unwrapExport(statement)\n      if item.kind == \"statement/record\" || item.kind == \"statement/enum\" {\n        let name = match child(item, \"name\") {\n          case Some(found) => text(module.source, found)\n          case None => \"\"\n        }\n        let typeParameterCount = typeParameterNames(module.source, item).length\n        for derived in children(item, \"derives\") {\n          let protocol = text(module.source, derived)\n          if protocol != \"Eq\" && protocol != \"Order\" &&\n            protocol != \"Show\" && protocol != \"JSON\" {\n            addDiagnostic(\n              state,\n              module.moduleIndex,\n              \"TPZ5530\",\n              \"unknown protocol `{protocol}` in `derives` for `{name}`; derivable protocols are `Eq`, `Order`, `Show`, `JSON`\",\n              \"\",\n              derived,\n            )\n          } else if typeParameterCount > 0 {\n            addDiagnostic(\n              state,\n              module.moduleIndex,\n              \"TPZ5022\",\n              \"cannot derive `{protocol}` for generic nominal `{name}` yet; conditional generic conformance is not defined\",\n              \"\",\n              derived,\n            )\n          } else {\n            let failure = if protocol == \"Show\" {\n              \"\"\n            } else if item.kind == \"statement/record\" {\n              match state.records.get(recordDefinitionIndex(\n                state,\n                module.moduleIndex,\n                name,\n              )) {\n                case Some(definition) => firstRecordDeriveFailure(\n                  state,\n                  definition,\n                  protocol,\n                )\n                case None => \"nominal\"\n              }\n            } else {\n              match state.enums.get(enumDefinitionIndex(\n                state,\n                module.moduleIndex,\n                name,\n              )) {\n                case Some(definition) => firstEnumDeriveFailure(\n                  state,\n                  definition,\n                  protocol,\n                )\n                case None => \"nominal\"\n              }\n            }\n            if failure == \"\" {\n              recordDerivedConformance(\n                state,\n                module.moduleIndex,\n                name,\n                protocol,\n                derived,\n              )\n            } else {\n              addDiagnostic(\n                state,\n                module.moduleIndex,\n                \"TPZ5530\",\n                if protocol == \"Eq\" {\n                  \"cannot derive `Eq` for `{name}`: {failure} has a non-comparable type\"\n                } else if protocol == \"Order\" {\n                  \"cannot derive `Order` for `{name}`: {failure} is not totally orderable\"\n                } else {\n                  \"cannot derive `JSON` for `{name}`: {failure} cannot round-trip through JSON\"\n                },\n                \"\",\n                derived,\n              )\n            }\n          }\n        }\n      }\n    }\n  }\n  ()\n}\n",
      "sourceSha256": "17945ea7bf5de9f1f8544ddcce963d16e98f5ddc181ea600168d97009c83ad8e"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/expression_control.tpz",
      "language": "topaz",
      "bytes": 49967,
      "sha256": "fd94da8bb1c7829abf6beab31b634b27300ca6dd53de97740ccaf13ec2d12f19",
      "content": "import literal { signedIntegerInput, decodeIntegerLiteral, decodeDecimalFloatLiteral, decodeDurationMilliseconds }\n// Inference for operators, branches, loops, matches, and concurrent forms.\n// Core literals and member access stay in expression_core; recursive descent is\n// routed through the service boundary owned by the checker facade.\n\nimport length { decodeLength, signedLengthInput }\nimport types { SyntaxNode }\nimport checker_types { TypeValue }\nimport checker.model {\n  CallPreparation,\n  CheckerService,\n  CheckerState,\n  advanceConstantRenderEpoch,\n  LeadingCallArgument,\n  LoopFrame,\n  constructor,\n  emptyType,\n  functionType,\n  literal,\n  nominal,\n  lengthType,\n  lengthUnit,\n  primitive,\n  serviceCheckBlock,\n  serviceCheckBlockExpected,\n  serviceCheckBlockExpectedResult,\n  structural,\n}\nimport checker.type_algebra {\n  assignable,\n  hasHole,\n  hasPartialHole,\n  joinedTypes,\n  solvePartialTypeAgainst,\n  stringJoin,\n  typeText,\n  unionType,\n  widen,\n  widenedUnion,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  addNode,\n  attribute,\n  child,\n  children,\n  text,\n}\nimport checker.members_capabilities {\n  comparableType,\n  gateCollectionKey,\n  memberType,\n  orderCapability,\n}\nimport checker.patterns {\n  coverageGap,\n  emptyPatternCoverage,\n  mergePatternCoverage,\n  patternBindingType,\n  patternBindingTypeAt,\n}\nimport checker.call_facts {\n  addPipeCall,\n  argumentValue,\n  checkExpressionExpected,\n  checkExpressionExpectedResult,\n  checkReturn,\n  containsPlaceholder,\n  currentExpectedExpression,\n  currentExpressionChecksResult,\n  currentFunctionReturn,\n  currentPipeValue,\n  inferExpressionWithExpected,\n  inferExpressionContext,\n  inferExpressionWithResultContext,\n  recordInferredExpression,\n  refineExpressionToExpected,\n  reportExpectedType,\n}\nimport checker.expression_core {\n  blockTerminates,\n  checkedIterableElement,\n  expressionTerminates,\n  hasBranchJoinContext,\n  hasLiteralJoinContext,\n  inferBranchExpression,\n  inferIdentifierExpression,\n  inferLambda,\n  inferMapLiteralExpression,\n  inferMemberAccessExpression,\n  missingReceiverMemberMessage,\n  inferRecordLiteralExpression,\n  inferRecordUpdateExpression,\n  inferSequenceLiteralExpression,\n  inferTextExpression,\n}\nimport checker.call_complete {\n  callArgumentInferenceContext,\n  completePreparedCall,\n  inferCall,\n  inferCallArguments,\n  inferContextualCallArgument,\n  leadingCallActuals,\n  prepareCall,\n}\n\nfunction inferIfExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let contextual = hasLiteralJoinContext(state, node)\n  let expected = currentExpectedExpression(state, node)\n  let checkResult = currentExpressionChecksResult(state, node)\n  match child(node, \"condition\") {\n    case Some(found) => {\n      let _ = checkExpressionExpected(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        primitive(\"bool\"),\n      )\n    }\n    case None => ()\n  }\n  let mut branches: Array<TypeValue> = []\n  match child(node, \"then\") {\n    case Some(found) => {\n      let terminating = blockTerminates(found)\n      let branch = if terminating {\n        serviceCheckBlock(\n          service,\n          state,\n          moduleIndex,\n          source,\n          found,\n        )\n      } else {\n        match expected {\n          // Partial expectations still constrain every concrete component.\n          case Some(expectedType) => {\n            serviceCheckBlockExpectedResult(\n              service,\n              state,\n              moduleIndex,\n              source,\n              found,\n              expectedType,\n              checkResult,\n            )\n          }\n          case None => inferBranchExpression(\n            service,\n            state,\n            moduleIndex,\n            source,\n            found,\n            contextual,\n          )\n        }\n      }\n      if !terminating {\n        branches.push(branch)\n      }\n    }\n    case None => ()\n  }\n  match child(node, \"else\") {\n    case Some(found) => {\n      let terminating = expressionTerminates(found)\n      let branch = if terminating {\n        inferExpression(service, state, moduleIndex, source, found)\n      } else {\n        match expected {\n          case Some(expectedType) => {\n            checkExpressionExpectedResult(\n              service,\n              state,\n              moduleIndex,\n              source,\n              found,\n              expectedType,\n              false,\n              checkResult,\n            )\n          }\n          case None => inferBranchExpression(\n            service,\n            state,\n            moduleIndex,\n            source,\n            found,\n            contextual,\n          )\n        }\n      }\n      if !terminating {\n        branches.push(branch)\n      }\n    }\n    case None => branches.push(primitive(\"unit\"))\n  }\n  let expectedContext = match expected {\n    case Some(found) => !hasHole(found)\n    case None => false\n  }\n  joinedTypes(state, branches, !(contextual || expectedContext))\n}\n\nfunction inferMatchExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let contextual = hasLiteralJoinContext(state, node)\n  let scrutinee = match child(node, \"scrutinee\") {\n    case Some(found) => inferExpression(service, state, moduleIndex, source, found)\n    case None => emptyType(\"unknown\")\n  }\n  let mut branches: Array<TypeValue> = []\n  let mut coverage = emptyPatternCoverage()\n  for foundCase in children(node, \"cases\") {\n    let mut caseCoverage = emptyPatternCoverage()\n    match child(foundCase, \"pattern\") {\n      case Some(pattern) => {\n        caseCoverage = patternBindingTypeAt(\n          service,\n          state,\n          moduleIndex,\n          source,\n          pattern,\n          scrutinee,\n          false,\n          true,\n        )\n      }\n      case None => ()\n    }\n    match child(foundCase, \"guard\") {\n      case Some(guard) => {\n        let _ = checkExpressionExpected(\n          service,\n          state,\n          moduleIndex,\n          source,\n          guard,\n          primitive(\"bool\"),\n        )\n      }\n      case None => {\n        coverage = mergePatternCoverage(coverage, caseCoverage)\n      }\n    }\n    match child(foundCase, \"body\") {\n      case Some(body) => if body.kind == \"match-case-return\" {\n        checkReturn(service, state, moduleIndex, source, body)\n      } else {\n        let terminating = expressionTerminates(body)\n        let branch = if terminating {\n          inferExpression(service, state, moduleIndex, source, body)\n        } else {\n          match currentExpectedExpression(state, node) {\n            case Some(expected) => checkExpressionExpectedResult(\n              service,\n              state,\n              moduleIndex,\n              source,\n              body,\n              expected,\n              false,\n              currentExpressionChecksResult(state, node),\n            )\n            case None => inferBranchExpression(\n              service,\n              state,\n              moduleIndex,\n              source,\n              body,\n              contextual,\n            )\n          }\n        }\n        if !terminating {\n          branches.push(branch)\n        }\n      }\n      case None => ()\n    }\n  }\n  let gap = coverageGap(state, moduleIndex, coverage, scrutinee)\n  if gap.decidable && gap.missing.length > 0 {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5021\",\n      \"non-exhaustive match: missing {stringJoin(gap.missing, \", \")}\",\n      \"\",\n      node,\n    )\n  }\n  let expectedContext = match currentExpectedExpression(state, node) {\n    case Some(expected) => !hasHole(expected)\n    case None => false\n  }\n  joinedTypes(state, branches, !(contextual || expectedContext))\n}\n\nfunction currentLoopFloor(state: CheckerState) -> int {\n  if state.loopFloors.length == 0 {\n    return 0\n  }\n  match state.loopFloors.get(state.loopFloors.length - 1) {\n    case Some(found) => found\n    case None => 0\n  }\n}\n\nfunction statementForExpression(\n  state: CheckerState,\n  node: SyntaxNode,\n) -> bool {\n  if state.statementExpressionContexts.length == 0 {\n    return false\n  }\n  match state.statementExpressionContexts.get(\n    state.statementExpressionContexts.length - 1,\n  ) {\n    case Some(lo) => lo == node.lo\n    case None => false\n  }\n}\n\nfunction resolveLoopTarget(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  keyword: string,\n) -> int {\n  let floor = currentLoopFloor(state)\n  match child(node, \"label\") {\n    case Some(label) => {\n      let name = text(source, label)\n      let mut index = state.loopFrames.length - 1\n      while index >= floor {\n        match state.loopFrames.get(index) {\n          case Some(frame) => if frame.label == name {\n            return index\n          }\n          case None => ()\n        }\n        index -= 1\n      }\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5720\",\n        \"no loop labeled `'{name}` in scope\",\n        \"\",\n        node,\n      )\n      -1\n    }\n    case None => if state.loopFrames.length <= floor {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"`{keyword}` outside a loop\",\n        \"\",\n        node,\n      )\n      -1\n    } else {\n      let index = state.loopFrames.length - 1\n      match state.loopFrames.get(index) {\n        case Some(frame) => if frame.bareTarget {\n          index\n        } else {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"bare `{keyword}` cannot target {frame.bareError}\",\n            \"\",\n            node,\n          )\n          -1\n        }\n        case None => -1\n      }\n    }\n  }\n}\n\nexport function checkLoopExitStatement(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> () {\n  let keyword = if node.kind == \"statement/break\" {\n    \"break\"\n  } else {\n    \"continue\"\n  }\n  let targetIndex = resolveLoopTarget(\n    state,\n    moduleIndex,\n    source,\n    node,\n    keyword,\n  )\n  if keyword == \"continue\" {\n    return ()\n  }\n  let expected = if targetIndex >= 0 {\n    match state.loopFrames.get(targetIndex) {\n      case Some(frame) => frame.expected\n      case None => None\n    }\n  } else {\n    None\n  }\n  let valueType = match child(node, \"value\") {\n    case Some(value) => match expected {\n      case Some(expectedType) => {\n        let inferred = inferExpressionWithExpected(\n          service,\n          state,\n          moduleIndex,\n          source,\n          value,\n          expectedType,\n          false,\n        )\n        refineExpressionToExpected(\n          state,\n          moduleIndex,\n          value,\n          inferred,\n          expectedType,\n        )\n      }\n      case None => inferExpression(service, state, moduleIndex, source, value)\n    }\n    case None => primitive(\"unit\")\n  }\n  if targetIndex < 0 {\n    return ()\n  }\n  match state.loopFrames.get(targetIndex) {\n    case Some(frame) => if frame.valueLoop {\n      let mut breaks = frame.breaks\n      if frame.expected == None && breaks.length > 0 {\n        match breaks.get(0) {\n          case Some(first) => {\n            let earlier = widen(first)\n            let current = widen(valueType)\n            if !hasHole(earlier) && !hasHole(current) &&\n              !assignable(earlier, current) &&\n              !assignable(current, earlier) {\n              addDiagnostic(\n                state,\n                moduleIndex,\n                \"TPZ5721\",\n                \"`break` values targeting this loop disagree — earlier `break` is `{typeText(earlier)}`, this is `{typeText(current)}` (all break values must have the same type)\",\n                \"\",\n                node,\n              )\n            }\n          }\n          case None => ()\n        }\n      }\n      breaks.push(valueType)\n      let mut frames = state.loopFrames\n      frames[targetIndex] = LoopFrame { ...frame, breaks: breaks }\n    }\n    case Some(_) => ()\n    case None => ()\n  }\n  ()\n}\n\nfunction inferLoopExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let expected = currentExpectedExpression(state, node)\n  let frame = LoopFrame {\n    label: match child(node, \"label\") {\n      case Some(label) => text(source, label)\n      case None => \"\"\n    },\n    valueLoop: true,\n    bareTarget: true,\n    bareError: \"\",\n    expected: expected,\n    breaks: [],\n  }\n  let mut frames = state.loopFrames\n  frames.push(frame)\n  match child(node, \"body\") {\n    case Some(body) => {\n      let _ = serviceCheckBlock(\n        service,\n        state,\n        moduleIndex,\n        source,\n        body,\n      )\n    }\n    case None => ()\n  }\n  let completed = match frames.get(frames.length - 1) {\n    case Some(found) => found\n    case None => frame\n  }\n  frames.pop()\n  if completed.breaks.length == 0 {\n    primitive(\"unit\")\n  } else {\n    match expected {\n      case Some(_) => unionType(completed.breaks)\n      case None => widenedUnion(completed.breaks)\n    }\n  }\n}\n\nfunction inferForExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let statementPosition = statementForExpression(state, node)\n  let iteratorNode = child(node, \"iterator\")\n  let iterator = match iteratorNode {\n    case Some(found) => inferExpression(service, state, moduleIndex, source, found)\n    case None => emptyType(\"unknown\")\n  }\n  match child(node, \"pattern\") {\n    case Some(pattern) => patternBindingType(\n      service,\n      state,\n      moduleIndex,\n      source,\n      pattern,\n      checkedIterableElement(\n        state,\n        moduleIndex,\n        match iteratorNode {\n          case Some(found) => found\n          case None => node\n        },\n        iterator,\n      ),\n      false,\n    )\n    case None => ()\n  }\n  let mut frames = state.loopFrames\n  frames.push(LoopFrame {\n    label: \"\",\n    valueLoop: false,\n    bareTarget: statementPosition,\n    bareError: \"a value-collecting `for` (§5)\",\n    expected: None,\n    breaks: [],\n  })\n  let bodyType = match child(node, \"body\") {\n    case Some(body) => serviceCheckBlock(\n      service,\n      state,\n      moduleIndex,\n      source,\n      body,\n    )\n    case None => primitive(\"unit\")\n  }\n  frames.pop()\n  if statementPosition {\n    primitive(\"unit\")\n  } else {\n    constructor(\"Array\", [widen(bodyType)])\n  }\n}\n\nfunction inferConcurrentExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  match child(node, \"timeout\") {\n    case Some(found) => {\n      if found.kind == \"expression/duration\" &&\n        !durationFitsMilliseconds(found) {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5001\",\n          \"`concurrent` timeout duration must fit in u64 milliseconds (§15)\",\n          \"\",\n          found,\n        )\n      }\n      let timeoutType = inferExpression(service, state, moduleIndex, source, found)\n      if timeoutType.kind == \"unknown\" {\n        addNode(state, moduleIndex, \"expression\", found, timeoutType)\n      }\n    }\n    case None => ()\n  }\n  let mut names: Array<string> = []\n  let mut values: Array<TypeValue> = []\n  for arm in children(node, \"arms\") {\n    let nameNode = match child(arm, \"name\") {\n      case Some(found) => found\n      case None => arm\n    }\n    let name = text(source, nameNode)\n    let mut duplicate = false\n    for existing in names {\n      if existing == name {\n        duplicate = true\n      }\n    }\n    if duplicate {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5008\",\n        \"duplicate concurrent arm `{name}`\",\n        \"\",\n        nameNode,\n      )\n    }\n    let value = match child(arm, \"value\") {\n      case Some(found) => widen(inferExpression(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n      ))\n      case None => emptyType(\"unknown\")\n    }\n    names.push(name)\n    values.push(value)\n  }\n  let record = structural(names, values)\n  match child(node, \"else\") {\n    case Some(found) => {\n      if hasHole(record) || blockTerminates(found) {\n        let _ = serviceCheckBlock(service, state, moduleIndex, source, found)\n      } else {\n        let _ = serviceCheckBlockExpected(service, state, moduleIndex, source, found, record)\n      }\n    }\n    case None => ()\n  }\n  if hasHole(record) {\n    emptyType(\"unknown\")\n  } else {\n    record\n  }\n}\n\nfunction durationFitsMilliseconds(node: SyntaxNode) -> bool {\n  let magnitude = attribute(node, \"valueDecimal\")\n  let unit = attribute(node, \"unit\")\n  decodeDurationMilliseconds(\"{magnitude}{unit}\") != None\n}\n\nfunction constantZero(node: SyntaxNode) -> bool {\n  if node.kind == \"expression/integer\" {\n    return attribute(node, \"valueDecimal\").toInt() == Some(0)\n  }\n  if node.kind == \"expression/parenthesized\" ||\n    node.kind == \"expression/unary\" &&\n      (attribute(node, \"operator\") == \"plus\" || attribute(node, \"operator\") == \"minus\") {\n    return match child(node, \"operand\") {\n      case Some(found) => constantZero(found)\n      case None => false\n    }\n  }\n  false\n}\n\nfunction inferRangeExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  for fieldName in [\"low\", \"high\", \"step\"] {\n    match child(node, fieldName) {\n      case Some(found) => {\n        let endpoint = widen(inferExpression(\n          service,\n          state,\n          moduleIndex,\n          source,\n          found,\n        ))\n        if !hasHole(endpoint) &&\n          (endpoint.kind != \"primitive\" || endpoint.name != \"int\") {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            if fieldName == \"step\" {\n              \"a range step is `int`, found `{typeText(endpoint)}`\"\n            } else {\n              \"range endpoints are `int`, found `{typeText(endpoint)}`\"\n            },\n            \"\",\n            found,\n          )\n        }\n        if fieldName == \"step\" && constantZero(found) {\n          addDiagnostic(state, moduleIndex, \"TPZ5001\",\n            \"the range step must not be zero (§10)\", \"\", found)\n        }\n      }\n      case None => ()\n    }\n  }\n  constructor(\"Range\", [primitive(\"int\")])\n}\n\nfunction sameBinaryType(\n  left: TypeValue,\n  right: TypeValue,\n  kind: string,\n  name: string,\n) -> bool {\n  left.kind == kind && right.kind == kind &&\n    left.name == name && right.name == name\n}\n\nexport function inferBinaryExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let operator = attribute(node, \"operator\")\n  let equality = operator == \"equal\" || operator == \"not-equal\"\n  let leftNode = child(node, \"left\")\n  let left = match leftNode {\n    case Some(found) => if equality {\n      inferExpressionContext(service, state, moduleIndex, source, found)\n    } else {\n      inferExpression(service, state, moduleIndex, source, found)\n    }\n    case None => emptyType(\"unknown\")\n  }\n  if operator == \"coalesce\" {\n    let optional = if left.kind == \"constructor\" && left.name == \"Option\" {\n      left.arguments.get(0)\n    } else if left.kind == \"union\" {\n      let mut nullable = false\n      let mut remaining: Array<TypeValue> = []\n      for member in left.members {\n        if member.kind == \"literal\" && member.name == \"null\" {\n          nullable = true\n        } else {\n          remaining.push(member)\n        }\n      }\n      if nullable && remaining.length > 0 {\n        Some(unionType(remaining))\n      } else {\n        None\n      }\n    } else {\n      None\n    }\n    return match optional {\n      case Some(inner) => {\n        match child(node, \"right\") {\n          case Some(found) => {\n            let _ = checkExpressionExpected(\n              service,\n              state,\n              moduleIndex,\n              source,\n              found,\n              inner,\n            )\n          }\n          case None => ()\n        }\n        inner\n      }\n      case None => {\n        match child(node, \"right\") {\n          case Some(found) => { let _ = inferExpression(service, state, moduleIndex, source, found) }\n          case None => ()\n        }\n        if !hasHole(left) {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"`??` needs an Option or nullable left operand, found `{typeText(left)}`\",\n            \"\",\n            node,\n          )\n        }\n        emptyType(\"unknown\")\n      }\n    }\n  }\n  let right = match child(node, \"right\") {\n    case Some(found) => if equality {\n      inferExpressionContext(service, state, moduleIndex, source, found)\n    } else {\n      inferExpression(service, state, moduleIndex, source, found)\n    }\n    case None => emptyType(\"unknown\")\n  }\n  let mut lhs = widen(left)\n  let mut rhs = widen(right)\n  if operator == \"equal\" || operator == \"not-equal\" {\n    if hasPartialHole(lhs) && !hasHole(rhs) {\n      lhs = solvePartialTypeAgainst(state, lhs, rhs)\n    } else if hasPartialHole(rhs) && !hasHole(lhs) {\n      rhs = solvePartialTypeAgainst(state, rhs, lhs)\n    }\n  }\n  if hasHole(lhs) || hasHole(rhs) {\n    return emptyType(\"unknown\")\n  }\n  let lu = lengthUnit(lhs)\n  let ru = lengthUnit(rhs)\n  if lu != \"\" || ru != \"\" {\n    if lu != \"\" && lu == ru {\n      if operator == \"add\" || operator == \"subtract\" { return lhs }\n      if operator == \"divide\" { return primitive(\"float\") }\n      if operator == \"equal\" || operator == \"not-equal\" || operator == \"less-than\" || operator == \"less-or-equal\" || operator == \"greater-than\" || operator == \"greater-or-equal\" { return primitive(\"bool\") }\n    }\n    let leftScalar = lhs.kind == \"primitive\" && (lhs.name == \"int\" || lhs.name == \"float\")\n    let rightScalar = rhs.kind == \"primitive\" && (rhs.name == \"int\" || rhs.name == \"float\")\n    if operator == \"multiply\" && lu != \"\" && rightScalar { return lhs }\n    if operator == \"multiply\" && ru != \"\" && leftScalar { return rhs }\n    if operator == \"divide\" && lu != \"\" && rhs.kind == \"primitive\" && rhs.name == \"int\" { return lhs }\n    addDiagnostic(state,moduleIndex,\"TPZ5001\",\"Length operation requires compatible units and scalar operands, found `{typeText(lhs)}` and `{typeText(rhs)}`\",\"\",node)\n    return emptyType(\"unknown\")\n  }\n  match operator {\n    case \"power\" | \"divide\" => if sameBinaryType(\n      lhs,\n      rhs,\n      \"primitive\",\n      \"int\",\n    ) {\n      primitive(\"int\")\n    } else if sameBinaryType(lhs, rhs, \"primitive\", \"float\") {\n      primitive(\"float\")\n    } else {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"arithmetic needs matching numeric operands, found `{typeText(lhs)}` and `{typeText(rhs)}`\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    }\n    case \"multiply\" | \"subtract\" => if sameBinaryType(\n      lhs,\n      rhs,\n      \"primitive\",\n      \"int\",\n    ) {\n      primitive(\"int\")\n    } else if sameBinaryType(lhs, rhs, \"primitive\", \"float\") {\n      primitive(\"float\")\n    } else if sameBinaryType(lhs, rhs, \"big-int\", \"\") {\n      emptyType(\"big-int\")\n    } else if sameBinaryType(lhs, rhs, \"decimal\", \"\") {\n      emptyType(\"decimal\")\n    } else {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"arithmetic needs matching numeric operands, found `{typeText(lhs)}` and `{typeText(rhs)}`\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    }\n    case \"remainder\" => if sameBinaryType(lhs, rhs, \"primitive\", \"int\") {\n      primitive(\"int\")\n    } else {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"`%` needs int operands in v5.2, found `{typeText(lhs)}` and `{typeText(rhs)}`\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    }\n    case \"add\" => if sameBinaryType(lhs, rhs, \"primitive\", \"int\") {\n      primitive(\"int\")\n    } else if sameBinaryType(lhs, rhs, \"primitive\", \"float\") {\n      primitive(\"float\")\n    } else if sameBinaryType(lhs, rhs, \"primitive\", \"string\") {\n      primitive(\"string\")\n    } else if sameBinaryType(lhs, rhs, \"big-int\", \"\") {\n      emptyType(\"big-int\")\n    } else if sameBinaryType(lhs, rhs, \"decimal\", \"\") {\n      emptyType(\"decimal\")\n    } else {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"`+` needs matching int, float, string, BigInt, or Decimal operands, found `{typeText(lhs)}` and `{typeText(rhs)}`\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    }\n    case \"less-than\" | \"less-or-equal\" | \"greater-than\" |\n      \"greater-or-equal\" => {\n      let scalar = sameBinaryType(lhs, rhs, \"primitive\", \"int\") ||\n        sameBinaryType(lhs, rhs, \"primitive\", \"float\") ||\n        sameBinaryType(lhs, rhs, \"primitive\", \"string\") ||\n        sameBinaryType(lhs, rhs, \"big-int\", \"\") ||\n        sameBinaryType(lhs, rhs, \"decimal\", \"\")\n      let nominal = (assignable(lhs, rhs) || assignable(rhs, lhs)) &&\n        orderCapability(state, moduleIndex, lhs, []) == \"accept\" &&\n        orderCapability(state, moduleIndex, rhs, []) == \"accept\"\n      if scalar || nominal {\n        primitive(\"bool\")\n      } else {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5007\",\n          \"`{typeText(lhs)}` and `{typeText(rhs)}` are not ordered comparable\",\n          \"\",\n          node,\n        )\n        emptyType(\"unknown\")\n      }\n    }\n    case \"equal\" | \"not-equal\" => if !comparableType(\n      state,\n      moduleIndex,\n      lhs,\n      [],\n    ) || !comparableType(state, moduleIndex, rhs, []) {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5007\",\n        \"`{typeText(lhs)}` and `{typeText(rhs)}` are not comparable values\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    } else if assignable(lhs, rhs) || assignable(rhs, lhs) {\n      primitive(\"bool\")\n    } else {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5007\",\n        \"`{typeText(lhs)}` and `{typeText(rhs)}` are never equal\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    }\n    case \"in\" => if rhs.kind == \"constructor\" &&\n      (rhs.name == \"Array\" || rhs.name == \"Set\" || rhs.name == \"Range\") {\n      match rhs.arguments.get(0) {\n        case Some(element) => reportExpectedType(\n          state,\n          moduleIndex,\n          node,\n          element,\n          lhs,\n        )\n        case None => ()\n      }\n      primitive(\"bool\")\n    } else if rhs.kind == \"constructor\" && rhs.name == \"Map\" {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"`in` does not apply to a Map; use `in map.keys`\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    } else if rhs.kind == \"primitive\" && rhs.name == \"string\" {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"`in` does not apply to strings\",\n        \"\",\n        node,\n      )\n      emptyType(\"unknown\")\n    } else {\n      emptyType(\"unknown\")\n    }\n    case \"and\" | \"or\" => {\n      reportExpectedType(state, moduleIndex, node, primitive(\"bool\"), lhs)\n      reportExpectedType(state, moduleIndex, node, primitive(\"bool\"), rhs)\n      primitive(\"bool\")\n    }\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction inferUnaryExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  if state.languageMode == \"topaz-5.21\" {\n    match signedIntegerInput(node, source) {\n      case Some(input) => return match decodeIntegerLiteral(input.spelling, input.negative) {\n        case Some(value) => {\n          let ty = literal(\"int\", \"{value}\")\n          let mut current = node\n          while true {\n            recordInferredExpression(state, moduleIndex, source, current, ty)\n            if current.kind != \"expression/parenthesized\" && current.kind != \"expression/unary\" { break }\n            match child(current, \"operand\") { case Some(value) => { current = value }; case None => { break } }\n          }\n          ty\n        }\n        case None => { addDiagnostic(state,moduleIndex,\"TPZ5001\",\"integer literal is out of range\",\"\",node); emptyType(\"unknown\") }\n      }\n      case None => ()\n    }\n  }\n  match signedLengthInput(node,source) {\n    case Some(input) => return match decodeLength(input.spelling,input.negative) {\n      case Ok(value) => {\n        let ty=lengthType(value.unit)\n        let mut current=node\n        while true {\n          recordInferredExpression(state,moduleIndex,source,current,ty)\n          if current.kind != \"expression/parenthesized\" && current.kind != \"expression/unary\" {break}\n          match child(current,\"operand\") {\n            case Some(value) => { current = value }\n            case None => { break }\n          }\n        }\n        ty\n      }\n      case Err(message) => {addDiagnostic(state,moduleIndex,\"TPZ5001\",message,\"\",node);emptyType(\"unknown\")}\n    }\n    case None => ()\n  }\n  let operandNode = child(node, \"operand\")\n  let operand = match operandNode {\n    case Some(found) => inferExpression(service, state, moduleIndex, source, found)\n    case None => emptyType(\"unknown\")\n  }\n  let widened = widen(operand)\n  if hasHole(widened) {\n    return emptyType(\"unknown\")\n  }\n  let operator = attribute(node, \"operator\")\n  let valid = if lengthUnit(widened) != \"\" { operator == \"minus\" } else if operator == \"not\" {\n    widened.kind == \"primitive\" && widened.name == \"bool\"\n  } else {\n    (widened.kind == \"primitive\" &&\n      (widened.name == \"int\" || widened.name == \"float\")) ||\n      widened.kind == \"big-int\" || widened.kind == \"decimal\"\n  }\n  if valid {\n    if operator == \"not\" { primitive(\"bool\") } else { widened }\n  } else {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"unary operator cannot apply to `{typeText(widened)}`\",\n      \"\",\n      match operandNode {\n        case Some(found) => found\n        case None => node\n      },\n    )\n    emptyType(\"unknown\")\n  }\n}\n\nfunction inferTryExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let expected = currentFunctionReturn(state)\n  match expected {\n    case None => addDiagnostic(state, moduleIndex, \"TPZ5001\", \"`return` outside a function\", \"\", node)\n    case Some(_) => ()\n  }\n  let operand = match child(node, \"operand\") {\n    case Some(found) => inferExpression(service, state, moduleIndex, source, found)\n    case None => emptyType(\"unknown\")\n  }\n  if operand.kind == \"constructor\" && operand.name == \"Result\" {\n    match expected {\n      case Some(result) => if result.kind == \"constructor\" && result.name == \"Result\" {\n        match operand.arguments.get(1) {\n          case Some(error) => match result.arguments.get(1) {\n            case Some(expectedError) => reportExpectedType(state, moduleIndex, node, expectedError, error)\n            case None => ()\n          }\n          case None => ()\n        }\n      } else if !hasHole(result) {\n        addDiagnostic(state, moduleIndex, \"TPZ5001\",\n          \"`?` propagates an error, but the function returns `{typeText(result)}`, not a Result\", \"\", node)\n      }\n      case None => ()\n    }\n    match operand.arguments.get(0) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n  } else {\n    if !hasHole(operand) {\n      addDiagnostic(state, moduleIndex, \"TPZ5001\",\n        \"`?` requires a Result value, found `{typeText(operand)}`\", \"\", node)\n    }\n    emptyType(\"unknown\")\n  }\n}\n\nfunction inferComposeExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let leftNode = match child(node, \"left\") { case Some(found) => found; case None => node }\n  let rightNode = match child(node, \"right\") { case Some(found) => found; case None => node }\n  let left = inferExpression(service, state, moduleIndex, source, leftNode)\n  let right = inferExpression(service, state, moduleIndex, source, rightNode)\n  if hasHole(left) || hasHole(right) { return emptyType(\"unknown\") }\n  if left.kind != \"function\" || right.kind != \"function\" {\n    let invalid = if left.kind != \"function\" { left } else { right }\n    addDiagnostic(state, moduleIndex, \"TPZ5005\", \"`{typeText(invalid)}` is not callable\", \"\",\n      if left.kind != \"function\" { leftNode } else { rightNode })\n    return emptyType(\"unknown\")\n  }\n  if left.parameters.length != 1 || left.variadic.length != 0 {\n    addDiagnostic(state, moduleIndex, \"TPZ5004\",\n      \"the left side of `>>` takes exactly one argument (§11)\", \"\", leftNode)\n  }\n  if right.parameters.length != 1 || right.variadic.length != 0 {\n    addDiagnostic(state, moduleIndex, \"TPZ5004\",\n      \"the right side of `>>` takes exactly one argument (§11)\", \"\", rightNode)\n  } else {\n    match left.result.get(0) {\n      case Some(result) => match right.parameters.get(0) {\n        case Some(parameter) => reportExpectedType(state, moduleIndex, rightNode, parameter, result)\n        case None => ()\n      }\n      case None => ()\n    }\n  }\n  functionType(left.parameters, left.variadic,\n    match right.result.get(0) { case Some(found) => found; case None => emptyType(\"unknown\") })\n}\n\nfunction inferIndexExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let objectType = match child(node, \"object\") {\n    case Some(found) => inferExpression(service, state, moduleIndex, source, found)\n    case None => emptyType(\"unknown\")\n  }\n  let indexNode = child(node, \"index\")\n  let indexType = match indexNode {\n    case Some(found) => inferExpression(service, state, moduleIndex, source, found)\n    case None => emptyType(\"unknown\")\n  }\n  if objectType.kind == \"constructor\" && objectType.name == \"Array\" {\n    match indexNode {\n      case Some(found) => reportExpectedType(\n        state,\n        moduleIndex,\n        found,\n        primitive(\"int\"),\n        indexType,\n      )\n      case None => ()\n    }\n    match objectType.arguments.get(0) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n  } else if hasHole(objectType) {\n    emptyType(\"unknown\")\n  } else if objectType.kind == \"union\" {\n    let mut containsArray = false\n    for member in objectType.members {\n      if member.kind == \"constructor\" && member.name == \"Array\" {\n        containsArray = true\n      }\n    }\n    if containsArray {\n      match indexNode {\n        case Some(found) => reportExpectedType(\n          state,\n          moduleIndex,\n          found,\n          primitive(\"int\"),\n          indexType,\n        )\n        case None => ()\n      }\n    } else {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5001\",\n        \"`{typeText(objectType)}` is not index-readable; only arrays support `[…]` indexing (§9)\",\n        \"\",\n        node,\n      )\n    }\n    emptyType(\"unknown\")\n  } else {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      if objectType.kind == \"constructor\" && objectType.name == \"Map\" {\n        \"a Map is not index-readable; use `m.get` (§22)\"\n      } else {\n        \"`{typeText(objectType)}` is not index-readable; only arrays support `[…]` indexing (§9)\"\n      },\n      \"\",\n      node,\n    )\n    emptyType(\"unknown\")\n  }\n}\n\nfunction inferBlockExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  match child(node, \"block\") {\n    case Some(found) => match currentExpectedExpression(state, node) {\n      case Some(expected) => serviceCheckBlockExpectedResult(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        expected,\n        currentExpressionChecksResult(state, node),\n      )\n      case None => if hasBranchJoinContext(state, node) {\n        inferBranchExpression(service, state, moduleIndex, source, found, false)\n      } else {\n        serviceCheckBlock(service, state, moduleIndex, source, found)\n      }\n    }\n    case None => primitive(\"unit\")\n  }\n}\n\nfunction inferUnknownExpressionChildren(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  for nested in node.children {\n    if nested.kind.startsWith(\"expression/\") {\n      let _ = inferExpression(service, state, moduleIndex, source, nested)\n    }\n  }\n  emptyType(\"unknown\")\n}\n\nfunction inferExpressionValue(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  match node.kind {\n    case \"expression/integer\" => {\n      let value = attribute(node, \"valueDecimal\")\n      match value.toInt() {\n        case Some(found) => literal(\"int\", \"{found}\")\n        case None => {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            if state.languageMode == \"topaz-5.21\" { \"TPZ5001\" } else { \"TPZ5022\" },\n            \"integer literal `{value}` is out of range\",\n            \"\",\n            node,\n          )\n          emptyType(\"unknown\")\n        }\n      }\n    }\n    case \"expression/length\" => {\n      match decodeLength(text(source,node),false) {\n        case Ok(value) => lengthType(value.unit)\n        case Err(message) => { addDiagnostic(state,moduleIndex,\"TPZ5001\",message,\"\",node); emptyType(\"unknown\") }\n      }\n    }\n    case \"expression/float\" => literal(\"float\", match decodeDecimalFloatLiteral(text(source,node)) {case Some(value)=>\"{value}\";case None=>\"\"})\n    case \"expression/boolean\" => literal(\"bool\", attribute(node, \"value\"))\n    case \"expression/null\" => literal(\"null\", \"\")\n    case \"expression/unit\" => primitive(\"unit\")\n    case \"expression/placeholder\" => currentPipeValue(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n    )\n    case \"expression/try\" => inferTryExpression(service, state, moduleIndex, source, node)\n    case \"expression/string\" | \"expression/template\" =>\n      inferTextExpression(service, state, moduleIndex, source, node)\n    case \"expression/identifier\" =>\n      inferIdentifierExpression(state, moduleIndex, source, node, false)\n    case \"expression/parenthesized\" => match child(node, \"operand\") {\n      case Some(found) => match currentExpectedExpression(state, node) {\n        case Some(expected) => inferExpressionWithResultContext(\n          service, state, moduleIndex, source, found, expected, false,\n          currentExpressionChecksResult(state, node))\n        case None => if hasBranchJoinContext(state, node) {\n          inferBranchExpression(service, state, moduleIndex, source, found, false)\n        } else {\n          inferExpression(service, state, moduleIndex, source, found)\n        }\n      }\n      case None => emptyType(\"unknown\")\n    }\n    case \"expression/array\" | \"expression/set\" =>\n      inferSequenceLiteralExpression(service, state, moduleIndex, source, node)\n    case \"expression/map\" =>\n      inferMapLiteralExpression(service, state, moduleIndex, source, node)\n    case \"expression/member\" | \"expression/optional-access\" =>\n      inferMemberAccessExpression(service, state, moduleIndex, source, node)\n    case \"expression/index\" => inferIndexExpression(service, state, moduleIndex, source, node)\n    case \"expression/call\" => inferCall(service, state, moduleIndex, source, node)\n    case \"expression/pipe\" => inferPipe(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n    )\n    case \"expression/compose\" => inferComposeExpression(service, state, moduleIndex, source, node)\n    case \"expression/record-literal\" =>\n      inferRecordLiteralExpression(service, state, moduleIndex, source, node)\n    case \"expression/record-update\" =>\n      inferRecordUpdateExpression(service, state, moduleIndex, source, node)\n    case \"expression/block\" => inferBlockExpression(service, state, moduleIndex, source, node)\n    case \"expression/if\" =>\n      inferIfExpression(service, state, moduleIndex, source, node)\n    case \"expression/match\" =>\n      inferMatchExpression(service, state, moduleIndex, source, node)\n    case \"expression/for\" =>\n      inferForExpression(service, state, moduleIndex, source, node)\n    case \"expression/loop\" =>\n      inferLoopExpression(service, state, moduleIndex, source, node)\n    case \"expression/concurrent\" =>\n      inferConcurrentExpression(service, state, moduleIndex, source, node)\n    case \"expression/comprehension\" => inferComprehension(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n    )\n    case \"expression/range\" =>\n      inferRangeExpression(service, state, moduleIndex, source, node)\n    case \"expression/binary\" =>\n      inferBinaryExpression(service, state, moduleIndex, source, node)\n    case \"expression/unary\" =>\n      inferUnaryExpression(service, state, moduleIndex, source, node)\n    case \"expression/lambda\" => inferLambda(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n      currentExpectedExpression(state, node),\n    )\n    case _ => inferUnknownExpressionChildren(service, state, moduleIndex, source, node)\n  }\n}\n\nexport function inferExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  if node.kind == \"expression/call\" || node.kind == \"expression/pipe\" ||\n    node.kind == \"expression/concurrent\" || node.kind == \"expression/await\" {\n    advanceConstantRenderEpoch(state)\n  }\n  let result = inferExpressionValue(service, state, moduleIndex, source, node)\n  recordInferredExpression(state, moduleIndex, source, node, result)\n  result\n}\n\nfunction pipeCallHasPlaceholder(stage: SyntaxNode) -> bool {\n  for argument in children(stage, \"arguments\") {\n    if containsPlaceholder(argumentValue(argument)) {\n      return true\n    }\n  }\n  false\n}\n\nfunction inferBarePipeStage(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  leftNode: SyntaxNode,\n  leftType: TypeValue,\n  stage: SyntaxNode,\n) -> TypeValue {\n  let stageType = inferExpression(service, state, moduleIndex, source, stage)\n  let mut result = emptyType(\"unknown\")\n  if !hasHole(stageType) {\n    if stageType.kind == \"function\" {\n      let expected = if stageType.parameters.length == 1 {\n        stageType.parameters.get(0)\n      } else if stageType.parameters.length == 0 &&\n        stageType.variadic.length > 0 {\n        stageType.variadic.get(0)\n      } else {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5004\",\n          \"a pipeline stage takes the piped value as its only argument (§11)\",\n          \"\",\n          stage,\n        )\n        None\n      }\n      match expected {\n        case Some(expectedType) => {\n          let refined = refineExpressionToExpected(\n            state,\n            moduleIndex,\n            leftNode,\n            leftType,\n            expectedType,\n          )\n          reportExpectedType(\n            state,\n            moduleIndex,\n            leftNode,\n            expectedType,\n            refined,\n          )\n          result = match stageType.result.get(0) {\n            case Some(found) => found\n            case None => emptyType(\"unknown\")\n          }\n        }\n        case None => ()\n      }\n    } else {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5005\",\n        \"`{typeText(stageType)}` is not callable\",\n        \"\",\n        stage,\n      )\n    }\n  }\n  addPipeCall(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    leftNode,\n    stage,\n    stage,\n    stageType,\n    emptyType(\"unknown\"),\n    result,\n    false,\n  )\n  result\n}\n\nfunction inferPipeCallStage(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  leftNode: SyntaxNode,\n  stage: SyntaxNode,\n) -> TypeValue {\n  let hasPlaceholder = pipeCallHasPlaceholder(stage)\n  let saved = LeadingCallArgument {\n    moduleIndex: moduleIndex, node: leftNode, stage: stage,\n    activeFunctionDepth: state.activeFunctions.length,\n    returnDepth: state.expectedReturns.length,\n    expectedExpressionDepth: state.expectedExpressions.length,\n    values: [], diagnostics: [],\n  }\n  let leading = if hasPlaceholder { None } else { Some(saved) }\n  let calleeNode = match child(stage, \"callee\") {\n    case Some(found) => found\n    case None => stage\n  }\n  let placeholderCallee = containsPlaceholder(calleeNode)\n  let mut pipeValues = state.pipeValues\n  // The callee is inside this pipeline too; its placement error below owns\n  // an invalid callee placeholder, not the outside-pipeline diagnostic.\n  pipeValues.push(saved)\n  // Discover the callee context before checking the piped argument, but retain\n  // source evaluation order for diagnostics from the left and the callee.\n  let preparationState = CheckerState { ...state, diagnostics: [] }\n  if placeholderCallee {\n    addDiagnostic(\n      preparationState,\n      moduleIndex,\n      \"TPZ5001\",\n      \"a placeholder `_` is valid only in a pipeline stage's argument list (§11)\",\n      \"\",\n      calleeNode,\n    )\n  }\n  let initialPreparation = prepareCall(\n    service,\n    preparationState,\n    moduleIndex,\n    source,\n    stage,\n    node,\n    leading,\n  )\n  let mut calleeDiagnostics = saved.diagnostics\n  for diagnostic in preparationState.diagnostics { calleeDiagnostics.push(diagnostic) }\n  let preparation = initialPreparation\n  let inferred = inferCallArguments(\n    service,\n    state,\n    moduleIndex,\n    source,\n    stage,\n    preparation,\n  )\n  pipeValues.pop()\n  let leftType = match saved.values.get(0) { case Some(found) => found; case None => emptyType(\"unknown\") }\n  let completed = completePreparedCall(\n    service,\n    state,\n    moduleIndex,\n    source,\n    stage,\n    preparation,\n    inferred,\n  )\n  addPipeCall(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    leftNode,\n    stage,\n    preparation.callee,\n    completed.calleeType,\n    preparation.receiverType,\n    completed.resultType,\n    hasPlaceholder,\n  )\n  completed.resultType\n}\n\nfunction inferPipe(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let leftNode = match child(node, \"left\") {\n    case Some(found) => found\n    case None => node\n  }\n  match child(node, \"field\") {\n    case Some(found) => {\n      let object = inferExpression(service, state, moduleIndex, source, leftNode)\n      let name = text(source, found)\n      let member = memberType(state, moduleIndex, object, name)\n      if member.kind == \"unknown\" && !hasHole(object) {\n        addDiagnostic(state, moduleIndex, \"TPZ5006\",\n          missingReceiverMemberMessage(state, moduleIndex, object, name, false), \"\", node)\n      }\n      return member\n    }\n    case None => ()\n  }\n  let stage = match child(node, \"right\") {\n    case Some(found) => found\n    case None => return emptyType(\"unknown\")\n  }\n  if stage.kind != \"expression/call\" {\n    let leftType = inferExpression(service, state, moduleIndex, source, leftNode)\n    return inferBarePipeStage(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n      leftNode,\n      leftType,\n      stage,\n    )\n  }\n  inferPipeCallStage(\n    service,\n    state,\n    moduleIndex,\n    source,\n    node,\n    leftNode,\n    stage,\n  )\n}\n\nfunction inferComprehension(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let mut frames = state.loopFrames\n  frames.push(LoopFrame {\n    label: \"\",\n    valueLoop: false,\n    bareTarget: false,\n    bareError: \"a comprehension (§6.4)\",\n    expected: None,\n    breaks: [],\n  })\n  for clause in children(node, \"clauses\") {\n    if clause.kind == \"comprehension-clause/for\" {\n      let iterator = match child(clause, \"iterator\") {\n        case Some(found) => inferExpression(service, state, moduleIndex, source, found)\n        case None => emptyType(\"unknown\")\n      }\n      match child(clause, \"pattern\") {\n        case Some(pattern) => patternBindingType(\n          service,\n          state,\n          moduleIndex,\n          source,\n          pattern,\n          checkedIterableElement(\n            state,\n            moduleIndex,\n            match child(clause, \"iterator\") {\n              case Some(found) => found\n              case None => clause\n            },\n            iterator,\n          ),\n          false,\n        )\n        case None => ()\n      }\n    } else {\n      match child(clause, \"condition\") {\n        case Some(found) => {\n          let _ = checkExpressionExpected(\n            service,\n            state,\n            moduleIndex,\n            source,\n            found,\n            primitive(\"bool\"),\n          )\n        }\n        case None => ()\n      }\n    }\n  }\n  let result = match attribute(node, \"collection\") {\n    case \"map\" => {\n      let key = match child(node, \"bodyKey\") {\n        case Some(found) => widen(inferExpression(service, state, moduleIndex, source, found))\n        case None => emptyType(\"unknown\")\n      }\n      let value = match child(node, \"bodyValue\") {\n        case Some(found) => widen(inferExpression(service, state, moduleIndex, source, found))\n        case None => emptyType(\"unknown\")\n      }\n      gateCollectionKey(service, state, moduleIndex, node, key)\n      constructor(\"Map\", [key, value])\n    }\n    case \"set\" => {\n      let value = match child(node, \"body\") {\n        case Some(found) => widen(inferExpression(service, state, moduleIndex, source, found))\n        case None => emptyType(\"unknown\")\n      }\n      gateCollectionKey(service, state, moduleIndex, node, value)\n      constructor(\"Set\", [value])\n    }\n    case _ => {\n      let value = match child(node, \"body\") {\n        case Some(found) => widen(inferExpression(service, state, moduleIndex, source, found))\n        case None => emptyType(\"unknown\")\n      }\n      constructor(\"Array\", [value])\n    }\n  }\n  frames.pop()\n  result\n}\n",
      "sourceSha256": "fd94da8bb1c7829abf6beab31b634b27300ca6dd53de97740ccaf13ec2d12f19"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/expression_core.tpz",
      "language": "topaz",
      "bytes": 64761,
      "sha256": "3503e9e45f89b2c78f7811498baa1e159f93d01fd0abf50c74fb5fc8846dde06",
      "content": "// Core expression inference for literals, lambdas, aggregates, and members.\n// Control forms live beside it in expression_control, while call expressions\n// cross the explicit checker service rather than importing call leaves back.\n\nimport types { SyntaxNode }\nimport checker_types { TypeValue }\nimport unicode { didYouMean }\nimport checker.model {\n  CheckerService,\n  CheckerState,\n  TypeBinding,\n  constantRenderEpoch,\n  advanceConstantRenderEpoch,\n  restoreConstantRenderEpoch,\n  ReturnExpectation,\n  constructor,\n  emptyType,\n  functionType,\n  inference,\n  literal,\n  nominal,\n  lengthUnit,\n  primitive,\n  rigid,\n  serviceCheckBlock,\n  serviceInferExpression,\n  structural,\n}\nimport checker.type_algebra {\n  typeDecidable,\n  typesOverlap,\n  hasHole,\n  hasPartialHole,\n  joinedTypes,\n  typeContains,\n  typeText,\n  unionType,\n  widen,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  addNode,\n  attribute,\n  bindSymbol,\n  child,\n  children,\n  containsString,\n  functionDefinitionForReference,\n  protocolDefinition,\n  protocolMethodDefinition,\n  referenceFor,\n  replaceNodeType,\n  spanKey,\n  symbolAt,\n  text,\n  unwrapExport,\n}\nimport checker.nominals {\n  addTypeArgumentArityDiagnostic,\n  formType,\n  substitute,\n}\nimport checker.protocols_methods {\n  enumDefinitionForType,\n  newtypeDefinitionForType,\n  nominalTypeHead,\n  receiverMethodType,\n  recordDefinitionForType,\n  referenceTargetType,\n}\nimport checker.members_capabilities {\n  applyBindings,\n  arraySpreadElement,\n  builtinNamespaceMemberType,\n  containsByteBuffer,\n  checkFunctionBounds,\n  collectTypeBindings,\n  gateCollectionKey,\n  iterableElement,\n  instantiateCallType,\n  memberType,\n  enumVariantType,\n  opaqueMemberNames,\n  protocolStaticMemberType,\n  rigidUnionMissingConcreteMember,\n  scopeCallParameters,\n}\nimport checker.call_facts {\n  argumentValue,\n  calleeReference,\n  builtinIdentifierType,\n  containsPlaceholder,\n  builtinMutator,\n  builtinNamespaceObject,\n  checkExpressionExpected,\n  currentExpectedExpression,\n  currentExpressionChecksResult,\n  generatedLispexIntrinsic,\n  generatedStandardFunctionType,\n  inferExpressionContext,\n  inferExpressionWithResultContext,\n  isBuiltinNamespace,\n  isBareBindingExpression,\n  isImportNamespace,\n  reportExpectedType,\n  unboundCalleeSuggestion,\n  unboundSuggestion,\n  numericMigrationHint,\n  reportRemovedStaticMember,\n  userProtocolObject,\n}\n\n// Classify the same inward value positions that expression inference consumes.\n// This reads existing signatures; it never infers a body or allocates a second scheme.\n// Project the enclosing expectation to the actual lexical pipe hole. A lambda\n// body receives the function result, not the signature of the enclosing lambda.\nexport function pipePlaceholderContext(node: SyntaxNode, expected: Option<TypeValue>) -> Option<TypeValue> {\n  if node.kind == \"expression/placeholder\" { return expected }\n  if node.kind == \"expression/pipe\" {\n    match child(node, \"left\") { case Some(left) => return pipePlaceholderContext(left, None); case None => return None }\n  }\n  if node.kind == \"expression/lambda\" {\n    let result = match expected { case Some(value) => value.result.get(0); case None => None }\n    match child(node, \"body\") { case Some(body) => return pipePlaceholderContext(body, result); case None => return None }\n  }\n  if node.kind == \"expression/parenthesized\" {\n    match child(node, \"operand\") { case Some(inner) => return pipePlaceholderContext(inner, expected); case None => return None }\n  }\n  if node.kind == \"expression/block\" || node.kind == \"block\" {\n    let block = if node.kind == \"block\" { node } else { match child(node, \"block\") { case Some(found) => found; case None => node } }\n    match child(block, \"tail\") { case Some(tail) => return pipePlaceholderContext(tail, expected); case None => return None }\n  }\n  for nested in node.children {\n    let context = if node.kind == \"expression/array\" {\n      match expected { case Some(value) => value.arguments.get(0); case None => None }\n    } else { expected }\n    match pipePlaceholderContext(nested, context) { case Some(found) => return Some(found); case None => () }\n  }\n  None\n}\n\nexport function needsInwardCallContext(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  expected: Option<TypeValue>,\n) -> bool {\n  if containsPlaceholder(node) { return true }\n  if node.kind == \"expression/lambda\" {\n    let context = match expected { case Some(found) => found; case None => emptyType(\"unknown\") }\n    if context.kind != \"function\" { return true }\n    let mut index = 0\n    for parameter in children(node, \"parameters\") {\n      if match child(parameter, \"type\") { case Some(_) => false; case None => true } {\n        match context.parameters.get(index) {\n          case Some(input) => if hasHole(input) || typeContains(input, (part) => part.kind == \"rigid\") {\n            return true\n          }\n          case None => return true\n        }\n      }\n      index += 1\n    }\n    match child(node, \"body\") {\n      case Some(body) => return needsInwardCallContext(state, moduleIndex, source, body, context.result.get(0))\n      case None => ()\n    }\n    return false\n  }\n  if node.kind == \"expression/parenthesized\" {\n    match child(node, \"operand\") { case Some(inner) => return needsInwardCallContext(state, moduleIndex, source, inner, expected); case None => () }\n  }\n  if node.kind == \"expression/block\" || node.kind == \"block\" {\n    let block = if node.kind == \"block\" { node } else { match child(node, \"block\") { case Some(found) => found; case None => node } }\n    match child(block, \"tail\") { case Some(tail) => return needsInwardCallContext(state, moduleIndex, source, tail, expected); case None => () }\n  }\n  if node.kind == \"expression/if\" {\n    for branch in [\"then\", \"else\"] {\n      match child(node, branch) { case Some(value) => if needsInwardCallContext(state, moduleIndex, source, value, expected) { return true }; case None => () }\n    }\n  }\n  if node.kind == \"expression/match\" {\n    for arm in children(node, \"cases\") {\n      match child(arm, \"body\") { case Some(value) => if needsInwardCallContext(state, moduleIndex, source, value, expected) { return true }; case None => () }\n    }\n  }\n  if node.kind == \"expression/array\" || node.kind == \"expression/record-literal\" {\n    let values = if node.kind == \"expression/array\" { children(node, \"elements\") } else { children(node, \"fields\") }\n    for item in values {\n      let value = match child(item, \"value\") { case Some(found) => found; case None => item }\n      if needsInwardCallContext(state, moduleIndex, source, value, None) { return true }\n    }\n  }\n  if node.kind == \"expression/call\" || node.kind == \"expression/record-update\" {\n    let callee = match child(node, if node.kind == \"expression/call\" { \"callee\" } else { \"base\" }) { case Some(found) => found; case None => node }\n    if callee.kind != \"expression/identifier\" { return false }\n    let signature = match referenceTargetType(state, moduleIndex, callee) {\n      case Some(found) => found\n      case None => match builtinIdentifierType(text(source, callee), state.languageMode) { case Some(found) => found; case None => emptyType(\"unknown\") }\n    }\n    if signature.kind == \"newtype\" && signature.arguments.length > 0 { return true }\n    if node.kind == \"expression/record-update\" {\n      if signature.kind != \"nominal-record\" || signature.arguments.length == 0 { return false }\n      for field in children(node, \"fields\") {\n        match child(field, \"value\") { case Some(value) => if needsInwardCallContext(state, moduleIndex, source, value, None) { return true }; case None => () }\n      }\n      return false\n    }\n    if children(node, \"typeArguments\").length > 0 { return false }\n    let result = match signature.result.get(0) { case Some(found) => found; case None => emptyType(\"unknown\") }\n    if !typeContains(result, (part) => part.kind == \"rigid\" || part.kind == \"inference-variable\") { return false }\n    let mut index = 0\n    for argument in children(node, \"arguments\") {\n      let value = argumentValue(argument)\n      let input = match signature.parameters.get(index) { case Some(found) => Some(found); case None => signature.variadic.get(0) }\n      if needsInwardCallContext(state, moduleIndex, source, value, input) { return true }\n      index += 1\n    }\n  }\n  false\n}\n\nexport function blockTerminates(block: SyntaxNode) -> bool {\n  match child(block, \"tail\") {\n    case Some(tail) => if expressionTerminates(tail) { return true }\n    case None => ()\n  }\n  let statements = children(block, \"statements\")\n  if statements.length == 0 {\n    return false\n  }\n  match statements.get(statements.length - 1) {\n    case Some(statement) => {\n      let item = unwrapExport(statement)\n      if item.kind == \"statement/return\" {\n        return true\n      }\n      if item.kind == \"statement/expression\" {\n        match item.children.get(0) {\n          case Some(expression) => return expressionTerminates(expression)\n          case None => ()\n        }\n      }\n    }\n    case None => ()\n  }\n  false\n}\n\nexport function expressionTerminates(expression: SyntaxNode) -> bool {\n  if expression.kind == \"expression/block\" {\n    match child(expression, \"block\") {\n      case Some(block) => return blockTerminates(block)\n      case None => ()\n    }\n  }\n  if expression.kind == \"expression/parenthesized\" {\n    match child(expression, \"operand\") {\n      case Some(operand) => return expressionTerminates(operand)\n      case None => ()\n    }\n  }\n  if expression.kind == \"expression/if\" {\n    let thenTerminates = match child(expression, \"then\") {\n      case Some(found) => blockTerminates(found)\n      case None => false\n    }\n    let elseTerminates = match child(expression, \"else\") {\n      case Some(found) => expressionTerminates(found)\n      case None => false\n    }\n    return thenTerminates && elseTerminates\n  }\n  if expression.kind == \"expression/match\" {\n    let cases = children(expression, \"cases\")\n    if cases.length == 0 {\n      return false\n    }\n    for foundCase in cases {\n      match child(foundCase, \"body\") {\n        case Some(body) => if body.kind != \"match-case-return\" &&\n          !expressionTerminates(body) {\n          return false\n        }\n        case None => return false\n      }\n    }\n    return true\n  }\n  false\n}\n\nexport function inferLambda(\n  service: CheckerService, state: CheckerState, moduleIndex: int, source: Bytes,\n  node: SyntaxNode, expected: Option<TypeValue>,\n) -> TypeValue {\n  let saved = constantRenderEpoch(state)\n  advanceConstantRenderEpoch(state)\n  let result = inferLambdaInner(service, state, moduleIndex, source, node, expected)\n  restoreConstantRenderEpoch(state, saved)\n  result\n}\n\nfunction inferLambdaInner(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  expected: Option<TypeValue>,\n) -> TypeValue {\n  let parameterNodes = children(node, \"parameters\")\n  match expected {\n    case Some(functionValue) => if functionValue.kind == \"function\" &&\n      functionValue.variadic.length == 0 &&\n      functionValue.parameters.length != parameterNodes.length {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5004\",\n        \"this lambda takes {parameterNodes.length} parameter(s), but a function taking {functionValue.parameters.length} is expected\",\n        \"\",\n        node,\n      )\n    }\n    case None => ()\n  }\n  let expectedResult = match expected {\n    case Some(functionValue) => if functionValue.kind == \"function\" {\n      functionValue.result.get(0)\n    } else {\n      None\n    }\n    case None => None\n  }\n  let mut parameters: Array<TypeValue> = []\n  let mut parameterIndex = 0\n  for parameter in parameterNodes {\n    let typeValue = match child(parameter, \"type\") {\n      case Some(found) => formType(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        [],\n        \"lambda\",\n      )\n      case None => match expected {\n        case Some(functionValue) => if functionValue.kind == \"function\" {\n          match functionValue.parameters.get(parameterIndex) {\n            case Some(found) => found\n            case None => inference(parameter.lo)\n          }\n        } else {\n          inference(parameter.lo)\n        }\n        case None => inference(parameter.lo)\n      }\n    }\n    let nameNode = match child(parameter, \"name\") {\n      case Some(found) => found\n      case None => parameter\n    }\n    bindSymbol(\n      state,\n      moduleIndex,\n      nameNode.lo,\n      nameNode.hi,\n      text(source, nameNode),\n      typeValue,\n      false,\n    )\n    addNode(state, moduleIndex, \"binding\", nameNode, typeValue)\n    parameters.push(typeValue)\n    parameterIndex += 1\n  }\n  let mut loopFloors = state.loopFloors\n  loopFloors.push(state.loopFrames.length)\n  let mut expectedReturns = state.expectedReturns\n  expectedReturns.push(ReturnExpectation {\n    typeValue: match expectedResult {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    },\n    checkResult: false,\n  })\n  let mut returnJoins = state.returnJoins\n  returnJoins.push([])\n  let bodyNode = child(node, \"body\")\n  let body = match bodyNode {\n    case Some(found) => match expectedResult {\n      // An unsolved scheme component must not erase concrete sibling types.\n      // Keep the partial result context when checking the callback body.\n      case Some(result) => inferExpressionWithResultContext(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        result,\n        true,\n        false,\n      )\n      case None => serviceInferExpression(service, state, moduleIndex, source, found)\n    }\n    case None => emptyType(\"unknown\")\n  }\n  let mut returns = match returnJoins.get(returnJoins.length - 1) {\n    case Some(found) => found\n    case None => []\n  }\n  returnJoins.pop()\n  expectedReturns.pop()\n  loopFloors.pop()\n  let result = if returns.length == 0 {\n    body\n  } else {\n    match bodyNode {\n      case Some(found) => if !expressionTerminates(found) {\n        returns.push(body)\n      }\n      case None => ()\n    }\n    let widenReturns = match expectedResult {\n      case Some(expected) => !typeContains(expected, (part) => part.kind == \"literal\")\n      case None => true\n    }\n    joinedTypes(state, returns, widenReturns)\n  }\n  functionType(parameters, [], result)\n}\n\nexport function hasLiteralJoinContext(\n  state: CheckerState,\n  expression: SyntaxNode,\n) -> bool {\n  expressionContextAt(state.literalJoinContexts, expression)\n}\n\nexport function hasBranchJoinContext(\n  state: CheckerState,\n  expression: SyntaxNode,\n) -> bool {\n  expressionContextAt(state.branchJoinContexts, expression)\n}\n\nfunction expressionContextAt(contexts: Array<int>, expression: SyntaxNode) -> bool {\n  match contexts.get(contexts.length - 1) {\n    case Some(lo) => lo == expression.lo\n    case None => false\n  }\n}\n\nexport function inferBranchExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n  contextual: bool,\n) -> TypeValue {\n  // Branches can solve each other's inference holes even when their literals\n  // will be widened. Keep this separate from literal-preserving contexts.\n  let mut joins = state.branchJoinContexts\n  joins.push(expression.lo)\n  let result = if expression.kind == \"block\" {\n    serviceCheckBlock(service, state, moduleIndex, source, expression)\n  } else if contextual && expression.kind != \"expression/block\" {\n    inferExpressionContext(service, state, moduleIndex, source, expression)\n  } else {\n    serviceInferExpression(service, state, moduleIndex, source, expression)\n  }\n  joins.pop()\n  result\n}\n\nexport function checkedIterableElement(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  iterator: TypeValue,\n) -> TypeValue {\n  let element = iterableElement(iterator)\n  if element.kind == \"unknown\" && !hasHole(iterator) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"`{typeText(iterator)}` is not iterable (§10)\",\n      \"\",\n      node,\n    )\n  }\n  element\n}\n\nexport function inferTextExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let mut value = \"\"\n  let mut interpolated = false\n  for part in node.children {\n    if part.kind == \"string-part/text\" {\n      value = \"{value}{attribute(part, \"cooked\")}\"\n    }\n    match child(part, \"value\") {\n      case Some(expression) => {\n        interpolated = true\n        let inferred = serviceInferExpression(service, state, moduleIndex, source, expression)\n        if containsByteBuffer(state, moduleIndex, inferred, []) {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"`ByteBuffer` values cannot be interpolated; snapshot to `Bytes` and encode explicitly\",\n            \"\",\n            expression,\n          )\n        }\n      }\n      case None => ()\n    }\n  }\n  if node.kind == \"expression/template\" {\n    emptyType(\"template\")\n  } else if interpolated {\n    primitive(\"string\")\n  } else {\n    literal(\"string\", value)\n  }\n}\n\n// Named generic values are instantiated at their use site, including a\n// callback's returned value. Sharing this path with direct call arguments keeps\n// their schemes separate without importing the call planner back into this leaf.\nexport function specializeGenericFunctionValue(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  declared: TypeValue,\n  expected: TypeValue,\n) -> TypeValue {\n  if expected.kind != \"function\" { return declared }\n  match calleeReference(state, moduleIndex, node) {\n    case Some(reference) => match functionDefinitionForReference(state, reference) {\n      case Some(definition) => if definition.typeParameters.length > 0 {\n        let mut parameters: Array<TypeValue> = []\n        let mut index = 0\n        for name in definition.typeParameters {\n          match definition.typeParameterOrigins.get(index) {\n            case Some(origin) => parameters.push(rigid(name, origin))\n            case None => ()\n          }\n          index += 1\n        }\n        let scheme = scopeCallParameters(parameters, moduleIndex, node)\n        let inferred = instantiateCallType(declared, parameters, scheme)\n        let mut bindings: Array<TypeBinding> = []\n        collectTypeBindings(inferred, expected, bindings, true, scheme)\n        checkFunctionBounds(state, moduleIndex, node, definition, scheme, bindings)\n        let specialized = applyBindings(inferred, bindings)\n        replaceNodeType(state, moduleIndex, \"expression\", node, specialized)\n        return specialized\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n  declared\n}\n\nexport function inferIdentifierExpression(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  callee: bool,\n) -> TypeValue {\n  match referenceTargetType(state, moduleIndex, node) {\n    case Some(found) => match currentExpectedExpression(state, node) {\n      case Some(expected) => specializeGenericFunctionValue(state, moduleIndex, node, found, expected)\n      case None => found\n    }\n    case None => {\n      let name = text(source, node)\n      // Namespace heads have no value type; the resolver owns bare-use errors.\n      if isImportNamespace(state, moduleIndex, name) { return emptyType(\"unknown\") }\n      if name == \"None\" {\n        let expected = currentExpectedExpression(state, node)\n        match expected {\n          case Some(context) => if context.kind == \"constructor\" &&\n            context.name == \"Option\" && context.arguments.length == 1 {\n            return context\n          }\n          case None => ()\n        }\n        let solving = match expected {\n          case Some(context) => !hasPartialHole(context) &&\n            !typeContains(context, (part) => part.kind == \"unknown\" && part.origin == \"generic-call-expectation\")\n          case None => false\n        }\n        if isBareBindingExpression(state, node) || solving {\n          addDiagnostic(state, moduleIndex, \"TPZ5020\",\n            \"this expression needs a contextual type (§22.1): annotate the binding or surrounding expectation\", \"\", node)\n          emptyType(\"unknown\")\n        } else if hasLiteralJoinContext(state, node) || hasBranchJoinContext(state, node) {\n          constructor(\"Option\", [inference(node.lo)])\n        } else {\n          constructor(\"Option\", [emptyType(\"unknown\")])\n        }\n      } else if isBuiltinNamespace(name) {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5002\",\n          \"`{name}` is not bound{numericMigrationHint(state, name)}\",\n          \"\",\n          node,\n        )\n        emptyType(\"unknown\")\n      } else if generatedLispexIntrinsic(state, moduleIndex, name) {\n        match generatedStandardFunctionType(state, moduleIndex, name) { case Some(found) => found; case None => emptyType(\"unknown\") }\n      } else {\n        match builtinIdentifierType(name, state.languageMode) {\n          case Some(found) => found\n          case None => {\n            match referenceFor(state, moduleIndex, node.lo, node.hi) {\n              case Some(reference) => if reference.targetModuleIndex < 0 &&\n                reference.namespace == \"value\" && reference.role == \"read\" {\n                addDiagnostic(\n                  state,\n                  moduleIndex,\n                  \"TPZ5002\",\n                  \"`{reference.name}` is not bound\" + if callee {\n                    unboundCalleeSuggestion(state, reference)\n                  } else {\n                    unboundSuggestion(state, reference)\n                  },\n                  \"\",\n                  node,\n                )\n              }\n              case None => ()\n            }\n            emptyType(\"unknown\")\n          }\n        }\n      }\n    }\n  }\n}\n\nexport function inferSequenceLiteralExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let mut elementTypes: Array<TypeValue> = []\n  let mut opaque = false\n  if children(node, \"elements\").length == 0 {\n    let name = if node.kind == \"expression/array\" { \"Array\" } else { \"Set\" }\n    match currentExpectedExpression(state, node) {\n      case Some(expected) => if expected.kind == \"constructor\" && expected.name == name {\n        return expected\n      }\n      case None => ()\n    }\n    if isBareBindingExpression(state, node) {\n      addDiagnostic(state, moduleIndex, \"TPZ5020\",\n        if name == \"Array\" { \"`[]` needs a contextual type (§22.1): annotate the binding or the expected element type\" }\n        else { \"`set \\{\\}` needs a contextual type (§6): annotate the binding or the expected element type\" }, \"\", node)\n    }\n  }\n  let contextualElement = match currentExpectedExpression(state, node) {\n    case Some(expected) => if currentExpressionChecksResult(state, node) &&\n      node.kind == \"expression/array\" &&\n      children(node, \"elements\").length > 0 &&\n      expected.kind == \"constructor\" && expected.name == \"Array\" &&\n      !typeContains(expected, (part) => part.kind == \"rigid\") {\n      // check_expr(Array) retains even a partial element expectation after\n      // checking every element. Callable results use infer_result instead.\n      expected.arguments.get(0)\n    } else { None }\n    case None => None\n  }\n  for element in children(node, \"elements\") {\n    if element.kind == \"array-element/spread\" {\n      match child(element, \"value\") {\n        case Some(value) => {\n          let spreadType = serviceInferExpression(service, state, moduleIndex, source, value)\n          let spread = arraySpreadElement(spreadType)\n          if spread.status == \"element\" {\n            elementTypes.push(spread.element)\n            match contextualElement {\n              case Some(expected) => reportExpectedType(\n                state, moduleIndex, value, expected, spread.element,\n              )\n              case None => ()\n            }\n          } else {\n            opaque = true\n            if spread.status == \"invalid\" {\n              addDiagnostic(\n                state,\n                moduleIndex,\n                \"TPZ5001\",\n                \"array spread needs an `Array`, found `{typeText(spreadType)}`\",\n                \"\",\n                value,\n              )\n            }\n          }\n        }\n        case None => ()\n      }\n    } else {\n      let inferred = match contextualElement {\n        case Some(expected) => checkExpressionExpected(\n          service, state, moduleIndex, source, element, expected,\n        )\n        case None => serviceInferExpression(service, state, moduleIndex, source, element)\n      }\n      elementTypes.push(widen(inferred))\n    }\n  }\n  match contextualElement {\n    case Some(expected) => return constructor(\"Array\", [expected])\n    case None => ()\n  }\n  let element = if opaque {\n    emptyType(\"unknown\")\n  } else if elementTypes.length == 0 &&\n    node.kind == \"expression/array\" {\n    inference(node.lo)\n  } else {\n    unionType(elementTypes)\n  }\n  if node.kind == \"expression/array\" {\n    constructor(\"Array\", [element])\n  } else {\n    gateCollectionKey(service, state, moduleIndex, node, element)\n    constructor(\"Set\", [element])\n  }\n}\n\nexport function inferMapLiteralExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  if children(node, \"entries\").length == 0 {\n    match currentExpectedExpression(state, node) {\n      case Some(expected) => if expected.kind == \"constructor\" && expected.name == \"Map\" {\n        return expected\n      }\n      case None => ()\n    }\n    if isBareBindingExpression(state, node) {\n      addDiagnostic(state, moduleIndex, \"TPZ5020\",\n        \"`map \\{\\}` needs a contextual type (§6): annotate the binding or the expected key/value types\", \"\", node)\n    }\n  }\n  let mut keys: Array<TypeValue> = []\n  let mut values: Array<TypeValue> = []\n  let mut constantKeys: Array<string> = []\n  for entry in children(node, \"entries\") {\n    match child(entry, \"key\") {\n      case Some(found) => {\n        if found.kind == \"expression/string\" ||\n          found.kind == \"expression/integer\" ||\n          found.kind == \"expression/bool\" {\n          let key = \"{found.kind}:{text(source, found)}\"\n          if containsString(constantKeys, key) {\n            addDiagnostic(\n              state,\n              moduleIndex,\n              \"TPZ5602\",\n              \"duplicate key in `map \\{ … \\}` literal\",\n              \"\",\n              found,\n            )\n          } else {\n            constantKeys.push(key)\n          }\n        }\n        keys.push(widen(serviceInferExpression(\n          service,\n          state,\n          moduleIndex,\n          source,\n          found,\n        )))\n      }\n      case None => ()\n    }\n    match child(entry, \"value\") {\n      case Some(found) => values.push(widen(serviceInferExpression(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n      )))\n      case None => ()\n    }\n  }\n  let key = unionType(keys)\n  gateCollectionKey(service, state, moduleIndex, node, key)\n  constructor(\"Map\", [key, unionType(values)])\n}\n\nfunction plainRecordDiscriminant(node: SyntaxNode) -> bool {\n  if node.kind == \"expression/integer\" || node.kind == \"expression/float\" ||\n    node.kind == \"expression/null\" || node.kind == \"expression/unit\" ||\n    node.kind == \"expression/boolean\" || node.kind == \"expression/length\" ||\n    node.kind == \"expression/duration\" {\n    return true\n  }\n  if node.kind != \"expression/string\" { return false }\n  for part in node.children {\n    match child(part, \"value\") {\n      case Some(_) => return false\n      case None => ()\n    }\n  }\n  true\n}\n\nfunction recordLiteralMatchesMember(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  member: TypeValue,\n) -> bool {\n  let fields = children(node, \"fields\")\n  if member.kind != \"record\" || member.fieldNames.length != fields.length {\n    return false\n  }\n  for field in fields {\n    let name = match child(field, \"name\") {\n      case Some(found) => text(source, found)\n      case None => return false\n    }\n    let expected = match structuralRecordFieldType(member, name) {\n      case Some(found) => found\n      case None => return false\n    }\n    match child(field, \"value\") {\n      case Some(value) => if plainRecordDiscriminant(value) && typeDecidable(expected) {\n        // Probe only side-effect-free literals, as stage0 narrow_record_literal\n        // does. The selected member's field check owns any diagnostics.\n        let before = state.diagnostics.length\n        let actual = serviceInferExpression(service, state, moduleIndex, source, value)\n        let mut diagnostics = state.diagnostics\n        while diagnostics.length > before { diagnostics.pop() }\n        if typeDecidable(actual) && !typesOverlap(actual, expected) {\n          return false\n        }\n      }\n      case None => ()\n    }\n  }\n  true\n}\n\nfunction narrowedRecordExpectation(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  expected: TypeValue,\n) -> Option<TypeValue> {\n  if expected.kind == \"record\" { return Some(expected) }\n  if expected.kind != \"union\" { return None }\n  let mut chosen: Option<TypeValue> = None\n  for member in expected.members {\n    if recordLiteralMatchesMember(service, state, moduleIndex, source, node, member) {\n      match chosen {\n        case Some(_) => return None\n        case None => { chosen = Some(member) }\n      }\n    }\n  }\n  chosen\n}\n\nexport function inferRecordLiteralExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let mut names: Array<string> = []\n  let mut values: Array<TypeValue> = []\n  // Callable results keep their actual fields for scheme inference and the\n  // caller's final comparison (stage0 infer_result -> record_literal).\n  // Ordinary checking still uses expected fields, as stage0 check_expr does.\n  let expected = match currentExpectedExpression(state, node) {\n    case Some(found) => if currentExpressionChecksResult(state, node) {\n      narrowedRecordExpectation(service, state, moduleIndex, source, node, found)\n    } else { None }\n    case None => None\n  }\n  for field in children(node, \"fields\") {\n    let name = match child(field, \"name\") {\n      case Some(found) => text(source, found)\n      case None => \"\"\n    }\n    let value = match child(field, \"value\") {\n      case Some(found) => match expected {\n        case Some(record) => match structuralRecordFieldType(record, name) {\n          case Some(fieldType) => {\n            let _ = checkExpressionExpected(\n              service,\n              state,\n              moduleIndex,\n              source,\n              found,\n              fieldType,\n            )\n            fieldType\n          }\n          case None => widen(serviceInferExpression(\n            service,\n            state,\n            moduleIndex,\n            source,\n            found,\n          ))\n        }\n        case None => widen(serviceInferExpression(\n          service,\n          state,\n          moduleIndex,\n          source,\n          found,\n        ))\n      }\n      case None => emptyType(\"unknown\")\n    }\n    if containsString(names, name) {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5022\",\n        \"record literal declares field `{name}` twice\",\n        \"\",\n        field,\n      )\n      continue\n    }\n    names.push(name)\n    values.push(value)\n  }\n  structural(names, values)\n}\n\nfunction inferMemberObjectType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  object: SyntaxNode,\n  protocolCall: bool,\n) -> TypeValue {\n  if object.kind != \"expression/identifier\" {\n    return serviceInferExpression(service, state, moduleIndex, source, object)\n  }\n  if builtinNamespaceObject(service, state, moduleIndex, source, object) {\n    return emptyType(\"unknown\")\n  }\n  if protocolCall {\n    match userProtocolObject(state, moduleIndex, source, object) {\n      case Some(_) => return emptyType(\"unknown\")\n      case None => ()\n    }\n  }\n  let typeNamespace = match referenceFor(\n    state,\n    moduleIndex,\n    object.lo,\n    object.hi,\n  ) {\n    case Some(reference) => reference.targetNamespace == \"type\"\n    case None => false\n  }\n  if typeNamespace {\n    match referenceTargetType(state, moduleIndex, object) {\n      case Some(found) => {\n        // A bare record/newtype member reads the head as a value. Constructor\n        // syntax and enum variants have their own paths; a nominal type alone\n        // does not bind a runtime receiver, including through a selected alias.\n        if !protocolCall && (found.kind == \"nominal-record\" || found.kind == \"newtype\") {\n          let name = text(source, object)\n          let hint = match referenceFor(state, moduleIndex, object.lo, object.hi) {\n            case Some(reference) => unboundSuggestion(state, reference)\n            case None => numericMigrationHint(state, name)\n          }\n          addDiagnostic(state, moduleIndex, \"TPZ5002\",\n            \"`{name}` is not bound{hint}\", \"\", object)\n          return emptyType(\"unknown\")\n        }\n        found\n      }\n      case None => serviceInferExpression(service, state, moduleIndex, source, object)\n    }\n  } else {\n    serviceInferExpression(service, state, moduleIndex, source, object)\n  }\n}\n\nexport function contextualMemberObjectType(\n  state: CheckerState,\n  expression: SyntaxNode,\n  objectType: TypeValue,\n) -> TypeValue {\n  match currentExpectedExpression(state, expression) {\n    case Some(expected) => if objectType.kind == \"enum\" &&\n      expected.kind == \"enum\" && objectType.identity == expected.identity {\n      expected\n    } else {\n      objectType\n    }\n    case None => objectType\n  }\n}\n\nrecord MemberAccessContext {\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  object: SyntaxNode,\n  objectType: TypeValue,\n  field: Option<SyntaxNode>,\n  fieldName: string,\n  builtinNamespace: bool,\n  protocolNamespace: string,\n}\n\n// Optional-access carrier retaining both the inner type and wrapper identity.\nexport record OptionalReceiver {\n  innerType: TypeValue,\n  container: string,\n}\n\nexport record OptionalMemberAccess {\n  rawType: TypeValue,\n  wrappedType: TypeValue,\n  receiverType: TypeValue,\n  container: string,\n}\n\nexport function optionalReceiver(objectType: TypeValue) -> Option<OptionalReceiver> {\n  if objectType.kind == \"constructor\" && objectType.name == \"Option\" {\n    return match objectType.arguments.get(0) {\n      case Some(inner) => Some(OptionalReceiver {\n        innerType: inner,\n        container: \"option\",\n      })\n      case None => None\n    }\n  }\n  if objectType.kind != \"union\" {\n    return None\n  }\n  let mut nullable = false\n  let mut innerMembers: Array<TypeValue> = []\n  for member in objectType.members {\n    if member.kind == \"literal\" && member.name == \"null\" {\n      nullable = true\n    } else {\n      innerMembers.push(member)\n    }\n  }\n  if nullable && innerMembers.length > 0 {\n    Some(OptionalReceiver {\n      innerType: unionType(innerMembers),\n      container: \"nullable\",\n    })\n  } else {\n    None\n  }\n}\n\nexport function wrapOptionalResult(rawType: TypeValue, container: string) -> TypeValue {\n  if container == \"\" {\n    return rawType\n  }\n  if hasHole(rawType) {\n    return emptyType(\"unknown\")\n  }\n  if container == \"nullable\" {\n    return unionType([rawType, literal(\"null\", \"\")])\n  }\n  if container == \"option\" {\n    if rawType.kind == \"constructor\" && rawType.name == \"Option\" {\n      return rawType\n    }\n    return constructor(\"Option\", [rawType])\n  }\n  rawType\n}\n\nfunction memberObjectIsNamespace(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  object: SyntaxNode,\n) -> bool {\n  if builtinNamespaceObject(service, state, moduleIndex, source, object) {\n    return true\n  }\n  match userProtocolObject(state, moduleIndex, source, object) {\n    case Some(_) => return true\n    case None => ()\n  }\n  match referenceFor(state, moduleIndex, object.lo, object.hi) {\n    case Some(reference) => reference.targetNamespace == \"type\"\n    case None => false\n  }\n}\n\nfunction memberNameSuggestion(target: string, candidates: Array<string>) -> string {\n  didYouMean(target, candidates)\n}\n\nexport function missingReceiverMemberMessage(\n  state: CheckerState,\n  moduleIndex: int,\n  receiver: TypeValue,\n  member: string,\n  callable: bool,\n) -> string {\n  let receiverName = typeText(widen(receiver))\n  if receiver.kind == \"newtype\" && lengthUnit(receiver) == \"\" {\n    return \"newtype `{receiverName}` has no member named `{member}` (use `.value()` to unwrap the base)\"\n  }\n  let mut names: Array<string> = []\n  if receiver.kind == \"record\" {\n    let mut index = 0\n    for name in receiver.fieldNames {\n      if !callable || match receiver.fields.get(index) {\n        case Some(field) => field.kind == \"function\"\n        case None => false\n      } { names.push(name) }\n      index += 1\n    }\n    return \"`{receiverName}` has no field `{member}`{memberNameSuggestion(member, names)}\"\n  }\n  match recordDefinitionForType(state, moduleIndex, receiver) {\n    case Some(definition) => {\n      for field in definition.fields {\n        let fieldType = substitute(field.typeValue, definition.typeParameters, receiver.arguments)\n        if !callable || fieldType.kind == \"function\" { names.push(field.name) }\n      }\n      return \"record `{receiverName}` has no field `{member}`{memberNameSuggestion(member, names)}\"\n    }\n    case None => ()\n  }\n  for name in opaqueMemberNames(receiver) {\n    let found = memberType(state, moduleIndex, receiver, name)\n    if found.kind != \"unknown\" && (!callable || found.kind == \"function\") {\n      names.push(name)\n    }\n  }\n  \"`{receiverName}` has no member named `{member}`{memberNameSuggestion(member, names)}\"\n}\n\nfunction reportMissingOptionalMember(\n  context: MemberAccessContext,\n  diagnosticNode: SyntaxNode,\n) -> () {\n  if context.fieldName == \"\" { return () }\n  addDiagnostic(\n    context.state,\n    context.moduleIndex,\n    \"TPZ5006\",\n    missingReceiverMemberMessage(context.state, context.moduleIndex, context.objectType, context.fieldName, false),\n    \"\",\n    diagnosticNode,\n  )\n}\n\nexport function inferOptionalMemberAccess(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  diagnosticNode: SyntaxNode,\n) -> OptionalMemberAccess {\n  let objectNode = match child(node, \"object\") {\n    case Some(found) => found\n    case None => node\n  }\n  let objectType = inferMemberObjectType(\n    service,\n    state,\n    moduleIndex,\n    source,\n    objectNode,\n    false,\n  )\n  let namespaceObject = memberObjectIsNamespace(\n    service,\n    state,\n    moduleIndex,\n    source,\n    objectNode,\n  )\n  let receiver = if namespaceObject {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"`?.` needs an Option or nullable receiver, found `namespace`\",\n      \"\",\n      diagnosticNode,\n    )\n    None\n  } else {\n    optionalReceiver(contextualMemberObjectType(\n      state,\n      node,\n      objectType,\n    ))\n  }\n  let unwrapped = match receiver {\n    case Some(found) => found\n    case None => {\n      if !hasHole(objectType) && !namespaceObject {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5001\",\n          \"`?.` needs an Option or nullable receiver, found `{typeText(widen(objectType))}`\",\n          \"\",\n          diagnosticNode,\n        )\n      }\n      return OptionalMemberAccess {\n        rawType: emptyType(\"unknown\"),\n        wrappedType: emptyType(\"unknown\"),\n        receiverType: emptyType(\"unknown\"),\n        container: \"\",\n      }\n    }\n  }\n  let fieldNode = child(node, \"field\")\n  let fieldName = match fieldNode {\n    case Some(found) => text(source, found)\n    case None => \"\"\n  }\n  let context = MemberAccessContext {\n    state: state,\n    moduleIndex: moduleIndex,\n    source: source,\n    object: objectNode,\n    objectType: unwrapped.innerType,\n    field: fieldNode,\n    fieldName: fieldName,\n    builtinNamespace: false,\n    protocolNamespace: \"\",\n  }\n  let found = resolvedMemberAccessType(context)\n  if (found.kind == \"unknown\" && !hasHole(unwrapped.innerType) ||\n    rigidUnionMissingConcreteMember(\n      state,\n      moduleIndex,\n      unwrapped.innerType,\n      fieldName,\n    )) && fieldName != \"\" {\n    reportMissingOptionalMember(context, diagnosticNode)\n  }\n  OptionalMemberAccess {\n    rawType: found,\n    wrappedType: wrapOptionalResult(found, unwrapped.container),\n    receiverType: unwrapped.innerType,\n    container: unwrapped.container,\n  }\n}\n\nfunction fallbackMemberAccessType(context: MemberAccessContext) -> TypeValue {\n  if context.builtinNamespace {\n    let namespace = text(context.source, context.object)\n    match builtinNamespaceMemberType(namespace, context.fieldName, context.state.languageMode) {\n      case Some(found) => return found\n      case None => ()\n    }\n    match protocolStaticMemberType(namespace, context.fieldName) {\n      case Some(found) => return found\n      case None => return emptyType(\"unknown\")\n    }\n  }\n  if context.protocolNamespace != \"\" {\n    match protocolDefinition(\n      context.state,\n      context.moduleIndex,\n      context.protocolNamespace,\n    ) {\n      case Some(definition) => match protocolMethodDefinition(\n        definition,\n        context.fieldName,\n      ) {\n        case Some(method) => return method.typeValue\n        case None => return emptyType(\"unknown\")\n      }\n      case None => return emptyType(\"unknown\")\n    }\n  }\n  memberType(\n    context.state,\n    context.moduleIndex,\n    context.objectType,\n    context.fieldName,\n  )\n}\n\nfunction resolvedMemberAccessType(context: MemberAccessContext) -> TypeValue {\n  if context.objectType.kind == \"enum\" {\n    return if nominalTypeHead(context.state, context.moduleIndex, context.object) {\n      enumVariantType(context.state, context.moduleIndex, context.objectType, context.fieldName)\n    } else {\n      emptyType(\"unknown\")\n    }\n  }\n  match context.field {\n    case Some(fieldNode) => match referenceTargetType(\n      context.state,\n      context.moduleIndex,\n      fieldNode,\n    ) {\n      case Some(resolved) => if resolved.kind != \"unknown\" {\n        resolved\n      } else {\n        fallbackMemberAccessType(context)\n      }\n      case None => fallbackMemberAccessType(context)\n    }\n    case None => memberType(\n      context.state,\n      context.moduleIndex,\n      context.objectType,\n      context.fieldName,\n    )\n  }\n}\n\nfunction reportMissingMember(context: MemberAccessContext, diagnosticNode: SyntaxNode, callable: bool) -> () {\n  if context.fieldName == \"\" {\n    return ()\n  }\n  if context.protocolNamespace != \"\" {\n    match context.field {\n      case Some(fieldNode) => addDiagnostic(\n        context.state,\n        context.moduleIndex,\n        \"TPZ5522\",\n        \"protocol `{context.protocolNamespace}` has no method `{context.fieldName}`\",\n        \"\",\n        fieldNode,\n      )\n      case None => ()\n    }\n    return ()\n  }\n  let receiverName = if context.builtinNamespace {\n    text(context.source, context.object)\n  } else {\n    typeText(widen(context.objectType))\n  }\n  match context.field {\n    case Some(fieldNode) => addDiagnostic(\n      context.state,\n      context.moduleIndex,\n      \"TPZ5006\",\n      if context.builtinNamespace {\n        \"`{receiverName}` has no member named `{context.fieldName}`\"\n      } else {\n        missingReceiverMemberMessage(context.state, context.moduleIndex, context.objectType, context.fieldName, callable)\n      },\n      \"\",\n      if context.builtinNamespace { fieldNode } else { diagnosticNode },\n    )\n    case None => ()\n  }\n}\n\n// Member lookup result before the caller records the expression observation.\nexport record PlainMemberAccess {\n  memberType: TypeValue,\n  receiverType: TypeValue,\n}\n\nexport function inferPlainMemberAccess(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  resultExpression: SyntaxNode,\n  protocolCall: bool,\n) -> PlainMemberAccess {\n  if rejectQualifiedNominalValue(state, moduleIndex, source, node) {\n    return PlainMemberAccess {\n      memberType: emptyType(\"unknown\"),\n      receiverType: emptyType(\"unknown\"),\n    }\n  }\n  let objectNode = match child(node, \"object\") {\n    case Some(found) => found\n    case None => node\n  }\n  let objectType = inferMemberObjectType(\n    service,\n    state,\n    moduleIndex,\n    source,\n    objectNode,\n    protocolCall,\n  )\n  let fieldNode = child(node, \"field\")\n  let fieldName = match fieldNode {\n    case Some(found) => text(source, found)\n    case None => \"\"\n  }\n  let builtinNamespaceObjectValue = builtinNamespaceObject(\n    service,\n    state,\n    moduleIndex,\n    source,\n    objectNode,\n  )\n  let protocolNamespace = if protocolCall {\n    match userProtocolObject(state, moduleIndex, source, objectNode) {\n      case Some(definition) => definition.name\n      case None => \"\"\n    }\n  } else {\n    \"\"\n  }\n  let context = MemberAccessContext {\n    state: state,\n    moduleIndex: moduleIndex,\n    source: source,\n    object: objectNode,\n    // A constructor callee takes its enum arguments from the enclosing call's\n    // result expectation; a bare variant takes them from the member itself.\n    objectType: contextualMemberObjectType(\n      state,\n      resultExpression,\n      objectType,\n    ),\n    field: fieldNode,\n    fieldName: fieldName,\n    builtinNamespace: builtinNamespaceObjectValue,\n    protocolNamespace: protocolNamespace,\n  }\n  if !builtinNamespaceObjectValue && builtinMutator(objectType, fieldName) &&\n    match fieldNode {\n      case Some(field) => match referenceTargetType(\n        state,\n        moduleIndex,\n        field,\n      ) {\n        case Some(_) => false\n        case None => true\n      }\n      case None => false\n  } {\n    checkAssignmentRootMutable(state, moduleIndex, source, objectNode, true)\n  }\n  let found = if protocolCall {\n    match receiverMethodType(\n      state,\n      moduleIndex,\n      context.objectType,\n      fieldName,\n    ) {\n      case Some(methodType) => methodType\n      case None => resolvedMemberAccessType(context)\n    }\n  } else {\n    resolvedMemberAccessType(context)\n  }\n  if (found.kind == \"unknown\" &&\n    (builtinNamespaceObjectValue || protocolNamespace != \"\" ||\n      !hasHole(objectType)) ||\n    rigidUnionMissingConcreteMember(\n      state,\n      moduleIndex,\n      objectType,\n      fieldName,\n    )) &&\n    fieldName != \"\" {\n    // Rust diagnoses a direct member callee on its field, including pipe calls.\n    // Reading the member as a value diagnoses the whole member expression.\n    let diagnosticNode = if protocolCall {\n      match fieldNode { case Some(field) => field; case None => node }\n    } else {\n      node\n    }\n    reportMissingMember(\n      MemberAccessContext { ...context, objectType: objectType },\n      diagnosticNode,\n      protocolCall,\n    )\n  }\n  PlainMemberAccess {\n    memberType: found,\n    receiverType: context.objectType,\n  }\n}\n\nexport function inferMemberAccessExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  if reportRemovedStaticMember(state, moduleIndex, source, node) {\n    return emptyType(\"unknown\")\n  }\n  if node.kind == \"expression/optional-access\" {\n    return inferOptionalMemberAccess(\n      service,\n      state,\n      moduleIndex,\n      source,\n      node,\n      node,\n    ).wrappedType\n  }\n  match child(node, \"object\") {\n    case Some(object) => if builtinNamespaceObject(\n      service, state, moduleIndex, source, object) {\n      let member = match child(node, \"field\") {\n        case Some(field) => text(source, field)\n        case None => \"\"\n      }\n      let staticValue = match builtinNamespaceMemberType(text(source, object), member, state.languageMode) {\n        case Some(value) => value.kind == \"rounding-mode\"\n        case None => false\n      }\n      // Builtin namespace functions are direct-call targets. Reading one as\n      // a value must diagnose the unbound namespace, as ordinary inference does.\n      if !staticValue {\n        serviceInferExpression(service, state, moduleIndex, source, object)\n        return emptyType(\"unknown\")\n      }\n    }\n    case None => ()\n  }\n  inferPlainMemberAccess(service, state, moduleIndex, source, node, node, false).memberType\n}\n\nrecord RecordUpdateContext {\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n  constructorName: string,\n}\n\n// Records and newtypes take a namespace qualifier only in type position\n// (§3/§17), so a qualified one in value position names no exported value.\nfunction rejectQualifiedNominalValue(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> bool {\n  if node.kind != \"expression/member\" {\n    return false\n  }\n  let object = match child(node, \"object\") {\n    case Some(found) => found\n    case None => return false\n  }\n  if object.kind != \"expression/identifier\" {\n    return false\n  }\n  let field = match child(node, \"field\") {\n    case Some(found) => found\n    case None => return false\n  }\n  let reference = match state.referenceIndexes.get(spanKey(moduleIndex, field.lo, field.hi)) {\n    case Some(index) => match state.resolved.references.get(index) {\n      case Some(found) => found\n      case None => return false\n    }\n    case None => return false\n  }\n  if reference.role != \"namespace-member\" || reference.targetNamespace != \"type\" {\n    return false\n  }\n  let kind = match referenceTargetType(state, moduleIndex, field) {\n    case Some(found) => found.kind\n    case None => return false\n  }\n  if kind != \"nominal-record\" && kind != \"newtype\" {\n    return false\n  }\n  let member = text(source, field)\n  let mut exported: Array<string> = []\n  match state.valueDeclarationIndexesByModule.get(\"{reference.targetModuleIndex}\") {\n    case Some(indexes) => for index in indexes {\n      match state.resolved.declarations.get(index) {\n        case Some(declaration) => if declaration.exported && declaration.namespace == \"value\" {\n          exported.push(declaration.name)\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  addDiagnostic(\n    state,\n    moduleIndex,\n    \"TPZ5002\",\n    \"`{member}` is not exported by the module bound as `{text(source, object)}` (§17){didYouMean(member, exported)}\",\n    \"\",\n    field,\n  )\n  true\n}\n\nexport function checkNominalConstructionContext(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  value: TypeValue,\n) -> bool {\n  let count = if value.kind == \"nominal-record\" {\n    match recordDefinitionForType(state, moduleIndex, value) {\n      case Some(definition) => definition.typeParameters.length\n      case None => 0\n    }\n  } else if value.kind == \"enum\" {\n    match enumDefinitionForType(state, moduleIndex, value) {\n      case Some(definition) => definition.typeParameters.length\n      case None => 0\n    }\n  } else if value.kind == \"newtype\" {\n    match newtypeDefinitionForType(state, moduleIndex, value) {\n      case Some(definition) => definition.typeParameters.length\n      case None => 0\n    }\n  } else { 0 }\n  if count == 0 { return false }\n  match currentExpectedExpression(state, node) {\n    case Some(expected) => if expected.kind == value.kind && expected.identity == value.identity &&\n      expected.origin == value.origin && expected.arguments.length == count {\n      return false\n    }\n    case None => ()\n  }\n  let kind = if value.kind == \"nominal-record\" { \"record\" } else { value.kind }\n  addTypeArgumentArityDiagnostic(state, moduleIndex, \"{kind} `{value.identity}`\", count, 0, node)\n  true\n}\n\nrecord RecordFieldExpectation {\n  shapeKnown: bool,\n  typeValue: Option<TypeValue>,\n}\n\nfunction inferRecordUpdateBase(\n  service: CheckerService,\n  context: RecordUpdateContext,\n  baseNode: SyntaxNode,\n) -> TypeValue {\n  if baseNode.kind != \"expression/identifier\" && baseNode.kind != \"expression/member\" {\n    return serviceInferExpression(\n      service,\n      context.state,\n      context.moduleIndex,\n      context.source,\n      baseNode,\n    )\n  }\n  if rejectQualifiedNominalValue(context.state, context.moduleIndex, context.source, baseNode) {\n    return emptyType(\"unknown\")\n  }\n  match referenceTargetType(context.state, context.moduleIndex, baseNode) {\n    case Some(typeValue) => {\n      match referenceFor(\n        context.state,\n        context.moduleIndex,\n        baseNode.lo,\n        baseNode.hi,\n      ) {\n        case Some(reference) => if reference.targetNamespace == \"value\" {\n          addNode(\n            context.state,\n            context.moduleIndex,\n            \"expression\",\n            baseNode,\n            typeValue,\n          )\n        } else {\n          ()\n        }\n        case None => ()\n      }\n      typeValue\n    }\n    case None => serviceInferExpression(\n      service,\n      context.state,\n      context.moduleIndex,\n      context.source,\n      baseNode,\n    )\n  }\n}\n\nfunction contextualRecordUpdateBase(\n  context: RecordUpdateContext,\n  baseNode: SyntaxNode,\n  baseType: TypeValue,\n) -> TypeValue {\n  let contextualExpected = currentExpectedExpression(\n    context.state,\n    context.expression,\n  )\n  // Context can supply arguments only for this declaration. Equal spellings in\n  // separate modules must not replace the constructor's nominal origin.\n  match contextualExpected {\n    case Some(expected) => if baseType.kind == \"nominal-record\" &&\n    expected.kind == \"nominal-record\" &&\n    baseType.identity == expected.identity &&\n    baseType.origin == expected.origin {\n      expected\n    } else {\n      baseType\n    }\n    case None => baseType\n  }\n}\n\nfunction recordUpdateConstructorName(\n  context: RecordUpdateContext,\n  baseNode: SyntaxNode,\n  baseType: TypeValue,\n) -> string {\n  if baseNode.kind != \"expression/identifier\" {\n    return \"\"\n  }\n  match referenceFor(\n    context.state,\n    context.moduleIndex,\n    baseNode.lo,\n    baseNode.hi,\n  ) {\n    case Some(reference) => if reference.targetNamespace == \"type\" {\n      match recordDefinitionForType(\n        context.state,\n        context.moduleIndex,\n        baseType,\n      ) {\n        case Some(_) => text(context.source, baseNode)\n        case None => \"\"\n      }\n    } else {\n      \"\"\n    }\n    case None => \"\"\n  }\n}\n\nfunction structuralRecordFieldType(\n  baseType: TypeValue,\n  fieldName: string,\n) -> Option<TypeValue> {\n  let mut index = 0\n  while index < baseType.fieldNames.length {\n    match baseType.fieldNames.get(index) {\n      case Some(name) => if name == fieldName {\n        return baseType.fields.get(index)\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  None\n}\n\nfunction recordUpdateFieldExpectation(\n  context: RecordUpdateContext,\n  baseType: TypeValue,\n  fieldName: string,\n) -> RecordFieldExpectation {\n  match recordDefinitionForType(\n    context.state,\n    context.moduleIndex,\n    baseType,\n  ) {\n    case Some(definition) => for declared in definition.fields {\n      if declared.name == fieldName {\n        return RecordFieldExpectation {\n          shapeKnown: true,\n          typeValue: Some(substitute(\n            declared.typeValue,\n            definition.typeParameters,\n            baseType.arguments,\n          )),\n        }\n      }\n    }\n    case None => ()\n  }\n  if baseType.kind == \"record\" {\n    return RecordFieldExpectation {\n      shapeKnown: true,\n      typeValue: structuralRecordFieldType(baseType, fieldName),\n    }\n  }\n  let nominalShapeKnown = match recordDefinitionForType(\n    context.state,\n    context.moduleIndex,\n    baseType,\n  ) {\n    case Some(_) => true\n    case None => false\n  }\n  RecordFieldExpectation {\n    shapeKnown: nominalShapeKnown,\n    typeValue: None,\n  }\n}\n\nfunction inferRecordFieldValue(\n  service: CheckerService,\n  context: RecordUpdateContext,\n  value: SyntaxNode,\n  expected: Option<TypeValue>,\n  checkExpected: bool,\n) -> () {\n  match expected {\n    case Some(expectedType) => if checkExpected &&\n      value.kind == \"expression/array\" &&\n      value.children.length == 0 &&\n      expectedType.kind == \"constructor\" &&\n      expectedType.name == \"Array\" {\n      addNode(\n        context.state,\n        context.moduleIndex,\n        \"expression\",\n        value,\n        expectedType,\n      )\n    } else if checkExpected && !hasHole(expectedType) {\n      let _ = checkExpressionExpected(\n        service,\n        context.state,\n        context.moduleIndex,\n        context.source,\n        value,\n        expectedType,\n      )\n    } else {\n      let _ = serviceInferExpression(\n        service,\n        context.state,\n        context.moduleIndex,\n        context.source,\n        value,\n      )\n    }\n    case None => {\n      let _ = serviceInferExpression(\n        service,\n        context.state,\n        context.moduleIndex,\n        context.source,\n        value,\n      )\n    }\n  }\n}\n\nfunction recordFieldName(context: RecordUpdateContext, field: SyntaxNode) -> string {\n  match child(field, \"name\") {\n    case Some(found) => text(context.source, found)\n    case None => \"\"\n  }\n}\n\nfunction stringArrayContains(values: Array<string>, target: string) -> bool {\n  for value in values {\n    if value == target { return true }\n  }\n  false\n}\n\nfunction laterRecordFieldHasName(\n  context: RecordUpdateContext,\n  fields: Array<SyntaxNode>,\n  index: int,\n  fieldName: string,\n) -> bool {\n  let mut later = index + 1\n  while later < fields.length {\n    match fields.get(later) {\n      case Some(field) => if recordFieldName(context, field) == fieldName {\n        return true\n      }\n      case None => ()\n    }\n    later += 1\n  }\n  false\n}\n\nfunction reportMissingRecordField(\n  context: RecordUpdateContext,\n  baseType: TypeValue,\n  field: SyntaxNode,\n  fieldName: string,\n) -> () {\n  let owner = if context.constructorName != \"\" {\n    \"record `{context.constructorName}`\"\n  } else {\n    \"`{typeText(widen(baseType))}`\"\n  }\n  addDiagnostic(\n    context.state,\n    context.moduleIndex,\n    \"TPZ5006\",\n    \"{owner} has no field `{fieldName}`\",\n    \"\",\n    field,\n  )\n}\n\nfunction inferRecordUpdateField(\n  service: CheckerService,\n  context: RecordUpdateContext,\n  baseType: TypeValue,\n  field: SyntaxNode,\n  checkExpected: bool,\n  duplicate: bool,\n) -> () {\n  let fieldName = recordFieldName(context, field)\n  let expectation = recordUpdateFieldExpectation(context, baseType, fieldName)\n  if duplicate {\n    addDiagnostic(\n      context.state,\n      context.moduleIndex,\n      \"TPZ5008\",\n      \"field `{fieldName}` is given twice in `{context.constructorName}`\",\n      \"\",\n      field,\n    )\n  }\n  if expectation.shapeKnown && match expectation.typeValue {\n    case Some(_) => false\n    case None => true\n  } {\n    reportMissingRecordField(context, baseType, field, fieldName)\n  }\n  match child(field, \"value\") {\n    case Some(value) => inferRecordFieldValue(\n      service,\n      context,\n      value,\n      expectation.typeValue,\n      checkExpected && !duplicate,\n    )\n    case None => ()\n  }\n}\n\nfunction inferRecordUpdateFields(\n  service: CheckerService,\n  context: RecordUpdateContext,\n  baseType: TypeValue,\n  fields: Array<SyntaxNode>,\n) -> () {\n  let mut seen: Array<string> = []\n  let mut index = 0\n  for field in fields {\n    let fieldName = recordFieldName(context, field)\n    let duplicate = context.constructorName != \"\" &&\n      stringArrayContains(seen, fieldName)\n    let checkExpected = context.constructorName != \"\" ||\n      !laterRecordFieldHasName(context, fields, index, fieldName)\n    inferRecordUpdateField(\n      service,\n      context,\n      baseType,\n      field,\n      checkExpected,\n      duplicate,\n    )\n    seen.push(fieldName)\n    index += 1\n  }\n  ()\n}\n\nfunction inferRecordUpdateSpread(\n  service: CheckerService,\n  context: RecordUpdateContext,\n  baseNode: SyntaxNode,\n  baseType: TypeValue,\n  spread: Option<SyntaxNode>,\n) -> bool {\n  match spread {\n    case Some(value) => {\n      if context.constructorName != \"\" {\n        let _ = checkExpressionExpected(\n          service,\n          context.state,\n          context.moduleIndex,\n          context.source,\n          value,\n          baseType,\n        )\n      } else {\n        let _ = serviceInferExpression(\n          service,\n          context.state,\n          context.moduleIndex,\n          context.source,\n          value,\n        )\n        addDiagnostic(\n          context.state,\n          context.moduleIndex,\n          \"TPZ5001\",\n          \"record spread `...` needs a declared record; `{text(context.source, baseNode)}` is not one\",\n          \"\",\n          value,\n        )\n      }\n      true\n    }\n    case None => false\n  }\n}\n\nfunction reportMissingRecordConstructionFields(\n  context: RecordUpdateContext,\n  baseType: TypeValue,\n  fields: Array<SyntaxNode>,\n  hasSpread: bool,\n  node: SyntaxNode,\n) -> () {\n  if context.constructorName == \"\" || hasSpread {\n    return ()\n  }\n  let definition = match recordDefinitionForType(\n    context.state,\n    context.moduleIndex,\n    baseType,\n  ) {\n    case Some(found) => found\n    case None => return ()\n  }\n  let mut supplied: Array<string> = []\n  for field in fields {\n    supplied.push(recordFieldName(context, field))\n  }\n  let mut count = 0\n  let mut names = \"\"\n  for declared in definition.fields {\n    if !declared.hasDefault && !stringArrayContains(supplied, declared.name) {\n      if count > 0 { names += \", \" }\n      names += \"`{declared.name}`\"\n      count += 1\n    }\n  }\n  if count > 0 {\n    let suffix = if count == 1 { \"\" } else { \"s\" }\n    addDiagnostic(\n      context.state,\n      context.moduleIndex,\n      \"TPZ5004\",\n      \"record `{context.constructorName}` is missing field{suffix} {names}\",\n      \"\",\n      node,\n    )\n  }\n}\n\nfunction checkedRecordUpdateResult(\n  context: RecordUpdateContext,\n  baseNode: SyntaxNode,\n  baseType: TypeValue,\n) -> TypeValue {\n  if context.constructorName != \"\" ||\n    baseType.kind == \"record\" ||\n    baseType.kind == \"rigid\" ||\n    baseType.kind == \"union\" ||\n    hasHole(baseType) {\n    return baseType\n  }\n  addDiagnostic(\n    context.state,\n    context.moduleIndex,\n    \"TPZ5001\",\n    \"record update needs a record, found `{typeText(widen(baseType))}`\",\n    \"\",\n    baseNode,\n  )\n  emptyType(\"unknown\")\n}\n\nexport function inferRecordUpdateExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> TypeValue {\n  let baseContext = RecordUpdateContext {\n    state: state,\n    moduleIndex: moduleIndex,\n    source: source,\n    expression: node,\n    constructorName: \"\",\n  }\n  let baseNode = match child(node, \"base\") {\n    case Some(found) => found\n    case None => return emptyType(\"unknown\")\n  }\n  let inferredBase = contextualRecordUpdateBase(\n    baseContext,\n    baseNode,\n    inferRecordUpdateBase(service, baseContext, baseNode),\n  )\n  let context = RecordUpdateContext {\n    ...baseContext,\n    constructorName: recordUpdateConstructorName(\n      baseContext,\n      baseNode,\n      inferredBase,\n    ),\n  }\n  let base = if context.constructorName != \"\" &&\n    checkNominalConstructionContext(state, moduleIndex, node, inferredBase) {\n    emptyType(\"unknown\")\n  } else { checkedRecordUpdateResult(context, baseNode, inferredBase) }\n  let fields = children(node, \"fields\")\n  let hasSpread = inferRecordUpdateSpread(\n    service,\n    context,\n    baseNode,\n    base,\n    child(node, \"spread\"),\n  )\n  inferRecordUpdateFields(service, context, base, fields)\n  reportMissingRecordConstructionFields(\n    context,\n    base,\n    fields,\n    hasSpread,\n    node,\n  )\n  base\n}\n\nfunction assignmentRoot(node: SyntaxNode) -> Option<SyntaxNode> {\n  if node.kind == \"expression/identifier\" {\n    return Some(node)\n  }\n  match child(node, \"object\") {\n    case Some(object) => assignmentRoot(object)\n    case None => None\n  }\n}\n\nexport function checkAssignmentRootMutable(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  target: SyntaxNode,\n  collectionMutation: bool,\n) -> () {\n  match assignmentRoot(target) {\n    case Some(root) => match referenceFor(\n      state,\n      moduleIndex,\n      root.lo,\n      root.hi,\n    ) {\n      case Some(reference) => match symbolAt(\n        state,\n        reference.targetModuleIndex,\n        reference.targetLo,\n        reference.targetHi,\n      ) {\n        case Some(symbol) => if !symbol.mutable {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5003\",\n            if collectionMutation {\n              \"`{text(source, root)}` is not `let mut`; in-place collection mutation requires a mutable binding (§9)\"\n            } else {\n              \"`{text(source, root)}` is immutable; declare it with `let mut`\"\n            },\n            \"\",\n            root,\n          )\n        } else {\n          ()\n        }\n        case None => ()\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n}\n",
      "sourceSha256": "3503e9e45f89b2c78f7811498baa1e159f93d01fd0abf50c74fb5fc8846dde06"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/members_capabilities.tpz",
      "language": "topaz",
      "bytes": 68918,
      "sha256": "1e7a01fb79246f255444948f7e4a595d2118a3e30f2994821aa4c6346690bbc9",
      "content": "import checker.builtin_signatures { builtinNamespaceFamily, stringElementType }\n// Member catalogs and capability rules for nominal and builtin types.\n// Formation supplies declared shapes; expression and call inference consume the\n// resolved member and Eq, Order, JSON, iterable, and key decisions.\n\nimport types { SyntaxNode }\nimport checker_types { TypeValue }\nimport checker.model {\n  CheckerService,\n  CheckerState,\n  FunctionDefinition,\n  TypeBinding,\n  constructor,\n  emptyType,\n  functionType,\n  inference,\n  literal,\n  nominal,\n  lengthType,\n  lengthUnit,\n  primitive,\n  rigid,\n  serviceBuiltinNamespaceObject,\n  structural,\n}\nimport checker.type_algebra {\n  hasHole,\n  transformTypeComponents,\n  typeContains,\n  typeEqual,\n  typeListText,\n  typeText,\n  unionType,\n  widen,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  child,\n  children,\n  containsString,\n  moduleIdentityAt,\n  protocolMethodDefinition,\n  text,\n}\nimport checker.nominals { substitute }\nimport checker.protocols_methods {\n  builtinProtocolDefinition,\n  enumDefinitionForType,\n  newtypeDefinitionForType,\n  protocolConformanceIndex,\n  receiverMethodType,\n  recordDefinitionForType,\n}\n\nexport function iterableElement(value: TypeValue) -> TypeValue {\n  if value.kind == \"constructor\" &&\n    (value.name == \"Array\" || value.name == \"Set\" || value.name == \"Range\") {\n    return match value.arguments.get(0) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n  }\n  if value.kind == \"rigid\" || value.kind == \"foreign\" {\n    return rigid(\"ElemOf<{typeText(value)}>\", \"builtin::iterable\")\n  }\n  emptyType(\"unknown\")\n}\n\nexport record ArraySpreadElement {\n  status: string,\n  element: TypeValue,\n}\n\nexport function arraySpreadElement(value: TypeValue) -> ArraySpreadElement {\n  if value.kind == \"constructor\" && value.name == \"Array\" {\n    return ArraySpreadElement {\n      status: \"element\",\n      element: match value.arguments.get(0) {\n        case Some(found) => found\n        case None => emptyType(\"unknown\")\n      },\n    }\n  }\n  if value.kind == \"rigid\" || value.kind == \"foreign\" {\n    return ArraySpreadElement {\n      status: \"element\",\n      element: rigid(\"ElemOf<{typeText(value)}>\", \"builtin::array-spread\"),\n    }\n  }\n  if value.kind == \"union\" {\n    let mut elements: Array<TypeValue> = []\n    let mut staged = false\n    for member in value.members {\n      let spread = arraySpreadElement(member)\n      if spread.status == \"invalid\" {\n        return spread\n      }\n      if spread.status == \"stage\" {\n        staged = true\n      } else {\n        elements.push(spread.element)\n      }\n    }\n    return if staged {\n      ArraySpreadElement {\n        status: \"stage\",\n        element: emptyType(\"unknown\"),\n      }\n    } else {\n      ArraySpreadElement {\n        status: \"element\",\n        element: unionType(elements),\n      }\n    }\n  }\n  if hasHole(value) {\n    ArraySpreadElement {\n      status: \"stage\",\n      element: emptyType(\"unknown\"),\n    }\n  } else {\n    ArraySpreadElement {\n      status: \"invalid\",\n      element: emptyType(\"unknown\"),\n    }\n  }\n}\n\nrecord KeyCapabilityFailure {\n  subject: string,\n  kind: string,\n}\n\nexport function capabilityPath(seen: Array<string>, key: string) -> Array<string> {\n  let mut nested: Array<string> = []\n  for item in seen {\n    nested.push(item)\n  }\n  nested.push(key)\n  nested\n}\n\nexport function nominalCapabilityKey(value: TypeValue) -> string {\n  \"{value.kind}:{value.origin}:{value.identity}<{typeListText(value.arguments)}>\"\n}\n\nrecord NominalCapabilityProjection {\n  moduleIndex: int,\n  children: Array<TypeValue>,\n}\n\nfunction nominalCapabilityType(value: TypeValue) -> bool {\n  value.kind == \"nominal-record\" || value.kind == \"enum\" ||\n    value.kind == \"newtype\"\n}\n\nfunction nominalCapabilityProjection(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n) -> NominalCapabilityProjection {\n  let mut children: Array<TypeValue> = []\n  if value.kind == \"nominal-record\" {\n    return match recordDefinitionForType(state, moduleIndex, value) {\n      case Some(definition) => {\n        for field in definition.fields {\n          children.push(substitute(\n            field.typeValue,\n            definition.typeParameters,\n            value.arguments,\n          ))\n        }\n        NominalCapabilityProjection {\n          moduleIndex: definition.moduleIndex,\n          children: children,\n        }\n      }\n      case None => NominalCapabilityProjection {\n        moduleIndex: moduleIndex,\n        children: children,\n      }\n    }\n  }\n  if value.kind == \"enum\" {\n    return match enumDefinitionForType(state, moduleIndex, value) {\n      case Some(definition) => {\n        for variant in definition.variants {\n          for payload in variant.payloads {\n            children.push(substitute(\n              payload,\n              definition.typeParameters,\n              value.arguments,\n            ))\n          }\n        }\n        NominalCapabilityProjection {\n          moduleIndex: definition.moduleIndex,\n          children: children,\n        }\n      }\n      case None => NominalCapabilityProjection {\n        moduleIndex: moduleIndex,\n        children: children,\n      }\n    }\n  }\n  match newtypeDefinitionForType(state, moduleIndex, value) {\n    case Some(definition) => {\n      children.push(substitute(\n        definition.base,\n        definition.typeParameters,\n        value.arguments,\n      ))\n      NominalCapabilityProjection {\n        moduleIndex: definition.moduleIndex,\n        children: children,\n      }\n    }\n    case None => NominalCapabilityProjection {\n      moduleIndex: moduleIndex,\n      children: children,\n    }\n  }\n}\n\nexport function containsByteBuffer(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  seen: Array<string>,\n) -> bool {\n  let widened = widen(value)\n  if widened.kind == \"byte-buffer\" {\n    return true\n  }\n  if widened.kind == \"function\" {\n    return false\n  }\n  if widened.kind == \"constructor\" || widened.kind == \"foreign\" {\n    for argument in widened.arguments {\n      if containsByteBuffer(state, moduleIndex, argument, seen) {\n        return true\n      }\n    }\n    return false\n  }\n  if widened.kind == \"record\" {\n    for field in widened.fields {\n      if containsByteBuffer(state, moduleIndex, field, seen) {\n        return true\n      }\n    }\n    return false\n  }\n  if widened.kind == \"union\" {\n    for member in widened.members {\n      if containsByteBuffer(state, moduleIndex, member, seen) {\n        return true\n      }\n    }\n    return false\n  }\n  if nominalCapabilityType(widened) {\n    for argument in widened.arguments {\n      if containsByteBuffer(state, moduleIndex, argument, seen) {\n        return true\n      }\n    }\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return false\n    }\n    let projection = nominalCapabilityProjection(state, moduleIndex, widened)\n    let nested = capabilityPath(seen, key)\n    for child in projection.children {\n      if containsByteBuffer(\n        state,\n        projection.moduleIndex,\n        child,\n        nested,\n      ) {\n        return true\n      }\n    }\n    return false\n  }\n  false\n}\n\nexport function comparableType(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  seen: Array<string>,\n) -> bool {\n  let widened = widen(value)\n  if widened.kind == \"template\" || widened.kind == \"file\" ||\n    widened.kind == \"json-value\" || widened.kind == \"toml-value\" ||\n    widened.kind == \"function\" || widened.kind == \"byte-buffer\" ||\n    widened.kind == \"regex\" {\n    return false\n  }\n  if widened.kind == \"constructor\" {\n    if widened.name == \"Map\" || widened.name == \"Set\" {\n      return false\n    }\n    for argument in widened.arguments {\n      if !comparableType(state, moduleIndex, argument, seen) {\n        return false\n      }\n    }\n    return true\n  }\n  if widened.kind == \"record\" {\n    for field in widened.fields {\n      if !comparableType(state, moduleIndex, field, seen) {\n        return false\n      }\n    }\n    return true\n  }\n  if widened.kind == \"union\" {\n    for member in widened.members {\n      if !comparableType(state, moduleIndex, member, seen) {\n        return false\n      }\n    }\n    return true\n  }\n  if nominalCapabilityType(widened) {\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return true\n    }\n    let projection = nominalCapabilityProjection(state, moduleIndex, widened)\n    let nested = capabilityPath(seen, key)\n    for child in projection.children {\n      if !comparableType(\n        state,\n        projection.moduleIndex,\n        child,\n        nested,\n      ) {\n        return false\n      }\n    }\n    return true\n  }\n  true\n}\n\nfunction capabilityAnd(left: string, right: string) -> string {\n  if left == \"reject\" || right == \"reject\" {\n    \"reject\"\n  } else if left == \"defer\" || right == \"defer\" {\n    \"defer\"\n  } else {\n    \"accept\"\n  }\n}\n\nexport function orderCapability(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  seen: Array<string>,\n) -> string {\n  let widened = widen(value)\n  if lengthUnit(widened) != \"\" { return \"accept\" }\n  if widened.kind == \"primitive\" {\n    return if widened.name == \"int\" || widened.name == \"float\" ||\n      widened.name == \"string\" {\n      \"accept\"\n    } else {\n      \"reject\"\n    }\n  }\n  if widened.kind == \"literal\" {\n    return if widened.name == \"int\" || widened.name == \"float\" ||\n      widened.name == \"string\" {\n      \"accept\"\n    } else {\n      \"reject\"\n    }\n  }\n  if widened.kind == \"bytes\" || widened.kind == \"path\" ||\n    widened.kind == \"url\" || widened.kind == \"date\" ||\n    widened.kind == \"big-int\" || widened.kind == \"decimal\" {\n    return \"accept\"\n  }\n  if widened.kind == \"inference-variable\" {\n    return \"defer\"\n  }\n  if nominalCapabilityType(widened) {\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return \"accept\"\n    }\n    let mut status = \"accept\"\n    let projection = nominalCapabilityProjection(state, moduleIndex, widened)\n    let nested = capabilityPath(seen, key)\n    for child in projection.children {\n      status = capabilityAnd(status, orderCapability(\n        state,\n        projection.moduleIndex,\n        child,\n        nested,\n      ))\n    }\n    return status\n  }\n  \"reject\"\n}\n\nexport function jsonCapability(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  seen: Array<string>,\n  decoding: bool,\n) -> string {\n  let widened = widen(value)\n  if lengthUnit(widened) != \"\" { return \"reject\" }\n  if widened.kind == \"primitive\" {\n    return if widened.name == \"int\" || widened.name == \"bool\" ||\n      widened.name == \"string\" || widened.name == \"unit\" {\n      \"accept\"\n    } else {\n      \"reject\"\n    }\n  }\n  if widened.kind == \"literal\" {\n    return if widened.name == \"float\" { \"reject\" } else { \"accept\" }\n  }\n  if widened.kind == \"json-value\" {\n    return \"accept\"\n  }\n  if widened.kind == \"match\" {\n    return if decoding { \"reject\" } else { \"accept\" }\n  }\n  if widened.kind == \"inference-variable\" {\n    return \"defer\"\n  }\n  if widened.kind == \"constructor\" {\n    if widened.name == \"Option\" || widened.name == \"Array\" {\n      return match widened.arguments.get(0) {\n        case Some(argument) => jsonCapability(\n          state,\n          moduleIndex,\n          argument,\n          seen,\n          decoding,\n        )\n        case None => \"reject\"\n      }\n    }\n    if widened.name == \"Map\" {\n      let key = match widened.arguments.get(0) {\n        case Some(argument) => {\n          let shown = widen(argument)\n          if (shown.kind == \"primitive\" || shown.kind == \"literal\") &&\n            shown.name == \"string\" {\n            \"accept\"\n          } else if shown.kind == \"inference-variable\" {\n            \"defer\"\n          } else {\n            \"reject\"\n          }\n        }\n        case None => \"reject\"\n      }\n      return capabilityAnd(key, match widened.arguments.get(1) {\n        case Some(argument) => jsonCapability(\n          state,\n          moduleIndex,\n          argument,\n          seen,\n          decoding,\n        )\n        case None => \"reject\"\n      })\n    }\n    return \"reject\"\n  }\n  if widened.kind == \"record\" {\n    let mut status = \"accept\"\n    for field in widened.fields {\n      status = capabilityAnd(status, jsonCapability(\n        state,\n        moduleIndex,\n        field,\n        seen,\n        decoding,\n      ))\n    }\n    return status\n  }\n  if nominalCapabilityType(widened) {\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return if decoding { \"reject\" } else { \"accept\" }\n    }\n    let mut status = \"accept\"\n    let projection = nominalCapabilityProjection(state, moduleIndex, widened)\n    let nested = capabilityPath(seen, key)\n    for child in projection.children {\n      status = capabilityAnd(status, jsonCapability(\n        state,\n        projection.moduleIndex,\n        child,\n        nested,\n        decoding,\n      ))\n    }\n    return status\n  }\n  \"reject\"\n}\n\nfunction nonKeyableType(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  seen: Array<string>,\n) -> Option<KeyCapabilityFailure> {\n  let widened = widen(value)\n  if widened.kind == \"byte-buffer\" {\n    return Some(KeyCapabilityFailure {\n      subject: \"ByteBuffer\",\n      kind: \"mutable byte buffer\",\n    })\n  }\n  if widened.kind == \"constructor\" {\n    if widened.name == \"Map\" {\n      return Some(KeyCapabilityFailure {\n        subject: \"`Map` value\",\n        kind: \"Map\",\n      })\n    }\n    if widened.name == \"Set\" {\n      return Some(KeyCapabilityFailure {\n        subject: \"`Set` value\",\n        kind: \"Set\",\n      })\n    }\n    if widened.name == \"Range\" {\n      return Some(KeyCapabilityFailure {\n        subject: \"`range` value\",\n        kind: \"range\",\n      })\n    }\n    for argument in widened.arguments {\n      match nonKeyableType(state, moduleIndex, argument, seen) {\n        case Some(failure) => return Some(failure)\n        case None => ()\n      }\n    }\n    return None\n  }\n  if widened.kind == \"function\" {\n    return Some(KeyCapabilityFailure {\n      subject: \"function value\",\n      kind: \"function\",\n    })\n  }\n  let specialKind = match widened.kind {\n    case \"template\" => \"template\"\n    case \"file\" => \"File\"\n    case \"json-value\" => \"JSONValue\"\n    case \"regex\" => \"Regex\"\n    case \"rounding-mode\" => \"RoundingMode\"\n    case \"match\" => \"Match\"\n    case \"toml-value\" => \"TOMLValue\"\n    case _ => \"\"\n  }\n  if specialKind != \"\" {\n    return Some(KeyCapabilityFailure {\n      subject: if specialKind == \"template\" {\n        \"template value\"\n      } else {\n        \"`{specialKind}` value\"\n      },\n      kind: specialKind,\n    })\n  }\n  if widened.kind == \"union\" {\n    for member in widened.members {\n      match nonKeyableType(state, moduleIndex, member, seen) {\n        case Some(failure) => return Some(failure)\n        case None => ()\n      }\n    }\n    return None\n  }\n  if widened.kind == \"record\" {\n    for field in widened.fields {\n      match nonKeyableType(state, moduleIndex, field, seen) {\n        case Some(failure) => return Some(failure)\n        case None => ()\n      }\n    }\n    return None\n  }\n  if nominalCapabilityType(widened) {\n    let key = nominalCapabilityKey(widened)\n    if containsString(seen, key) {\n      return None\n    }\n    let projection = nominalCapabilityProjection(state, moduleIndex, widened)\n    let nested = capabilityPath(seen, key)\n    for child in projection.children {\n      match nonKeyableType(\n        state,\n        projection.moduleIndex,\n        child,\n        nested,\n      ) {\n        case Some(failure) => return Some(failure)\n        case None => ()\n      }\n    }\n    return None\n  }\n  None\n}\n\nexport function gateCollectionKey(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  value: TypeValue,\n) -> () {\n  match nonKeyableType(state, moduleIndex, value, []) {\n    case Some(failure) => addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5007\",\n      \"{failure.subject} is not a valid Map/Set key ({failure.kind} keys are not supported yet)\",\n      \"\",\n      node,\n    )\n    case None => ()\n  }\n  ()\n}\n\nfunction declaredMemberType(\n  state: CheckerState,\n  moduleIndex: int,\n  object: TypeValue,\n  name: string,\n) -> Option<TypeValue> {\n  match recordDefinitionForType(state, moduleIndex, object) {\n    case Some(definition) => for field in definition.fields {\n      if field.name == name {\n        return Some(substitute(\n          field.typeValue,\n          definition.typeParameters,\n          object.arguments,\n        ))\n      }\n    }\n    case None => ()\n  }\n  match newtypeDefinitionForType(state, moduleIndex, object) {\n    case Some(definition) => if name == \"value\" {\n      return Some(functionType([], [], substitute(\n        definition.base,\n        definition.typeParameters,\n        object.arguments,\n      )))\n    }\n    case None => ()\n  }\n  if object.kind == \"record\" {\n    let mut index = 0\n    for fieldName in object.fieldNames {\n      if fieldName == name {\n        return Some(match object.fields.get(index) {\n          case Some(found) => found\n          case None => emptyType(\"unknown\")\n        })\n      }\n      index += 1\n    }\n  }\n  None\n}\n\n// Variant construction belongs to a type head, never to an enum receiver.\nexport function enumVariantType(\n  state: CheckerState,\n  moduleIndex: int,\n  object: TypeValue,\n  name: string,\n) -> TypeValue {\n  match enumDefinitionForType(state, moduleIndex, object) {\n    case Some(definition) => for variant in definition.variants {\n      if variant.name == name {\n        if variant.payloads.length == 0 {\n          return object\n        }\n        let mut payloads: Array<TypeValue> = []\n        for payload in variant.payloads {\n          payloads.push(substitute(\n            payload,\n            definition.typeParameters,\n            object.arguments,\n          ))\n        }\n        return functionType(payloads, [], object)\n      }\n    }\n    case None => ()\n  }\n  emptyType(\"unknown\")\n}\n\nexport function typeArgument(object: TypeValue, index: int) -> TypeValue {\n  match object.arguments.get(index) {\n    case Some(found) => found\n    case None => emptyType(\"unknown\")\n  }\n}\n\nfunction optionMemberType(object: TypeValue, name: string) -> TypeValue {\n  let value = typeArgument(object, 0)\n  let output = rigid(\"U\", \"builtin::Option.{name}\")\n  match name {\n    case \"okOr\" => functionType(\n      [output],\n      [],\n      constructor(\"Result\", [value, output]),\n    )\n    case \"okOrElse\" => functionType(\n      [functionType([], [], output)],\n      [],\n      constructor(\"Result\", [value, output]),\n    )\n    case \"map\" => functionType(\n      [functionType([value], [], output)],\n      [],\n      constructor(\"Option\", [output]),\n    )\n    case \"flatMap\" => functionType(\n      [functionType([value], [], constructor(\"Option\", [output]))],\n      [],\n      constructor(\"Option\", [output]),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction resultMemberType(object: TypeValue, name: string) -> TypeValue {\n  let value = typeArgument(object, 0)\n  let error = typeArgument(object, 1)\n  let output = rigid(\"U\", \"builtin::Result.{name}\")\n  match name {\n    case \"map\" => functionType(\n      [functionType([value], [], output)],\n      [],\n      constructor(\"Result\", [output, error]),\n    )\n    case \"flatMap\" => functionType(\n      [functionType(\n        [value],\n        [],\n        constructor(\"Result\", [output, error]),\n      )],\n      [],\n      constructor(\"Result\", [output, error]),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction arrayMemberType(object: TypeValue, name: string) -> TypeValue {\n  let element = iterableElement(object)\n  match name {\n    case \"length\" => primitive(\"int\")\n    case \"get\" => functionType(\n      [primitive(\"int\")],\n      [],\n      constructor(\"Option\", [element]),\n    )\n    case \"slice\" => functionType(\n      [primitive(\"int\"), primitive(\"int\")],\n      [],\n      object,\n    )\n    case \"map\" => {\n      let output = rigid(\"U\", \"builtin::Array.map\")\n      functionType(\n        [functionType([element], [], output)],\n        [],\n        constructor(\"Array\", [output]),\n      )\n    }\n    case \"join\" => functionType([primitive(\"string\")], [], primitive(\"string\"))\n    case \"sorted\" => functionType([], [], object)\n    case \"sortedBy\" => {\n      let key = rigid(\"K\", \"builtin::Array.sortedBy\")\n      functionType([functionType([element], [], key)], [], object)\n    }\n    case \"filter\" => functionType(\n      [functionType([element], [], primitive(\"bool\"))],\n      [],\n      object,\n    )\n    case \"reduce\" => {\n      let output = rigid(\"U\", \"builtin::Array.reduce\")\n      functionType(\n        [output, functionType([output, element], [], output)],\n        [],\n        output,\n      )\n    }\n    case \"indexOf\" => functionType(\n      [element],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"push\" => functionType([element], [], primitive(\"unit\"))\n    case \"pop\" => functionType([], [], constructor(\"Option\", [element]))\n    case \"clear\" | \"reverse\" | \"sort\" =>\n      functionType([], [], primitive(\"unit\"))\n    case \"sortBy\" => {\n      let key = rigid(\"K\", \"builtin::Array.sortBy\")\n      functionType(\n        [functionType([element], [], key)],\n        [],\n        primitive(\"unit\"),\n      )\n    }\n    case \"retain\" => functionType(\n      [functionType([element], [], primitive(\"bool\"))],\n      [],\n      primitive(\"unit\"),\n    )\n    case \"insert\" => functionType(\n      [primitive(\"int\"), element],\n      [],\n      primitive(\"unit\"),\n    )\n    case \"removeAt\" => functionType(\n      [primitive(\"int\")],\n      [],\n      constructor(\"Option\", [element]),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction setMemberType(object: TypeValue, name: string) -> TypeValue {\n  let element = iterableElement(object)\n  match name {\n    case \"length\" => primitive(\"int\")\n    case \"toArray\" => functionType([], [], constructor(\"Array\", [element]))\n    case \"contains\" => functionType([element], [], primitive(\"bool\"))\n    case \"add\" => functionType([element], [], primitive(\"unit\"))\n    case \"remove\" => functionType([element], [], primitive(\"bool\"))\n    case \"isEmpty\" => functionType([], [], primitive(\"bool\"))\n    case \"union\" | \"intersection\" | \"difference\" =>\n      functionType([object], [], object)\n    case \"clear\" => functionType([], [], primitive(\"unit\"))\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction mapMemberType(object: TypeValue, name: string) -> TypeValue {\n  let key = typeArgument(object, 0)\n  let item = typeArgument(object, 1)\n  match name {\n    case \"length\" => primitive(\"int\")\n    case \"keys\" => constructor(\"Array\", [key])\n    case \"values\" => constructor(\"Array\", [item])\n    case \"entries\" => constructor(\"Array\", [structural(\n      [\"key\", \"value\"],\n      [key, item],\n    )])\n    case \"get\" => functionType([key], [], constructor(\"Option\", [item]))\n    case \"getOr\" => functionType([key, item], [], item)\n    case \"containsKey\" => functionType([key], [], primitive(\"bool\"))\n    case \"insert\" => functionType([key, item], [], primitive(\"unit\"))\n    case \"remove\" => functionType([key], [], constructor(\"Option\", [item]))\n    case \"isEmpty\" => functionType([], [], primitive(\"bool\"))\n    case \"clear\" => functionType([], [], primitive(\"unit\"))\n    case \"update\" => functionType(\n      [key, item, functionType([item], [], item)],\n      [],\n      primitive(\"unit\"),\n    )\n    case \"mapValues\" => {\n      let output = rigid(\"W\", \"builtin::Map.mapValues\")\n      functionType(\n        [functionType([item], [], output)],\n        [],\n        constructor(\"Map\", [key, output]),\n      )\n    }\n    case \"filter\" => functionType(\n      [functionType([key, item], [], primitive(\"bool\"))],\n      [],\n      object,\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction stringMemberType(name: string) -> TypeValue {\n  match name {\n    case \"byteLength\" => functionType([], [], primitive(\"int\"))\n    case \"trim\" | \"trimStart\" | \"trimEnd\" =>\n      functionType([], [], primitive(\"string\"))\n    case \"contains\" | \"startsWith\" | \"endsWith\" =>\n      functionType([primitive(\"string\")], [], primitive(\"bool\"))\n    case \"replace\" => functionType(\n      [primitive(\"string\"), primitive(\"string\")],\n      [],\n      primitive(\"string\"),\n    )\n    case \"indexOf\" | \"lastIndexOf\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"split\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Array\", [primitive(\"string\")]),\n    )\n    case \"slice\" => functionType(\n      [primitive(\"int\"), primitive(\"int\")],\n      [],\n      primitive(\"string\"),\n    )\n    case \"codePointAt\" => functionType(\n      [primitive(\"int\")],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"scalars\" => functionType(\n      [],\n      [],\n      constructor(\"Array\", [primitive(\"string\")]),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction bytesMemberType(name: string) -> TypeValue {\n  match name {\n    case \"length\" => functionType([], [], primitive(\"int\"))\n    case \"isEmpty\" => functionType([], [], primitive(\"bool\"))\n    case \"get\" => functionType(\n      [primitive(\"int\")],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"slice\" => functionType(\n      [primitive(\"int\"), primitive(\"int\")],\n      [],\n      emptyType(\"bytes\"),\n    )\n    case \"decodeUtf8\" => functionType(\n      [],\n      [],\n      constructor(\"Result\", [primitive(\"string\"), primitive(\"string\")]),\n    )\n    case \"toArray\" => functionType(\n      [],\n      [],\n      constructor(\"Array\", [primitive(\"int\")]),\n    )\n    case \"toHex\" | \"toBase64\" => functionType([], [], primitive(\"string\"))\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction byteBufferMemberType(name: string) -> TypeValue {\n  match name {\n    case \"length\" => functionType([], [], primitive(\"int\"))\n    case \"get\" => functionType([primitive(\"int\")], [], primitive(\"int\"))\n    case \"set\" => functionType(\n      [primitive(\"int\"), primitive(\"int\")],\n      [],\n      primitive(\"unit\"),\n    )\n    case \"fill\" => functionType(\n      [primitive(\"int\"), primitive(\"int\"), primitive(\"int\")],\n      [],\n      primitive(\"unit\"),\n    )\n    case \"copy\" => functionType(\n      [\n        emptyType(\"byte-buffer\"),\n        primitive(\"int\"),\n        primitive(\"int\"),\n        primitive(\"int\"),\n      ],\n      [],\n      primitive(\"unit\"),\n    )\n    case \"toBytes\" => functionType([], [], emptyType(\"bytes\"))\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction fileMemberType(name: string) -> TypeValue {\n  match name {\n    case \"read\" => functionType(\n      [],\n      [],\n      constructor(\"Result\", [primitive(\"string\"), primitive(\"string\")]),\n    )\n    case \"write\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Result\", [primitive(\"unit\"), primitive(\"string\")]),\n    )\n    case \"close\" => functionType([], [], primitive(\"unit\"))\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction pathMemberType(name: string) -> TypeValue {\n  match name {\n    case \"join\" | \"withExtension\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Result\", [emptyType(\"path\"), primitive(\"string\")]),\n    )\n    case \"parent\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [emptyType(\"path\")]),\n    )\n    case \"fileName\" | \"extension\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"string\")]),\n    )\n    case \"normalize\" => functionType([], [], emptyType(\"path\"))\n    case \"toString\" => functionType([], [], primitive(\"string\"))\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction regexMemberType(name: string) -> TypeValue {\n  match name {\n    case \"isMatch\" => functionType(\n      [primitive(\"string\")],\n      [],\n      primitive(\"bool\"),\n    )\n    case \"find\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Option\", [emptyType(\"match\")]),\n    )\n    case \"findAll\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Array\", [emptyType(\"match\")]),\n    )\n    case \"split\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Array\", [primitive(\"string\")]),\n    )\n    case \"replaceAll\" => functionType(\n      [primitive(\"string\"), primitive(\"string\")],\n      [],\n      primitive(\"string\"),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction urlMemberType(name: string) -> TypeValue {\n  match name {\n    case \"scheme\" | \"path\" | \"toString\" =>\n      functionType([], [], primitive(\"string\"))\n    case \"host\" | \"fragment\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"string\")]),\n    )\n    case \"query\" => functionType(\n      [],\n      [],\n      constructor(\n        \"Map\",\n        [primitive(\"string\"), constructor(\"Array\", [primitive(\"string\")])],\n      ),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction dateMemberType(name: string) -> TypeValue {\n  match name {\n    case \"toIso\" => functionType([], [], primitive(\"string\"))\n    case \"addDays\" => functionType([primitive(\"int\")], [], emptyType(\"date\"))\n    case \"year\" | \"month\" | \"day\" =>\n      functionType([], [], primitive(\"int\"))\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction bigIntMemberType(name: string) -> TypeValue {\n  match name {\n    case \"toString\" => functionType([primitive(\"int\")], [], primitive(\"string\"))\n    case \"toInt\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"div\" | \"mod\" => functionType(\n      [emptyType(\"big-int\")],\n      [],\n      constructor(\"Result\", [emptyType(\"big-int\"), primitive(\"string\")]),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction decimalMemberType(name: string) -> TypeValue {\n  match name {\n    case \"toString\" => functionType([], [], primitive(\"string\"))\n    case \"scale\" => functionType([], [], primitive(\"int\"))\n    case \"toInt\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"round\" => functionType(\n      [primitive(\"int\"), emptyType(\"rounding-mode\")],\n      [],\n      emptyType(\"decimal\"),\n    )\n    case \"div\" => functionType(\n      [\n        emptyType(\"decimal\"),\n        primitive(\"int\"),\n        emptyType(\"rounding-mode\"),\n      ],\n      [],\n      constructor(\"Result\", [emptyType(\"decimal\"), primitive(\"string\")]),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction jsonValueMemberType(name: string) -> TypeValue {\n  match name {\n    case \"kind\" => functionType([], [], primitive(\"string\"))\n    case \"isNull\" => functionType([], [], primitive(\"bool\"))\n    case \"asString\" | \"numberText\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"string\")]),\n    )\n    case \"asBool\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"bool\")]),\n    )\n    case \"asInt\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"get\" => functionType(\n      [primitive(\"string\")],\n      [],\n      constructor(\"Option\", [emptyType(\"json-value\")]),\n    )\n    case \"at\" => functionType(\n      [primitive(\"int\")],\n      [],\n      constructor(\"Option\", [emptyType(\"json-value\")]),\n    )\n    case \"length\" => functionType(\n      [],\n      [],\n      constructor(\"Option\", [primitive(\"int\")]),\n    )\n    case \"asArray\" | \"values\" => functionType(\n      [],\n      [],\n      constructor(\n        \"Option\",\n        [constructor(\"Array\", [emptyType(\"json-value\")])],\n      ),\n    )\n    case \"keys\" => functionType(\n      [],\n      [],\n      constructor(\n        \"Option\",\n        [constructor(\"Array\", [primitive(\"string\")])],\n      ),\n    )\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nfunction dataProjectionMemberType(object: TypeValue, name: string) -> TypeValue {\n  if object.kind == \"match\" {\n    return match name {\n      case \"start\" | \"end\" => primitive(\"int\")\n      case \"text\" => primitive(\"string\")\n      case \"groups\" => constructor(\n        \"Array\",\n        [constructor(\"Option\", [primitive(\"string\")])],\n      )\n      case \"named\" => constructor(\n        \"Map\",\n        [primitive(\"string\"), primitive(\"string\")],\n      )\n      case _ => emptyType(\"unknown\")\n    }\n  }\n  match name {\n    case \"tag\" => primitive(\"string\")\n    case \"parts\" => constructor(\"Array\", [primitive(\"string\")])\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nexport function removedStandardStatic(namespace: string, name: string) -> bool {\n  namespace == \"Math\" || namespace == \"JSON\" || namespace == \"Encoding\" || namespace == \"Hash\" || namespace == \"Codec\" || namespace == \"Cli\" || namespace == \"FS\" || namespace == \"Test\" || namespace == \"CSV\" || namespace == \"TOML\" || ((namespace == \"Array\" || namespace == \"Set\") && name == \"of\") || (namespace == \"Map\" && name == \"new\") || (namespace == \"Bytes\" && (name == \"encodeUtf8\" || name == \"concat\")) || ((namespace == \"BigInt\" || namespace == \"Decimal\") && name == \"fromInt\")\n}\n\nexport function standardBoundary(module: string, name: string) -> Array<string> {\n  match \"{module}::{name}\" {\n    case \"std.fs::__stdReadText\" => [\"FS\", \"readText\"]\n    case \"std.fs::__stdWriteText\" => [\"FS\", \"writeText\"]\n    case \"std.fs::__stdReadBytes\" => [\"FS\", \"readBytes\"]\n    case \"std.fs::__stdWriteBytes\" => [\"FS\", \"writeBytes\"]\n    case \"std.fs::__stdList\" => [\"FS\", \"list\"]\n    case \"std.io::__stdWriteLine\" => [\"\", \"print\"]\n    case \"std.io::__stdReadStdin\" => [\"\", \"input\"]\n    case \"std.io::__stdOpen\" => [\"\", \"open\"]\n    case \"std.json::__stdJsonParse\" => [\"JSON\", \"parse\"]\n    case \"std.json::__stdJsonStringify\" => [\"JSON\", \"stringify\"]\n    case \"std.json::__stdJsonParseAs\" => [\"JSON\", \"parseAs\"]\n    case \"std.csv::__stdCsvParse\" => [\"CSV\", \"parse\"]\n    case \"std.csv::__stdCsvParseWithHeader\" => [\"CSV\", \"parseWithHeader\"]\n    case \"std.csv::__stdCsvStringify\" => [\"CSV\", \"stringify\"]\n    case \"std.csv::__stdCsvStringifyWithHeader\" => [\"CSV\", \"stringifyWithHeader\"]\n    case \"std.toml::__stdTomlParse\" => [\"TOML\", \"parse\"]\n    case \"std.toml::__stdTomlStringify\" => [\"TOML\", \"stringify\"]\n    case \"std.toml::__stdTomlFromJson\" => [\"TOML\", \"fromJson\"]\n    case \"std.test::__stdAssert\" => [\"Test\", \"assert\"]\n    case \"std.test::__stdAssertEq\" => [\"Test\", \"assertEq\"]\n    case \"std.test::__stdAssertNe\" => [\"Test\", \"assertNe\"]\n    case \"std.test::__stdAssertContains\" => [\"Test\", \"assertContains\"]\n    case \"std.test::__stdAssertOk\" => [\"Test\", \"assertOk\"]\n    case \"std.test::__stdAssertErr\" => [\"Test\", \"assertErr\"]\n    case \"std.test::__stdAssertSome\" => [\"Test\", \"assertSome\"]\n    case \"std.test::__stdAssertNone\" => [\"Test\", \"assertNone\"]\n    case \"std.test::__stdAssertGolden\" => [\"Test\", \"assertGolden\"]\n    case _ => []\n  }\n}\n\nfunction movedReceiverType(namespace: string, name: string) -> TypeValue {\n  match builtinNamespaceMemberType(namespace, name, \"topaz-5.20\") {\n    case Some(found) => functionType(found.parameters.slice(1, found.parameters.length), found.variadic, match found.result.get(0) { case Some(result) => result; case None => emptyType(\"unknown\") })\n    case None => emptyType(\"unknown\")\n  }\n}\n\n// Candidate spellings for the closed opaque builtin surfaces. Lookup below\n// filters these by language mode and by whether the use requires a method.\nexport function opaqueMemberNames(object: TypeValue) -> Array<string> {\n  match object.kind {\n    case \"json-value\" => [\"kind\", \"isNull\", \"asString\", \"asBool\", \"asInt\", \"numberText\", \"get\", \"at\", \"length\", \"asArray\", \"keys\", \"values\", \"decode\"]\n    case \"bytes\" => [\"decodeUtf8\", \"toHex\", \"toBase64\", \"length\", \"isEmpty\", \"get\", \"slice\", \"toArray\", \"concat\", \"sha256\", \"sha512\", \"hmacSha256\", \"crc32\", \"gzipCompress\", \"gzipDecompress\", \"deflateCompress\", \"deflateFixedCompress\", \"zlibFixedCompress\", \"reedSolomon255223Protect\", \"deflateDecompress\", \"zstdCompress\", \"zstdDecompress\"]\n    case \"byte-buffer\" => [\"length\", \"get\", \"set\", \"fill\", \"copy\", \"toBytes\"]\n    case \"path\" => [\"join\", \"parent\", \"fileName\", \"extension\", \"withExtension\", \"normalize\", \"toString\"]\n    case \"regex\" => [\"isMatch\", \"find\", \"findAll\", \"split\", \"replaceAll\"]\n    case \"match\" => [\"start\", \"end\", \"text\", \"groups\", \"named\"]\n    case \"toml-value\" => [\"toJson\"]\n    case \"url\" => [\"scheme\", \"host\", \"path\", \"query\", \"fragment\", \"toString\"]\n    case \"date\" => [\"toIso\", \"addDays\", \"year\", \"month\", \"day\"]\n    case \"big-int\" => [\"toString\", \"toInt\", \"div\", \"mod\"]\n    case \"decimal\" => [\"toString\", \"scale\", \"toInt\", \"round\", \"div\"]\n    case _ => []\n  }\n}\n\nexport function memberType(\n  state: CheckerState,\n  moduleIndex: int,\n  object: TypeValue,\n  name: string,\n) -> TypeValue {\n  let unit = lengthUnit(object)\n  if state.languageMode == \"topaz-5.21\" && unit != \"\" {\n    if unit == \"Em\" { return if name == \"resolve\" { functionType([lengthType(\"Pt\")],[],lengthType(\"Pt\")) } else { emptyType(\"unknown\") } }\n    return match name {\n      case \"toPt\" => functionType([],[],lengthType(\"Pt\"))\n      case \"toMm\" => functionType([],[],lengthType(\"Mm\"))\n      case \"toCm\" => functionType([],[],lengthType(\"Cm\"))\n      case \"toIn\" => functionType([],[],lengthType(\"In\"))\n      case \"scaledPoints\" => functionType([],[],primitive(\"int\"))\n      case \"toMilliPoints\" => if unit == \"Pt\" { functionType([],[],primitive(\"int\")) } else { emptyType(\"unknown\") }\n      case _ => emptyType(\"unknown\")\n    }\n  }\n  if state.languageMode == \"topaz-5.21\" && (object.kind == \"primitive\" || object.kind == \"literal\") {\n    if object.name == \"float\" {\n      return match name {\n        case \"trunc\" | \"floor\" | \"ceil\" | \"round\" => functionType([], [], primitive(\"int\"))\n        case \"abs\" | \"sin\" | \"cos\" | \"tan\" => functionType([], [], primitive(\"float\"))\n        case \"sqrt\" => functionType([], [], constructor(\"Result\", [primitive(\"float\"), primitive(\"string\")]))\n        case \"isNaN\" | \"isFinite\" => functionType([], [], primitive(\"bool\"))\n        case \"atMost\" | \"atLeast\" => functionType([primitive(\"float\")], [], primitive(\"float\"))\n        case _ => emptyType(\"unknown\")\n      }\n    }\n    if object.name == \"int\" && (name == \"and\" || name == \"or\" || name == \"xor\" || name == \"shift\") { return functionType([primitive(\"int\")], [], primitive(\"int\")) }\n    if object.name == \"int\" && name == \"toBigInt\" { return movedReceiverType(\"BigInt\", \"fromInt\") }\n    if object.name == \"int\" && name == \"toDecimal\" { return movedReceiverType(\"Decimal\", \"fromInt\") }\n    if object.name == \"string\" && name == \"encodeUtf8\" { return movedReceiverType(\"Bytes\", \"encodeUtf8\") }\n    if object.name == \"int\" && name == \"toFloat\" { return functionType([], [], primitive(\"float\")) }\n    if object.name == \"int\" && name == \"toCodePoint\" { return functionType([], [], constructor(\"Option\", [primitive(\"string\")])) }\n    if object.name == \"string\" {\n      if name == \"parseFloat\" { return functionType([], [], constructor(\"Result\", [primitive(\"float\"), primitive(\"string\")])) }\n      if name == \"toInt\" { return functionType([], [], constructor(\"Option\", [primitive(\"int\")])) }\n      if name == \"toIntRadix\" { return functionType([primitive(\"int\")], [], constructor(\"Option\", [primitive(\"int\")])) }\n    }\n  }\n  match declaredMemberType(state, moduleIndex, object, name) {\n    case Some(found) => return found\n    case None => ()\n  }\n  if state.languageMode == \"topaz-5.21\" {\n    if object.kind == \"constructor\" && (object.name == \"Set\" || object.name == \"Range\") && (name == \"map\" || name == \"filter\" || name == \"reduce\") {\n      return arrayMemberType(constructor(\"Array\", [if object.name == \"Range\" { primitive(\"int\") } else { typeArgument(object, 0) }]), name)\n    }\n    if object.kind == \"constructor\" && object.name == \"Result\" {\n      if name == \"unwrapOr\" { let value = typeArgument(object, 0); return functionType([value], [], value) }\n      if name == \"mapErr\" { let error = rigid(\"F\", \"builtin::Result.mapErr\"); return functionType([functionType([typeArgument(object, 1)], [], error)], [], constructor(\"Result\", [typeArgument(object, 0), error])) }\n    }\n    if object.kind == \"constructor\" && object.name == \"Array\" && stringElementType(typeArgument(object, 0)) && (name == \"hasFlag\" || name == \"option\" || name == \"options\" || name == \"positionals\") { return movedReceiverType(\"Cli\", name) }\n    if object.kind == \"bytes\" {\n      if name == \"concat\" { return movedReceiverType(\"Bytes\", name) }\n      if name == \"sha256\" || name == \"sha512\" || name == \"hmacSha256\" || name == \"crc32\" { return movedReceiverType(\"Hash\", name) }\n      if name == \"gzipCompress\" || name == \"gzipDecompress\" || name == \"deflateCompress\" || name == \"deflateFixedCompress\" || name == \"zlibFixedCompress\" || name == \"reedSolomon255223Protect\" || name == \"deflateDecompress\" || name == \"zstdCompress\" || name == \"zstdDecompress\" { return movedReceiverType(\"Codec\", name) }\n    }\n    if object.kind == \"toml-value\" && name == \"toJson\" { return movedReceiverType(\"TOML\", name) }\n    if object.kind == \"json-value\" && name == \"decode\" { return functionType([], [], constructor(\"Result\", [rigid(\"T\", \"builtin::JSONValue.decode\"), primitive(\"string\")])) }\n  }\n  if (object.kind == \"primitive\" || object.kind == \"literal\") &&\n    object.name == \"int\" {\n    return match name {\n      case \"atLeast\" | \"atMost\" => functionType(\n        [primitive(\"int\")],\n        [],\n        primitive(\"int\"),\n      )\n      case _ => emptyType(\"unknown\")\n    }\n  }\n  if object.kind == \"constructor\" && object.name == \"Option\" {\n    return optionMemberType(object, name)\n  }\n  if object.kind == \"constructor\" && object.name == \"Result\" {\n    return resultMemberType(object, name)\n  }\n  if object.kind == \"constructor\" && object.name == \"Array\" {\n    return arrayMemberType(object, name)\n  }\n  if object.kind == \"constructor\" && object.name == \"Set\" {\n    return setMemberType(object, name)\n  }\n  if object.kind == \"constructor\" && object.name == \"Map\" {\n    return mapMemberType(object, name)\n  }\n  if (object.kind == \"primitive\" || object.kind == \"literal\") &&\n    object.name == \"string\" {\n    return stringMemberType(name)\n  }\n  if object.kind == \"bytes\" {\n    return bytesMemberType(name)\n  }\n  if object.kind == \"byte-buffer\" {\n    return byteBufferMemberType(name)\n  }\n  if object.kind == \"file\" {\n    return fileMemberType(name)\n  }\n  if object.kind == \"path\" {\n    return pathMemberType(name)\n  }\n  if object.kind == \"regex\" {\n    return regexMemberType(name)\n  }\n  if object.kind == \"url\" {\n    return urlMemberType(name)\n  }\n  if object.kind == \"date\" {\n    return dateMemberType(name)\n  }\n  if object.kind == \"big-int\" {\n    return bigIntMemberType(name)\n  }\n  if object.kind == \"decimal\" {\n    return decimalMemberType(name)\n  }\n  if object.kind == \"json-value\" {\n    return jsonValueMemberType(name)\n  }\n  if object.kind == \"match\" || object.kind == \"template\" {\n    return dataProjectionMemberType(object, name)\n  }\n  if object.kind == \"rigid\" || object.kind == \"foreign\" {\n    let projection = \"MemberOf<{typeText(object)}, {name}>\"\n    return rigid(\n      projection,\n      \"projection:{projection}\",\n    )\n  }\n  if object.kind == \"union\" {\n    let mut projected: Array<TypeValue> = []\n    for member in object.members {\n      let found = memberType(state, moduleIndex, member, name)\n      // A concrete missing arm invalidates the projection. Gradual arms stay\n      // gradual; rigid arms retain their MemberOf projection.\n      if found.kind == \"unknown\" && !hasHole(member) {\n        return emptyType(\"unknown\")\n      }\n      projected.push(found)\n    }\n    return unionType(projected)\n  }\n  emptyType(\"unknown\")\n}\n\nexport function rigidOrUnionRigid(value: TypeValue) -> bool {\n  if value.kind == \"rigid\" || value.kind == \"foreign\" {\n    return true\n  }\n  if value.kind == \"union\" {\n    for member in value.members {\n      if rigidOrUnionRigid(member) {\n        return true\n      }\n    }\n  }\n  false\n}\n\nexport function rigidUnionMissingConcreteMember(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  memberName: string,\n) -> bool {\n  if value.kind != \"union\" {\n    return false\n  }\n  for arm in value.members {\n    if arm.kind == \"rigid\" || arm.kind == \"foreign\" ||\n      arm.kind == \"unknown\" || arm.kind == \"inference-variable\" ||\n      rigidOrUnionRigid(arm) {\n      continue\n    }\n    let declared = match declaredMemberType(state, moduleIndex, arm, memberName) {\n      case Some(_) => true\n      case None => false\n    }\n    if declared { continue }\n    let receiverMethod = match receiverMethodType(\n      state,\n      moduleIndex,\n      arm,\n      memberName,\n    ) {\n      case Some(_) => true\n      case None => false\n    }\n    if receiverMethod { continue }\n    if memberType(state, moduleIndex, arm, memberName).kind == \"unknown\" {\n      return true\n    }\n  }\n  false\n}\n\nfunction collectionNamespaceMemberType(\n  namespace: string,\n  name: string,\n) -> Option<TypeValue> {\n  let bytes = emptyType(\"bytes\")\n  let textValue = primitive(\"string\")\n  let bytesResult = constructor(\"Result\", [bytes, textValue])\n  if namespace == \"Array\" || namespace == \"Set\" {\n    let item = rigid(\"T\", \"builtin::{namespace}.of\")\n    return match name {\n      case \"of\" => Some(functionType(\n        [],\n        [item],\n        constructor(namespace, [item]),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Bytes\" {\n    return match name {\n      case \"empty\" => Some(functionType([], [], bytes))\n      case \"encodeUtf8\" => Some(functionType([textValue], [], bytes))\n      case \"fromArray\" => Some(functionType(\n        [constructor(\"Array\", [primitive(\"int\")])],\n        [],\n        bytesResult,\n      ))\n      case \"fromHex\" | \"fromBase64\" => Some(functionType(\n        [textValue],\n        [],\n        bytesResult,\n      ))\n      case \"concat\" => Some(functionType([bytes, bytes], [], bytes))\n      case _ => None\n    }\n  }\n  if namespace == \"ByteBuffer\" {\n    return match name {\n      case \"allocate\" => Some(functionType(\n        [primitive(\"int\"), primitive(\"int\")],\n        [],\n        emptyType(\"byte-buffer\"),\n      ))\n      case \"fromBytes\" => Some(functionType(\n        [bytes],\n        [],\n        emptyType(\"byte-buffer\"),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Map\" {\n    let key = rigid(\"K\", \"builtin::Map.new\")\n    let value = rigid(\"V\", \"builtin::Map.new\")\n    return match name {\n      case \"new\" => Some(functionType(\n        [],\n        [],\n        constructor(\"Map\", [key, value]),\n      ))\n      case \"ofEntries\" => Some(functionType(\n        [constructor(\"Array\", [structural(\n          [\"key\", \"value\"],\n          [key, value],\n        )])],\n        [],\n        constructor(\"Map\", [key, value]),\n      ))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction numericAndBinaryNamespaceMemberType(\n  namespace: string,\n  name: string,\n) -> Option<TypeValue> {\n  let bytes = emptyType(\"bytes\")\n  let textValue = primitive(\"string\")\n  let bytesResult = constructor(\"Result\", [bytes, textValue])\n  if namespace == \"Math\" {\n    let floatValue = primitive(\"float\")\n    return match name {\n      case \"sqrt\" => Some(functionType(\n        [floatValue],\n        [],\n        constructor(\"Result\", [floatValue, textValue]),\n      ))\n      case \"abs\" | \"floor\" | \"ceil\" | \"round\" |\n        \"sin\" | \"cos\" | \"tan\" => Some(functionType(\n        [floatValue],\n        [],\n        floatValue,\n      ))\n      case \"isNaN\" | \"isFinite\" => Some(functionType(\n        [floatValue],\n        [],\n        primitive(\"bool\"),\n      ))\n      case \"parseFloat\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [floatValue, textValue]),\n      ))\n      case \"min\" | \"max\" => Some(functionType(\n        [floatValue, floatValue],\n        [],\n        floatValue,\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Codec\" {\n    return match name {\n      case \"zstdCompress\" => Some(functionType(\n        [bytes, primitive(\"int\")],\n        [],\n        bytesResult,\n      ))\n      case \"gzipCompress\" |\n        \"gzipDecompress\" |\n        \"deflateCompress\" |\n        \"deflateFixedCompress\" |\n        \"zlibFixedCompress\" |\n        \"reedSolomon255223Protect\" |\n        \"deflateDecompress\" |\n        \"zstdDecompress\" => Some(functionType([bytes], [], bytesResult))\n      case _ => None\n    }\n  }\n  if namespace == \"Hash\" {\n    return match name {\n      case \"sha256\" | \"sha512\" => Some(functionType([bytes], [], bytes))\n      case \"hmacSha256\" => Some(functionType([bytes, bytes], [], bytes))\n      case \"crc32\" => Some(functionType([bytes], [], primitive(\"int\")))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction hostNamespaceMemberType(\n  namespace: string,\n  name: string,\n) -> Option<TypeValue> {\n  let bytes = emptyType(\"bytes\")\n  let textValue = primitive(\"string\")\n  let bytesResult = constructor(\"Result\", [bytes, textValue])\n  if namespace == \"FS\" {\n    let pathValue = unionType([textValue, emptyType(\"path\")])\n    return match name {\n      case \"readText\" => Some(functionType(\n        [pathValue],\n        [],\n        constructor(\"Result\", [textValue, textValue]),\n      ))\n      case \"writeText\" => Some(functionType(\n        [pathValue, textValue],\n        [],\n        constructor(\"Result\", [primitive(\"unit\"), textValue]),\n      ))\n      case \"readBytes\" => Some(functionType(\n        [pathValue],\n        [],\n        bytesResult,\n      ))\n      case \"writeBytes\" => Some(functionType(\n        [pathValue, bytes],\n        [],\n        constructor(\"Result\", [primitive(\"unit\"), textValue]),\n      ))\n      case \"list\" => Some(functionType(\n        [pathValue],\n        [],\n        constructor(\"Result\", [\n          constructor(\"Array\", [structural(\n            [\"kind\", \"name\", \"sizeBytes\"],\n            [\n              textValue,\n              textValue,\n              constructor(\"Option\", [primitive(\"int\")]),\n            ],\n          )]),\n          textValue,\n        ]),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Encoding\" {\n    return match name {\n      case \"utf8Encode\" => Some(functionType([textValue], [], bytes))\n      case \"utf8Decode\" => Some(functionType(\n        [bytes],\n        [],\n        constructor(\"Result\", [textValue, textValue]),\n      ))\n      case \"hexEncode\" | \"base64Encode\" => Some(functionType(\n        [bytes],\n        [],\n        textValue,\n      ))\n      case \"hexDecode\" | \"base64Decode\" => Some(functionType(\n        [textValue],\n        [],\n        bytesResult,\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Cli\" {\n    let textArray = constructor(\"Array\", [textValue])\n    return match name {\n      case \"hasFlag\" => Some(functionType(\n        [textArray, textValue],\n        [],\n        primitive(\"bool\"),\n      ))\n      case \"option\" => Some(functionType(\n        [textArray, textValue],\n        [],\n        constructor(\"Option\", [textValue]),\n      ))\n      case \"options\" => Some(functionType(\n        [textArray, textValue],\n        [],\n        textArray,\n      ))\n      case \"positionals\" => Some(functionType(\n        [textArray],\n        [],\n        textArray,\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Path\" {\n    return match name {\n      case \"from\" | \"cwdRelative\" | \"project\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [emptyType(\"path\"), textValue]),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Regex\" {\n    return match name {\n      case \"compile\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [emptyType(\"regex\"), textValue]),\n      ))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction structuredDataNamespaceMemberType(\n  namespace: string,\n  name: string,\n) -> Option<TypeValue> {\n  let textValue = primitive(\"string\")\n  if namespace == \"CSV\" {\n    let textArray = constructor(\"Array\", [textValue])\n    let rows = constructor(\"Array\", [textArray])\n    let records = constructor(\n      \"Array\",\n      [constructor(\"Map\", [textValue, textValue])],\n    )\n    return match name {\n      case \"parse\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [rows, textValue]),\n      ))\n      case \"parseWithHeader\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [records, textValue]),\n      ))\n      case \"stringify\" => Some(functionType([rows], [], textValue))\n      case \"stringifyWithHeader\" => Some(functionType(\n        [records, textArray],\n        [],\n        textValue,\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"TOML\" {\n    return match name {\n      case \"parse\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\n          \"Result\",\n          [emptyType(\"toml-value\"), textValue],\n        ),\n      ))\n      case \"stringify\" => Some(functionType(\n        [emptyType(\"toml-value\")],\n        [],\n        constructor(\"Result\", [textValue, textValue]),\n      ))\n      case \"toJson\" => Some(functionType(\n        [emptyType(\"toml-value\")],\n        [],\n        emptyType(\"json-value\"),\n      ))\n      case \"fromJson\" => Some(functionType(\n        [emptyType(\"json-value\")],\n        [],\n        constructor(\n          \"Result\",\n          [emptyType(\"toml-value\"), textValue],\n        ),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"JSON\" {\n    let decoded = rigid(\"T\", \"builtin::JSON\")\n    let parseError = structural(\n      [\"column\", \"line\", \"message\"],\n      [primitive(\"int\"), primitive(\"int\"), textValue],\n    )\n    return match name {\n      case \"parseAs\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [decoded, textValue]),\n      ))\n      case \"decode\" => Some(functionType(\n        [emptyType(\"json-value\")],\n        [],\n        constructor(\"Result\", [decoded, textValue]),\n      ))\n      case \"parse\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\n          \"Result\",\n          [emptyType(\"json-value\"), parseError],\n        ),\n      ))\n      case \"stringify\" => Some(functionType(\n        [rigid(\"T\", \"builtin::JSON\")],\n        [],\n        constructor(\"Result\", [textValue, textValue]),\n      ))\n      case _ => None\n    }\n  }\n  None\n}\n\nfunction scalarNamespaceMemberType(\n  namespace: string,\n  name: string,\n) -> Option<TypeValue> {\n  let textValue = primitive(\"string\")\n  if namespace == \"URL\" {\n    return match name {\n      case \"parse\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [emptyType(\"url\"), textValue]),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Date\" {\n    return match name {\n      case \"fromYmd\" => Some(functionType(\n        [primitive(\"int\"), primitive(\"int\"), primitive(\"int\")],\n        [],\n        constructor(\"Result\", [emptyType(\"date\"), textValue]),\n      ))\n      case \"parseIso\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Result\", [emptyType(\"date\"), textValue]),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"BigInt\" {\n    return match name {\n      case \"fromInt\" => Some(functionType(\n        [primitive(\"int\")],\n        [],\n        emptyType(\"big-int\"),\n      ))\n      case \"parse\" => Some(functionType(\n        [textValue, primitive(\"int\")],\n        [],\n        constructor(\"Option\", [emptyType(\"big-int\")]),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"Decimal\" {\n    return match name {\n      case \"fromInt\" => Some(functionType(\n        [primitive(\"int\")],\n        [],\n        emptyType(\"decimal\"),\n      ))\n      case \"parse\" => Some(functionType(\n        [textValue],\n        [],\n        constructor(\"Option\", [emptyType(\"decimal\")]),\n      ))\n      case _ => None\n    }\n  }\n  if namespace == \"RoundingMode\" {\n    return match name {\n      case \"Down\" | \"Up\" | \"TowardZero\" | \"AwayFromZero\" |\n        \"HalfEven\" | \"HalfUp\" =>\n        Some(emptyType(\"rounding-mode\"))\n      case _ => None\n    }\n  }\n  if namespace == \"Test\" {\n    let value = rigid(\"T\", \"builtin::Test\")\n    let error = rigid(\"E\", \"builtin::Test\")\n    return match name {\n      case \"assert\" => Some(functionType(\n        [primitive(\"bool\"), textValue],\n        [],\n        primitive(\"unit\"),\n      ))\n      case \"assertEq\" | \"assertNe\" => Some(functionType(\n        [value, value],\n        [],\n        primitive(\"unit\"),\n      ))\n      case \"assertContains\" => Some(functionType(\n        [textValue, textValue],\n        [],\n        primitive(\"unit\"),\n      ))\n      case \"assertOk\" => Some(functionType(\n        [constructor(\"Result\", [value, error])],\n        [],\n        value,\n      ))\n      case \"assertErr\" => Some(functionType(\n        [constructor(\"Result\", [value, error])],\n        [],\n        error,\n      ))\n      case \"assertSome\" => Some(functionType(\n        [constructor(\"Option\", [value])],\n        [],\n        value,\n      ))\n      case \"assertNone\" => Some(functionType(\n        [constructor(\"Option\", [value])],\n        [],\n        primitive(\"unit\"),\n      ))\n      case \"assertGolden\" => Some(functionType(\n        [textValue, textValue],\n        [],\n        primitive(\"unit\"),\n      ))\n      case _ => None\n    }\n  }\n  None\n}\n\nexport function builtinNamespaceMemberType(\n  namespace: string,\n  name: string,\n  languageMode: string = \"topaz-5.20\",\n) -> Option<TypeValue> {\n  if languageMode == \"topaz-5.21\" && removedStandardStatic(namespace, name) { return None }\n  match builtinNamespaceFamily(namespace) {\n    case \"collection\" => collectionNamespaceMemberType(namespace, name)\n    case \"numeric-binary\" => numericAndBinaryNamespaceMemberType(namespace, name)\n    case \"host\" => hostNamespaceMemberType(namespace, name)\n    case \"structured-data\" => structuredDataNamespaceMemberType(namespace, name)\n    case \"scalar\" => scalarNamespaceMemberType(namespace, name)\n    case _ => None\n  }\n}\n\nexport function bindingIndex(bindings: Array<TypeBinding>, name: string) -> int {\n  let mut index = 0\n  for binding in bindings {\n    if binding.name == name {\n      return index\n    }\n    index += 1\n  }\n  -1\n}\n\nexport function typeBindingKey(parameter: TypeValue) -> string {\n  \"{parameter.origin.byteLength()}:{parameter.origin}{parameter.name}\"\n}\n\nexport function scopeCallParameters(\n  parameters: Array<TypeValue>,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> Array<TypeValue> {\n  let mut scoped: Array<TypeValue> = []\n  for parameter in parameters {\n    scoped.push(TypeValue {\n      ...parameter,\n      origin: \"call-scheme:{moduleIndex}:{node.lo}:{node.hi}:{parameter.origin}\",\n    })\n  }\n  scoped\n}\n\nexport function instantiateCallType(\n  value: TypeValue,\n  parameters: Array<TypeValue>,\n  scoped: Array<TypeValue>,\n) -> TypeValue {\n  let mut bindings: Array<TypeBinding> = []\n  let mut index = 0\n  for parameter in parameters {\n    match scoped.get(index) {\n      case Some(variable) => bindTypeVariable(bindings, parameter, variable, false)\n      case None => ()\n    }\n    index += 1\n  }\n  applyBindings(value, bindings)\n}\n\nexport function bindTypeVariable(\n  bindings: Array<TypeBinding>,\n  parameter: TypeValue,\n  typeValue: TypeValue,\n  widenLiteral: bool,\n) -> () {\n  let mut target = bindings\n  let name = typeBindingKey(parameter)\n  let index = bindingIndex(target, name)\n  if index >= 0 {\n    return ()\n  }\n  target.push(TypeBinding {\n    name: name,\n    typeValue: if widenLiteral { widen(typeValue) } else { typeValue },\n  })\n}\n\nfunction collectTypeArrayBindings(\n  expected: Array<TypeValue>,\n  actual: Array<TypeValue>,\n  bindings: Array<TypeBinding>,\n  widenLiteral: bool,\n  parameters: Array<TypeValue>,\n) -> () {\n  let mut index = 0\n  for nested in expected {\n    match actual.get(index) {\n      case Some(found) => collectTypeBindings(\n        nested,\n        found,\n        bindings,\n        widenLiteral,\n        parameters,\n      )\n      case None => ()\n    }\n    index += 1\n  }\n  ()\n}\n\nexport function collectTypeBindings(\n  expected: TypeValue,\n  actual: TypeValue,\n  bindings: Array<TypeBinding>,\n  widenLiteral: bool,\n  parameters: Array<TypeValue>,\n) -> () {\n  // An unsolved expected component provides no evidence for a scheme slot.\n  // Actual unknown inputs still retain their uncertainty during input binding.\n  if !widenLiteral && actual.kind == \"unknown\" { return () }\n  // This marker carries an unsolved call slot, not evidence about its type.\n  // A concrete sibling (for example the callback result) may still solve it.\n  if actual.kind == \"unknown\" && actual.origin == \"generic-call-expectation\" {\n    return ()\n  }\n  if expected.kind == \"rigid\" {\n    // Only this invocation's instantiated scheme is solvable. Caller rigids\n    // remain rigid even during recursion through the same declaration.\n    let mut owned = false\n    for parameter in parameters {\n      if typeEqual(expected, parameter) { owned = true }\n    }\n    if !owned { return () }\n    // Stage 0 leaves an Unknown-fed scheme slot empty. Self-host builtin\n    // generics are rigid values, so binding Unknown preserves the same\n    // unresolved result as an observable hole.\n    if typeEqual(expected, actual) || typeContains(\n      actual,\n      (component: TypeValue) => typeEqual(component, expected),\n    ) {\n      return ()\n    }\n    bindTypeVariable(bindings, expected, actual, widenLiteral)\n    return ()\n  }\n  if expected.kind == \"union\" {\n    for member in expected.members {\n      collectTypeBindings(member, actual, bindings, widenLiteral, parameters)\n    }\n    return ()\n  }\n  if expected.kind == \"constructor\" && actual.kind == \"constructor\" &&\n    expected.name == actual.name &&\n    expected.arguments.length == actual.arguments.length {\n    return collectTypeArrayBindings(\n      expected.arguments,\n      actual.arguments,\n      bindings,\n      widenLiteral,\n      parameters,\n    )\n  }\n  if (expected.kind == \"enum\" || expected.kind == \"nominal-record\" ||\n    expected.kind == \"newtype\") &&\n    expected.kind == actual.kind && expected.identity == actual.identity &&\n    expected.origin == actual.origin &&\n    expected.arguments.length == actual.arguments.length {\n    return collectTypeArrayBindings(\n      expected.arguments,\n      actual.arguments,\n      bindings,\n      widenLiteral,\n      parameters,\n    )\n  }\n  if expected.kind == \"record\" && actual.kind == \"record\" &&\n    expected.fields.length == actual.fields.length {\n    let mut index = 0\n    while index < expected.fields.length {\n      match [expected.fieldNames.get(index), actual.fieldNames.get(index)] {\n        case [Some(expectedName), Some(actualName)] => if expectedName ==\n          actualName {\n          match [expected.fields.get(index), actual.fields.get(index)] {\n            case [Some(expectedField), Some(actualField)] => collectTypeBindings(\n              expectedField,\n              actualField,\n              bindings,\n              widenLiteral,\n              parameters,\n            )\n            case _ => ()\n          }\n        }\n        case _ => ()\n      }\n      index += 1\n    }\n    return ()\n  }\n  if expected.kind == \"function\" && actual.kind == \"function\" {\n    collectTypeArrayBindings(\n      expected.parameters,\n      actual.parameters,\n      bindings,\n      widenLiteral,\n      parameters,\n    )\n    match [expected.variadic.get(0), actual.variadic.get(0)] {\n      case [Some(expectedVariadic), Some(actualVariadic)] => collectTypeBindings(\n        expectedVariadic,\n        actualVariadic,\n        bindings,\n        widenLiteral,\n        parameters,\n      )\n      case _ => ()\n    }\n    match [expected.result.get(0), actual.result.get(0)] {\n      case [Some(expectedResult), Some(actualResult)] => collectTypeBindings(\n        expectedResult,\n        actualResult,\n        bindings,\n        widenLiteral,\n        parameters,\n      )\n      case _ => ()\n    }\n  }\n  ()\n}\n\nfunction typeBindingComponentReplacement(\n  value: TypeValue,\n  bindings: Array<TypeBinding>,\n) -> Option<TypeValue> {\n  if value.kind != \"rigid\" {\n    return None\n  }\n  for binding in bindings {\n    if typeBindingKey(value) == binding.name {\n      return Some(binding.typeValue)\n    }\n  }\n  Some(value)\n}\n\nexport function applyBindings(value: TypeValue, bindings: Array<TypeBinding>) -> TypeValue {\n  transformTypeComponents(\n    value,\n    (component: TypeValue) => typeBindingComponentReplacement(\n      component,\n      bindings,\n    ),\n  )\n}\n\nfunction nominalDefinitionModule(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n) -> int {\n  match recordDefinitionForType(state, moduleIndex, value) {\n    case Some(definition) => return definition.moduleIndex\n    case None => ()\n  }\n  match enumDefinitionForType(state, moduleIndex, value) {\n    case Some(definition) => return definition.moduleIndex\n    case None => ()\n  }\n  match newtypeDefinitionForType(state, moduleIndex, value) {\n    case Some(definition) => return definition.moduleIndex\n    case None => ()\n  }\n  -1\n}\n\nexport function typeConforms(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n  protocol: string,\n) -> bool {\n  let widened = widen(value)\n  if widened.kind == \"rigid\" {\n    return rigidProtocolBound(state, widened, protocol)\n  }\n  if widened.kind == \"nominal-record\" ||\n    widened.kind == \"enum\" || widened.kind == \"newtype\" ||\n    widened.kind == \"foreign\" {\n    let definitionModule = nominalDefinitionModule(\n      state,\n      moduleIndex,\n      widened,\n    )\n    if widened.kind == \"foreign\" {\n      for conformance in state.conformances {\n        let owner = moduleIdentityAt(state, conformance.moduleIndex)\n        if conformance.protocol == protocol &&\n          (widened.identity == \"{owner}::{conformance.typeName}\" ||\n            widened.origin == owner && widened.identity == conformance.typeName) {\n          return conformance.moduleIndex == moduleIndex || conformance.derived\n        }\n      }\n      return false\n    }\n    let index = protocolConformanceIndex(\n      state,\n      definitionModule,\n      widened.identity,\n      protocol,\n    )\n    return match state.conformances.get(index) {\n      case Some(conformance) => definitionModule == moduleIndex || conformance.derived\n      case None => false\n    }\n  }\n  false\n}\n\nexport function conformanceTypeText(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n) -> string {\n  let owner = nominalDefinitionModule(state, moduleIndex, value)\n  if owner >= 0 && owner != moduleIndex {\n    return \"{moduleIdentityAt(state, owner)}::{typeText(value)}\"\n  }\n  typeText(value)\n}\n\nexport function checkFunctionBounds(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  definition: FunctionDefinition,\n  parameters: Array<TypeValue>,\n  bindings: Array<TypeBinding>,\n) -> () {\n  for bound in definition.bounds {\n    let mut index = -1\n    for parameter in parameters {\n      if parameter.name == bound.parameterName {\n        index = bindingIndex(bindings, typeBindingKey(parameter))\n      }\n    }\n    if index >= 0 {\n      match bindings.get(index) {\n        case Some(binding) => if !typeConforms(\n          state,\n          moduleIndex,\n          binding.typeValue,\n          bound.protocol,\n        ) {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5522\",\n            \"`{conformanceTypeText(state, moduleIndex, binding.typeValue)}` does not satisfy protocol bound `{bound.protocol}`\",\n            \"\",\n            node,\n          )\n        }\n        case None => ()\n      }\n    }\n  }\n  ()\n}\n\nexport function protocolCallResult(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  callee: SyntaxNode,\n) -> Option<TypeValue> {\n  if callee.kind != \"expression/member\" {\n    return None\n  }\n  let object = match child(callee, \"object\") {\n    case Some(found) => found\n    case None => return None\n  }\n  let field = match child(callee, \"field\") {\n    case Some(found) => text(source, found)\n    case None => return None\n  }\n  if !serviceBuiltinNamespaceObject(service, state, moduleIndex, source, object) {\n    return None\n  }\n  let protocol = text(source, object)\n  match protocolStaticMemberType(protocol, field) {\n    case Some(method) => return method.result.get(0)\n    case None => ()\n  }\n  if protocol == \"JSON\" && field == \"stringify\" {\n    return Some(constructor(\n      \"Result\",\n      [primitive(\"string\"), primitive(\"string\")],\n    ))\n  }\n  None\n}\n\nexport function protocolStaticMemberType(\n  namespace: string,\n  member: string,\n) -> Option<TypeValue> {\n  match builtinProtocolDefinition(namespace) {\n    case Some(definition) => match protocolMethodDefinition(definition, member) {\n      case Some(method) => Some(method.typeValue)\n      case None => None\n    }\n    case None => None\n  }\n}\n\nexport function rigidProtocolBound(\n  state: CheckerState,\n  value: TypeValue,\n  protocol: string,\n) -> bool {\n  if value.kind != \"rigid\" {\n    return false\n  }\n  for definition in state.functions {\n    let mut parameterIndex = 0\n    for parameterName in definition.typeParameters {\n      if parameterName == value.name {\n        match definition.typeParameterOrigins.get(parameterIndex) {\n          case Some(parameterOrigin) => if parameterOrigin == value.origin {\n            for bound in definition.bounds {\n              if bound.parameterName == value.name &&\n                bound.protocol == protocol {\n                return true\n              }\n            }\n          }\n          case None => ()\n        }\n      }\n      parameterIndex += 1\n    }\n  }\n  false\n}\n",
      "sourceSha256": "1e7a01fb79246f255444948f7e4a595d2118a3e30f2994821aa4c6346690bbc9"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/model.tpz",
      "language": "topaz",
      "bytes": 16911,
      "sha256": "d977acc55ff361d62c44a678eefad90b7c5447dc741814e5cc837f00afd0fb6b",
      "content": "// Shared data contracts for the acyclic checker module graph.\n// Records carry state, signatures, and call plans across leaves; semantic work\n// remains with type, expression, call, statement, and body modules.\n\nimport types {\n  KnownLiteralRender,\n  PreviewCheckDiagnostic,\n  PreviewResolvedDeclaration,\n  PreviewTypeAtom,\n  PreviewTypedCall,\n  PreviewTypedCapture,\n  PreviewTypedNode,\n  ResolveResult,\n  SyntaxNode,\n}\nimport checker_types { TypeValue }\n\n// Callback boundary that keeps expression, call, statement, and body recursion acyclic.\nexport record CheckerRequest {\n  kind: string,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  typeValue: TypeValue,\n}\n\nexport record CheckerResponse {\n  typeValue: TypeValue,\n  boolValue: bool,\n}\n\nexport type CheckerService = (CheckerState, CheckerRequest) -> CheckerResponse\n\nexport function serviceInferExpression(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n) -> TypeValue {\n  service(state, CheckerRequest {\n    kind: \"infer-expression\",\n    moduleIndex: moduleIndex,\n    source: source,\n    node: expression,\n    typeValue: emptyType(\"unknown\"),\n  }).typeValue\n}\n\nexport function serviceBuiltinNamespaceObject(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  expression: SyntaxNode,\n) -> bool {\n  service(state, CheckerRequest {\n    kind: \"builtin-namespace-object\",\n    moduleIndex: moduleIndex,\n    source: source,\n    node: expression,\n    typeValue: emptyType(\"unknown\"),\n  }).boolValue\n}\n\nexport function serviceCheckBlock(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  block: SyntaxNode,\n) -> TypeValue {\n  service(state, CheckerRequest {\n    kind: \"check-block\",\n    moduleIndex: moduleIndex,\n    source: source,\n    node: block,\n    typeValue: emptyType(\"unknown\"),\n  }).typeValue\n}\n\nexport function serviceCheckBlockExpected(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  block: SyntaxNode,\n  expected: TypeValue,\n) -> TypeValue {\n  serviceCheckBlockExpectedResult(service, state, moduleIndex, source, block, expected, true)\n}\n\nexport function serviceCheckBlockExpectedResult(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  block: SyntaxNode,\n  expected: TypeValue,\n  checkResult: bool,\n) -> TypeValue {\n  let mut contexts = state.expectedExpressions\n  contexts.push(ExpectedExpressionContext {\n    kind: block.kind, lo: block.lo, hi: block.hi,\n    typeValue: expected, checkResult: checkResult,\n  })\n  let result = service(state, CheckerRequest {\n    kind: \"check-block-expected\",\n    moduleIndex: moduleIndex,\n    source: source,\n    node: block,\n    typeValue: expected,\n  }).typeValue\n  contexts.pop()\n  result\n}\n\nexport function serviceGateCollectionKey(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  key: TypeValue,\n) -> () {\n  let _ = service(state, CheckerRequest {\n    kind: \"gate-collection-key\",\n    moduleIndex: moduleIndex,\n    source: (\"\").encodeUtf8(),\n    node: node,\n    typeValue: key,\n  })\n  ()\n}\n\n// This decodes the parser's high type-parameter component and low bound ordinal.\nexport const TYPE_BOUND_INDEX_STRIDE = 4294967296\n\n// These decimal limits are u64::MAX divided by each unit's millisecond multiplier.\nexport const MAX_DURATION_MILLISECONDS = \"18446744073709551615\"\n\nexport const MAX_DURATION_SECONDS = \"18446744073709551\"\n\nexport const MAX_DURATION_MINUTES = \"307445734561825\"\n\n// Text parsing represents i64::MIN without first constructing an overflowing positive literal.\nexport const MINIMUM_INT_DECIMAL = \"-9223372036854775808\"\n\n// Constant integer power accepts the same unsigned 32-bit exponent range as runtime power.\nexport const MAX_CONSTANT_EXPONENT = 4294967295\n\nexport enum FoldedConstant {\n  Integer(BigInt),\n  Floating(float),\n  Length(string, int),\n  Text(string),\n  Unit,\n  Boolean(bool),\n  Null,\n  Rendered(KnownLiteralRender, bool, int),\n  NonNull,\n  Unknown,\n}\n\nexport record SymbolType {\n  constantValue: Option<FoldedConstant>,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  name: string,\n  typeValue: TypeValue,\n  mutable: bool,\n}\n\nexport record RecordField {\n  name: string,\n  typeValue: TypeValue,\n  hasDefault: bool,\n}\n\nexport record RecordDefinition {\n  moduleIndex: int,\n  name: string,\n  typeParameters: Array<string>,\n  fields: Array<RecordField>,\n}\n\nexport record EnumVariant {\n  name: string,\n  payloads: Array<TypeValue>,\n}\n\nexport record EnumDefinition {\n  moduleIndex: int,\n  name: string,\n  typeParameters: Array<string>,\n  variants: Array<EnumVariant>,\n}\n\nexport record NewtypeDefinition {\n  moduleIndex: int,\n  name: string,\n  typeParameters: Array<string>,\n  base: TypeValue,\n}\n\nexport record AliasCollectionKey {\n  node: SyntaxNode,\n  key: TypeValue,\n}\n\nexport record AliasDefinition {\n  moduleIndex: int,\n  name: string,\n  typeParameters: Array<string>,\n  declaration: SyntaxNode,\n  origin: string,\n  body: TypeValue,\n  resolution: string,\n  deferCollectionKeys: bool,\n  collectionKeys: Array<AliasCollectionKey>,\n}\n\n// Callable metadata computed from an actual builtin value binding. This is not\n// a source function declaration or a fabricated function-body observation.\nexport record BoundBuiltin {\n  typeValue: TypeValue,\n  receiverType: TypeValue,\n  member: string,\n  boundary: Array<string>,\n  typeParameters: Array<string>,\n  signature: Option<CallSignature>,\n  target: string,\n}\n\nexport record FunctionDefinition {\n  moduleIndex: int,\n  name: string,\n  lo: int,\n  hi: int,\n  typeParameters: Array<string>,\n  typeParameterOrigins: Array<string>,\n  parameterNames: Array<string>,\n  parameterTypes: Array<TypeValue>,\n  parameterDefaults: Array<bool>,\n  variadic: Array<TypeValue>,\n  result: TypeValue,\n  bounds: Array<FunctionBound>,\n}\n\nexport record FunctionBound {\n  parameterName: string,\n  protocol: string,\n}\n\nexport record ProtocolMethodDefinition {\n  name: string,\n  parameterNames: Array<string>,\n  typeValue: TypeValue,\n}\n\nexport record ProtocolDefinition {\n  name: string,\n  methods: Array<ProtocolMethodDefinition>,\n}\n\nexport record ProtocolConformance {\n  moduleIndex: int,\n  typeName: string,\n  protocol: string,\n  derived: bool,\n}\n\nexport record ReceiverMethodDefinition {\n  moduleIndex: int,\n  typeName: string,\n  name: string,\n  functionIndex: int,\n  exported: bool,\n}\n\nexport record TypeParameterFact {\n  moduleIndex: int,\n  owner: string,\n  name: string,\n  origin: string,\n}\n\nexport record ModuleSyntax {\n  moduleIndex: int,\n  sourceOrdinal: int,\n  identity: string,\n  source: Bytes,\n  root: SyntaxNode,\n  generatedStd: bool,\n}\n\nexport record LoopFrame {\n  label: string,\n  valueLoop: bool,\n  bareTarget: bool,\n  bareError: string,\n  expected: Option<TypeValue>,\n  breaks: Array<TypeValue>,\n}\n\n// Single owner of phase catalogs; service callbacks update it instead of copying caches.\nexport record CheckerState {\n  languageMode: string,\n  constantRenderEpoch: Array<int>,\n  resolved: ResolveResult,\n  modules: Array<ModuleSyntax>,\n  declarationIndexes: Map<string, int>,\n  valueDeclarationIndexesByModule: Map<string, Array<int>>,\n  namespaceImportIndexes: Map<string, int>,\n  referenceIndexes: Map<string, int>,\n  scopeIndexes: Map<string, int>,\n  symbolIndexes: Map<string, int>,\n  nodeIndexes: Map<string, int>,\n  callIndexes: Map<string, int>,\n  functionIndexes: Map<string, int>,\n  functionNameIndexes: Map<string, int>,\n  receiverMethodIndexes: Map<string, int>,\n  protocolIndexes: Map<string, int>,\n  conformanceIndexes: Map<string, int>,\n  conformanceTypeIndexes: Map<string, int>,\n  recordIndexes: Map<string, int>,\n  enumIndexes: Map<string, int>,\n  newtypeIndexes: Map<string, int>,\n  aliasIndexes: Map<string, int>,\n  symbols: Array<SymbolType>,\n  records: Array<RecordDefinition>,\n  enums: Array<EnumDefinition>,\n  newtypes: Array<NewtypeDefinition>,\n  aliases: Array<AliasDefinition>,\n  functions: Array<FunctionDefinition>,\n  receiverMethods: Array<ReceiverMethodDefinition>,\n  protocols: Array<ProtocolDefinition>,\n  pendingFunctions: Array<bool>,\n  functionAliases: Map<string, int>,\n  boundBuiltins: Map<string, BoundBuiltin>,\n  conformances: Array<ProtocolConformance>,\n  typeParameters: Array<TypeParameterFact>,\n  activeFunctions: Array<int>,\n  expectedReturns: Array<ReturnExpectation>,\n  returnJoins: Array<Array<TypeValue>>,\n  expectedExpressions: Array<ExpectedExpressionContext>,\n  bareBindingExpressions: Array<SyntaxNode>,\n  literalJoinContexts: Array<int>,\n  branchJoinContexts: Array<int>,\n  statementExpressionContexts: Array<int>,\n  typeCapabilitySuppressions: Array<bool>,\n  loopFrames: Array<LoopFrame>,\n  loopFloors: Array<int>,\n  pipeValues: Array<LeadingCallArgument>,\n  nodes: Array<PreviewTypedNode>,\n  calls: Array<PreviewTypedCall>,\n  captures: Array<PreviewTypedCapture>,\n  diagnostics: Array<PreviewCheckDiagnostic>,\n  inferenceSolutions: Map<string, TypeValue>,\n  nextInference: int,\n}\n\nexport record ExpectedExpressionContext {\n  kind: string,\n  lo: int,\n  hi: int,\n  typeValue: TypeValue,\n  // False retains inference context but delegates this result's comparison.\n  checkResult: bool,\n}\n\nexport record ReturnExpectation {\n  typeValue: TypeValue,\n  // Named functions check each return; lambda results are checked as callables.\n  checkResult: bool,\n}\n\nexport record TypeBinding {\n  name: string,\n  typeValue: TypeValue,\n}\n\nexport record TypeTarget {\n  moduleIndex: int,\n  name: string,\n}\n\nexport record NamedNominalTarget {\n  semanticKind: string,\n  diagnosticKind: string,\n  typeArgumentCount: int,\n}\n\nexport record PatternCoverage {\n  irrefutable: bool,\n  keys: Array<string>,\n}\n\nexport record CoverageGap {\n  decidable: bool,\n  missing: Array<string>,\n}\n\nexport record InferredCallArguments {\n  types: Array<TypeValue>,\n  nodes: Array<SyntaxNode>,\n  protocolConformance: string,\n}\n\nexport record CallResultCandidates {\n  nominal: Option<TypeValue>,\n  protocol: Option<TypeValue>,\n}\n\n// The existing pipe stack owns the saved input until its first contextual inference.\nexport record LeadingCallArgument {\n  moduleIndex: int,\n  node: SyntaxNode,\n  stage: SyntaxNode,\n  activeFunctionDepth: int,\n  returnDepth: int,\n  expectedExpressionDepth: int,\n  values: Array<TypeValue>,\n  diagnostics: Array<PreviewCheckDiagnostic>,\n}\n\nexport record CaptureTarget {\n  declaration: PreviewResolvedDeclaration,\n  name: string,\n  typeValue: Array<PreviewTypeAtom>,\n  ambient: bool,\n}\n\nexport record CallArgumentPlan {\n  slots: Array<int>,\n  leadingSlot: int,\n  resultUnknown: bool,\n}\n\nexport record CallSignature {\n  parameterNames: Array<string>,\n  parameterDefaults: Array<bool>,\n  parameterCount: int,\n  variadic: bool,\n  positionalOnlyIdentity: string,\n}\n\nexport record BuiltinFunction {\n  typeValue: TypeValue,\n  callSignature: CallSignature,\n}\n\nexport record UserProtocolCallTarget {\n  protocolName: string,\n  method: ProtocolMethodDefinition,\n}\n\n// Selected call signature and argument plan before contextual inference completes.\nexport record CallPreparation {\n  callee: SyntaxNode,\n  diagnosticNode: SyntaxNode,\n  declaredType: TypeValue,\n  contextualType: TypeValue,\n  schemeParameters: Array<TypeValue>,\n  receiverType: TypeValue,\n  optionalContainer: string,\n  referencedDefinition: Option<FunctionDefinition>,\n  userProtocolTarget: Option<UserProtocolCallTarget>,\n  argumentPlan: CallArgumentPlan,\n  bindings: Array<TypeBinding>,\n  leading: Option<LeadingCallArgument>,\n  projectedMember: string,\n}\n\nexport record CompletedCall {\n  calleeType: TypeValue,\n  resultType: TypeValue,\n}\n\nexport function emptyType(kind: string) -> TypeValue {\n  TypeValue {\n    kind: kind,\n    name: \"\",\n    value: \"\",\n    identity: \"\",\n    origin: \"\",\n    arguments: [],\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function primitive(name: string) -> TypeValue {\n  TypeValue {\n    kind: \"primitive\",\n    name: name,\n    value: \"\",\n    identity: \"\",\n    origin: \"\",\n    arguments: [],\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function literal(name: string, spelling: string) -> TypeValue {\n  TypeValue {\n    kind: \"literal\",\n    name: name,\n    value: spelling,\n    identity: \"\",\n    origin: \"\",\n    arguments: [],\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function nominal(kind: string, identity: string, arguments: Array<TypeValue>) -> TypeValue {\n  TypeValue {\n    kind: kind,\n    name: \"\",\n    value: \"\",\n    identity: identity,\n    origin: \"\",\n    arguments: arguments,\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function nominalInModule(\n  kind: string,\n  identity: string,\n  arguments: Array<TypeValue>,\n  moduleIdentity: string,\n) -> TypeValue {\n  TypeValue {\n    kind: kind,\n    name: \"\",\n    value: \"\",\n    identity: identity,\n    origin: moduleIdentity,\n    arguments: arguments,\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function constructor(name: string, arguments: Array<TypeValue>) -> TypeValue {\n  TypeValue {\n    kind: \"constructor\",\n    name: name,\n    value: \"\",\n    identity: \"\",\n    origin: \"\",\n    arguments: arguments,\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function functionType(\n  parameters: Array<TypeValue>,\n  variadic: Array<TypeValue>,\n  result: TypeValue,\n) -> TypeValue {\n  TypeValue {\n    kind: \"function\",\n    name: \"\",\n    value: \"\",\n    identity: \"\",\n    origin: \"\",\n    arguments: [],\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: parameters,\n    variadic: variadic,\n    result: [result],\n  }\n}\n\nexport function inference(index: int) -> TypeValue {\n  TypeValue {\n    kind: \"inference-variable\",\n    name: \"\",\n    value: \"{index}\",\n    identity: \"\",\n    origin: \"\",\n    arguments: [],\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function rigid(name: string, origin: string) -> TypeValue {\n  TypeValue {\n    kind: \"rigid\",\n    name: name,\n    value: \"\",\n    identity: \"\",\n    origin: origin,\n    arguments: [],\n    members: [],\n    fieldNames: [],\n    fields: [],\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\nexport function structural(fieldNames: Array<string>, fields: Array<TypeValue>) -> TypeValue {\n  let mut orderedNames: Array<string> = []\n  let mut orderedFields: Array<TypeValue> = []\n  let mut sourceIndex = 0\n  for name in fieldNames {\n    let field = match fields.get(sourceIndex) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n    let mut inserted = false\n    let mut index = 0\n    while index < orderedNames.length {\n      let existing = match orderedNames.get(index) {\n        case Some(found) => found\n        case None => name\n      }\n      if name < existing {\n        orderedNames.insert(index, name)\n        orderedFields.insert(index, field)\n        inserted = true\n        break\n      }\n      index += 1\n    }\n    if !inserted {\n      orderedNames.push(name)\n      orderedFields.push(field)\n    }\n    sourceIndex += 1\n  }\n  TypeValue {\n    kind: \"record\",\n    name: \"\",\n    value: \"\",\n    identity: \"\",\n    origin: \"\",\n    arguments: [],\n    members: [],\n    fieldNames: orderedNames,\n    fields: orderedFields,\n    parameters: [],\n    variadic: [],\n    result: [],\n  }\n}\n\n\n// Mutable aggregate contents are facts for one evaluation phase, not cached\n// runtime values. Calls end their validity; callable checks restore the parent.\nexport function constantRenderEpoch(state: CheckerState) -> int {\n  match state.constantRenderEpoch.get(0) { case Some(value) => value; case None => 0 }\n}\nexport function advanceConstantRenderEpoch(state: CheckerState) -> () {\n  let current = constantRenderEpoch(state)\n  let mut epoch = state.constantRenderEpoch\n  epoch[0] = current + 1\n}\nexport function restoreConstantRenderEpoch(state: CheckerState, saved: int) -> () {\n  let mut epoch = state.constantRenderEpoch\n  epoch[0] = saved\n}\n\nexport function lengthType(unit: string) -> TypeValue {\n  nominal(\"newtype\", \"builtin:Length\", [nominal(\"newtype\", \"builtin:{unit}\", [])])\n}\nexport function lengthUnit(value: TypeValue) -> string {\n  if value.kind != \"newtype\" || value.identity != \"builtin:Length\" || value.origin != \"\" || value.arguments.length != 1 { return \"\" }\n  let unit = value.arguments[0]\n  if unit.kind != \"newtype\" || unit.origin != \"\" || unit.arguments.length != 0 { return \"\" }\n  match unit.identity { case \"builtin:Pt\" => \"Pt\"; case \"builtin:Mm\" => \"Mm\"; case \"builtin:Cm\" => \"Cm\"; case \"builtin:In\" => \"In\"; case \"builtin:Em\" => \"Em\"; case _ => \"\" }\n}\n",
      "sourceSha256": "d977acc55ff361d62c44a678eefad90b7c5447dc741814e5cc837f00afd0fb6b"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/nominals.tpz",
      "language": "topaz",
      "bytes": 37454,
      "sha256": "3a196752d9d6b2f96d3cef37da189f2c3e13e94aa5a59c3bb7d8770c7e1b75c4",
      "content": "import literal { literalAttribute, decodeIntegerLiteral, decodeDecimalFloatLiteral }\n// Predeclaration and filling of record, enum, newtype, and alias definitions.\n// Public type identity remains in shared exchange types; this leaf populates the\n// checker-private nominal catalogs consumed by later phases.\n\nimport types {\n  PreviewResolvedDeclaration,\n  SyntaxNode,\n}\nimport checker_types { TypeValue }\nimport checker.model {\n  AliasCollectionKey,\n  AliasDefinition,\n  CheckerService,\n  CheckerState,\n  EnumDefinition,\n  EnumVariant,\n  ModuleSyntax,\n  NewtypeDefinition,\n  ProtocolDefinition,\n  ProtocolMethodDefinition,\n  RecordDefinition,\n  RecordField,\n  TypeTarget,\n  constructor,\n  emptyType,\n  functionType,\n  literal,\n  lengthType,\n  lengthUnit,\n  nominal,\n  nominalInModule,\n  primitive,\n  rigid,\n  serviceGateCollectionKey,\n  structural,\n}\nimport checker.type_algebra {\n  transformTypeComponents,\n  typeEqual,\n  typeText,\n  unionType,\n}\nimport checker.syntax_index {\n  activeTypeParameter,\n  addDiagnostic,\n  addNode,\n  aliasDefinitionIndex,\n  boolAttribute,\n  child,\n  children,\n  containsString,\n  declarationFor,\n  definitionNameKey,\n  enumDefinitionIndex,\n  moduleAt,\n  moduleIdentityAt,\n  moduleIndexByIdentity,\n  namedNominalTarget,\n  newtypeDefinitionIndex,\n  protocolDefinitionIndex,\n  recordDefinitionIndex,\n  referenceFor,\n  registerTypeParameters,\n  replaceEnumDefinition,\n  replaceNewtypeDefinition,\n  replaceRecordDefinition,\n  text,\n  typeParameterNames,\n  typeParameterOrigin,\n  unwrapExport,\n}\n\nfunction primitiveNamedType(name: string) -> Option<TypeValue> {\n  match name {\n    case \"int\" => Some(primitive(\"int\"))\n    case \"float\" => Some(primitive(\"float\"))\n    case \"string\" => Some(primitive(\"string\"))\n    case \"bool\" => Some(primitive(\"bool\"))\n    case _ => None\n  }\n}\n\nfunction terminalNamedType(name: string) -> Option<TypeValue> {\n  match name {\n    case \"template\" => Some(emptyType(\"template\"))\n    case \"JSONValue\" => Some(emptyType(\"json-value\"))\n    case \"File\" => Some(emptyType(\"file\"))\n    case \"Bytes\" => Some(emptyType(\"bytes\"))\n    case \"ByteBuffer\" => Some(emptyType(\"byte-buffer\"))\n    case \"Path\" => Some(emptyType(\"path\"))\n    case \"Regex\" => Some(emptyType(\"regex\"))\n    case \"Match\" => Some(emptyType(\"match\"))\n    case \"TOMLValue\" => Some(emptyType(\"toml-value\"))\n    case \"URL\" => Some(emptyType(\"url\"))\n    case \"Date\" => Some(emptyType(\"date\"))\n    case \"BigInt\" => Some(emptyType(\"big-int\"))\n    case \"Decimal\" => Some(emptyType(\"decimal\"))\n    case \"RoundingMode\" => Some(emptyType(\"rounding-mode\"))\n    case _ => None\n  }\n}\n\nfunction builtinTypeConstructorArity(name: string) -> int {\n  match name {\n    case \"Array\" | \"Set\" | \"Option\" => 1\n    case \"Map\" | \"Result\" => 2\n    case _ => -1\n  }\n}\n\n// Alias expansion can precede the filling of nominal key fields. Keep each\n// alias's own key checks at its declaration's original position in that pass.\nfunction gateNamedCollectionKey(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  key: TypeValue,\n  origin: string,\n) -> () {\n  for alias in state.aliases {\n    if alias.resolution == \"active\" && alias.deferCollectionKeys &&\n      alias.moduleIndex == moduleIndex && alias.origin == origin {\n      let mut keys = alias.collectionKeys\n      keys.push(AliasCollectionKey { node: node, key: key })\n      return ()\n    }\n  };\n  serviceGateCollectionKey(service, state, moduleIndex, node, key)\n}\n\nexport function addTypeArgumentArityDiagnostic(\n  state: CheckerState,\n  moduleIndex: int,\n  subject: string,\n  expected: int,\n  found: int,\n  node: SyntaxNode,\n) -> () {\n  let suffix = if expected == 1 { \"\" } else { \"s\" }\n  addDiagnostic(\n    state,\n    moduleIndex,\n    \"TPZ5022\",\n    \"{subject} takes {expected} type argument{suffix}, found {found}\",\n    \"\",\n    node,\n  )\n}\n\nfunction typeParameterComponentReplacement(\n  value: TypeValue,\n  names: Array<string>,\n  arguments: Array<TypeValue>,\n) -> Option<TypeValue> {\n  if value.kind != \"rigid\" {\n    return None\n  }\n  let mut index = 0\n  for name in names {\n    if value.name == name {\n      return Some(match arguments.get(index) {\n        case Some(found) => found\n        case None => emptyType(\"unknown\")\n      })\n    }\n    index += 1\n  }\n  Some(value)\n}\n\nexport function substitute(\n  value: TypeValue,\n  names: Array<string>,\n  arguments: Array<TypeValue>,\n) -> TypeValue {\n  transformTypeComponents(\n    value,\n    (component: TypeValue) => typeParameterComponentReplacement(\n      component,\n      names,\n      arguments,\n    ),\n  )\n}\n\nfunction typeDeclarationForName(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<PreviewResolvedDeclaration> {\n  for declaration in state.resolved.declarations {\n    if declaration.moduleIndex == moduleIndex &&\n      declaration.namespace == \"type\" && declaration.name == name {\n      return Some(declaration)\n    }\n  }\n  None\n}\n\nexport function targetType(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> TypeTarget {\n  let sourceName = match moduleAt(state, moduleIndex) {\n    case Some(module) => text(module.source, node)\n    case None => \"\"\n  }\n  match referenceFor(state, moduleIndex, node.lo, node.hi) {\n    case Some(reference) => {\n      let mut target = TypeTarget {\n        moduleIndex: if reference.targetModuleIndex >= 0 {\n          reference.targetModuleIndex\n        } else {\n          moduleIndex\n        },\n        name: if reference.targetName != \"\" {\n          reference.targetName\n        } else {\n          sourceName\n        },\n      }\n      match declarationFor(\n        state,\n        reference.targetModuleIndex,\n        reference.targetLo,\n        reference.targetHi,\n      ) {\n        case Some(declaration) => {\n          if declaration.targetModule != \"\" {\n            target = TypeTarget {\n              moduleIndex: moduleIndexByIdentity(\n                state,\n                declaration.targetModule,\n              ),\n              name: target.name,\n            }\n          }\n          if declaration.targetName != \"\" {\n            target = TypeTarget {\n              moduleIndex: target.moduleIndex,\n              name: declaration.targetName,\n            }\n          }\n        }\n        case None => ()\n      }\n      target\n    }\n    case None => match typeDeclarationForName(state, moduleIndex, sourceName) {\n      case Some(declaration) => TypeTarget {\n        moduleIndex: if declaration.targetModule != \"\" {\n          moduleIndexByIdentity(state, declaration.targetModule)\n        } else {\n          moduleIndex\n        },\n        name: if declaration.targetName != \"\" {\n          declaration.targetName\n        } else {\n          sourceName\n        },\n      }\n      case None => TypeTarget {\n        moduleIndex: moduleIndex,\n        name: sourceName,\n      }\n    }\n  }\n}\n\nfunction formLiteralType(state: CheckerState, moduleIndex: int, source: Bytes, node: SyntaxNode) -> TypeValue {\n  for attr in node.attributes { if attr.name == \"cooked\" { return literal(\"string\",attr.value) } }\n  let kind = literalAttribute(node,\"literalKind\")\n  let spelling = if kind == \"\" { text(source,node) } else { literalAttribute(node,\"literalSpelling\") }\n  if kind == \"bool\" {\n    return literal(\"bool\", spelling)\n  }\n  if kind == \"null\" {\n    return literal(\"null\", \"\")\n  }\n  if kind == \"float\" {\n    literal(\"float\", match decodeDecimalFloatLiteral(spelling) {case Some(value)=>\"{value}\";case None=>\"\"})\n  } else {\n    match decodeIntegerLiteral(spelling,false) {\n      case Some(value) => literal(\"int\", \"{value}\")\n      case None => {\n        addDiagnostic(state,moduleIndex,if state.languageMode == \"topaz-5.21\" { \"TPZ5001\" } else { \"TPZ5022\" },\"integer literal type `{spelling}` is out of range\",\"\",node)\n        emptyType(\"unknown\")\n      }\n    }\n  }\n}\n\nfunction formUnionType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  parameters: Array<string>,\n  origin: string,\n) -> TypeValue {\n  let mut members: Array<TypeValue> = []\n  for member in children(node, \"members\") {\n    members.push(formType(\n      service,\n      state,\n      moduleIndex,\n      source,\n      member,\n      parameters,\n      origin,\n    ))\n  }\n  unionType(members)\n}\n\nfunction formRecordType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  parameters: Array<string>,\n  origin: string,\n) -> TypeValue {\n  let mut names: Array<string> = []\n  let mut values: Array<TypeValue> = []\n  for field in children(node, \"fields\") {\n    let name = match child(field, \"name\") {\n      case Some(found) => text(source, found)\n      case None => \"\"\n    }\n    if containsString(names, name) {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5022\",\n        \"record type declares field `{name}` twice\",\n        \"\",\n        field,\n      )\n      continue\n    }\n    let value = match child(field, \"type\") {\n      case Some(typeNode) => formType(\n        service,\n        state,\n        moduleIndex,\n        source,\n        typeNode,\n        parameters,\n        origin,\n      )\n      case None => emptyType(\"unknown\")\n    }\n    names.push(name)\n    values.push(value)\n  }\n  structural(names, values)\n}\n\nfunction formFunctionType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  parameters: Array<string>,\n  origin: string,\n) -> TypeValue {\n  let mut fixed: Array<TypeValue> = []\n  let mut variadic: Array<TypeValue> = []\n  for parameter in children(node, \"parameters\") {\n    let formed = match child(parameter, \"type\") {\n      case Some(typeNode) => formType(\n        service,\n        state,\n        moduleIndex,\n        source,\n        typeNode,\n        parameters,\n        origin,\n      )\n      case None => emptyType(\"unknown\")\n    }\n    if boolAttribute(parameter, \"variadic\") {\n      variadic.push(formed)\n    } else {\n      fixed.push(formed)\n    }\n  }\n  let result = match child(node, \"returnType\") {\n    case Some(typeNode) => formType(\n      service,\n      state,\n      moduleIndex,\n      source,\n      typeNode,\n      parameters,\n      origin,\n    )\n    case None => primitive(\"unit\")\n  }\n  functionType(fixed, variadic, result)\n}\n\nfunction formNamedType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  parameters: Array<string>,\n  origin: string,\n) -> TypeValue {\n  let nameNode = match child(node, \"name\") {\n    case Some(found) => found\n    case None => node\n  }\n  let name = text(source, nameNode)\n  let argumentNodes = children(node, \"arguments\")\n  let argumentCount = argumentNodes.length\n  if state.languageMode == \"topaz-5.21\" && name == \"Length\" {\n    if argumentCount == 1 {\n      let written = formType(service,state,moduleIndex,source,argumentNodes[0],parameters,origin)\n      if written.kind == \"newtype\" && written.origin == \"\" && written.arguments.length == 0 {\n        let marker=written.identity.replace(\"builtin:\",\"\")\n        if written.identity == \"builtin:{marker}\" && (marker == \"Pt\" || marker == \"Mm\" || marker == \"Cm\" || marker == \"In\" || marker == \"Em\") {return lengthType(marker)}\n      }\n    }\n    addDiagnostic(state,moduleIndex,\"TPZ5001\",\"Length requires one compiler-owned Pt, Mm, Cm, In or Em marker\",\"\",nameNode)\n    return emptyType(\"unknown\")\n  }\n  if state.languageMode == \"topaz-5.21\" && (name == \"Pt\" || name == \"Mm\" || name == \"Cm\" || name == \"In\" || name == \"Em\") {\n    if argumentCount != 0 { addTypeArgumentArityDiagnostic(state,moduleIndex,\"unit marker `{name}`\",0,argumentCount,nameNode) }\n    return nominal(\"newtype\",\"builtin:{name}\",[])\n  }\n  if containsString(parameters, name) {\n    if argumentCount > 0 {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5022\",\n        \"type parameter `{name}` takes no type arguments\",\n        \"\",\n        nameNode,\n      )\n    }\n    return rigid(name, typeParameterOrigin(state, moduleIndex, name, origin))\n  }\n  match activeTypeParameter(state, moduleIndex, name) {\n    case Some(value) => {\n      if argumentCount > 0 {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5022\",\n          \"type parameter `{name}` takes no type arguments\",\n          \"\",\n          nameNode,\n        )\n      }\n      return value\n    }\n    case None => ()\n  }\n  match primitiveNamedType(name) {\n    case Some(value) => {\n      if argumentCount > 0 {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5022\",\n          \"primitive type `{name}` takes no type arguments\",\n          \"\",\n          nameNode,\n        )\n      }\n      return value\n    }\n    case None => ()\n  }\n  match terminalNamedType(name) {\n    case Some(value) => {\n      if argumentCount > 0 {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5022\",\n          \"`{name}` takes no type arguments\",\n          \"\",\n          nameNode,\n        )\n      }\n      return value\n    }\n    case None => ()\n  }\n  let constructorArity = builtinTypeConstructorArity(name)\n  if constructorArity >= 0 && argumentCount != constructorArity {\n    addTypeArgumentArityDiagnostic(\n      state,\n      moduleIndex,\n      \"`{name}`\",\n      constructorArity,\n      argumentCount,\n      nameNode,\n    )\n    return emptyType(\"unknown\")\n  }\n  if constructorArity >= 0 {\n    let mut arguments: Array<TypeValue> = []\n    for argument in argumentNodes {\n      arguments.push(formType(\n        service,\n        state,\n        moduleIndex,\n        source,\n        argument,\n        parameters,\n        origin,\n      ))\n    }\n    let formed = constructor(name, arguments)\n    if (name == \"Map\" || name == \"Set\") &&\n      state.typeCapabilitySuppressions.length == 0 {\n      match arguments.get(0) {\n        case Some(key) => gateNamedCollectionKey(\n          service,\n          state,\n          moduleIndex,\n          nameNode,\n          key,\n          origin,\n        )\n        case None => ()\n      }\n    }\n    return formed\n  }\n  let target = targetType(state, moduleIndex, nameNode)\n  let targetModule = target.moduleIndex\n  let targetName = target.name\n  let displayName = if node.kind == \"type/qualified\" {\n    let namespace = match child(node, \"namespace\") {\n      case Some(found) => text(source, found)\n      case None => \"\"\n    }\n    \"{namespace}.{name}\"\n  } else {\n    name\n  }\n  let aliasIndex = aliasDefinitionIndex(state, targetModule, targetName)\n  if aliasIndex >= 0 && targetModule == moduleIndex &&\n    node.kind != \"type/qualified\" {\n    match state.aliases.get(aliasIndex) {\n      case Some(alias) => if argumentCount != alias.typeParameters.length {\n        addTypeArgumentArityDiagnostic(\n          state,\n          moduleIndex,\n          \"type alias `{displayName}`\",\n          alias.typeParameters.length,\n          argumentCount,\n          nameNode,\n        )\n        return emptyType(\"unknown\")\n      }\n      case None => ()\n    }\n  }\n  let mut arguments: Array<TypeValue> = []\n  for argument in argumentNodes {\n    arguments.push(formType(\n      service,\n      state,\n      moduleIndex,\n      source,\n      argument,\n      parameters,\n      origin,\n    ))\n  }\n  match namedNominalTarget(state, targetModule, targetName) {\n    case Some(target) => {\n      if arguments.length != target.typeArgumentCount {\n        addTypeArgumentArityDiagnostic(\n          state,\n          moduleIndex,\n          \"{target.diagnosticKind} `{displayName}`\",\n          target.typeArgumentCount,\n          arguments.length,\n          nameNode,\n        )\n        return emptyType(\"unknown\")\n      }\n      return nominalInModule(\n        target.semanticKind,\n        targetName,\n        arguments,\n        moduleIdentityAt(state, targetModule),\n      )\n    }\n    case None => ()\n  }\n  if aliasIndex >= 0 {\n    return match state.aliases.get(aliasIndex) {\n      case Some(alias) => {\n        if arguments.length != alias.typeParameters.length {\n          let subject = if targetModule == moduleIndex &&\n            node.kind != \"type/qualified\" {\n            \"type alias `{displayName}`\"\n          } else {\n            \"`{displayName}`\"\n          }\n          addTypeArgumentArityDiagnostic(\n            state,\n            moduleIndex,\n            subject,\n            alias.typeParameters.length,\n            arguments.length,\n            nameNode,\n          )\n          emptyType(\"unknown\")\n        } else {\n          substitute(\n            resolveAliasBody(service, state, aliasIndex, moduleIndex, nameNode, true),\n            alias.typeParameters,\n            arguments,\n          )\n        }\n      }\n      case None => emptyType(\"unknown\")\n    }\n  }\n  if node.kind == \"type/qualified\" {\n    let namespace = match child(node, \"namespace\") {\n      case Some(found) => text(source, found)\n      case None => \"\"\n    }\n    return nominal(\"foreign\", \"{namespace}.{name}\", arguments)\n  }\n  nominal(\"foreign\", name, arguments)\n}\n\nexport function formType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n  parameters: Array<string>,\n  origin: string,\n) -> TypeValue {\n  match node.kind {\n    case \"type/unit\" => primitive(\"unit\")\n    case \"type/literal\" => formLiteralType(state, moduleIndex, source, node)\n    case \"type/union\" =>\n      formUnionType(service, state, moduleIndex, source, node, parameters, origin)\n    case \"type/record\" =>\n      formRecordType(service, state, moduleIndex, source, node, parameters, origin)\n    case \"type/function\" =>\n      formFunctionType(service, state, moduleIndex, source, node, parameters, origin)\n    case \"type/named\" | \"type/qualified\" =>\n      formNamedType(service, state, moduleIndex, source, node, parameters, origin)\n    case _ => emptyType(\"unknown\")\n  }\n}\n\nexport function predeclareNominals(state: CheckerState) -> () {\n  let mut records = state.records\n  let mut enums = state.enums\n  let mut newtypes = state.newtypes\n  let mut aliases = state.aliases\n  let mut recordIndexes = state.recordIndexes\n  let mut enumIndexes = state.enumIndexes\n  let mut newtypeIndexes = state.newtypeIndexes\n  let mut aliasIndexes = state.aliasIndexes\n  for module in state.modules {\n    for statement in module.root.children {\n      let item = unwrapExport(statement)\n      let nameNode = child(item, \"name\")\n      let name = match nameNode {\n        case Some(found) => text(module.source, found)\n        case None => \"\"\n      }\n      let parameters = typeParameterNames(module.source, item)\n      let nominalKind = match item.kind {\n        case \"statement/record\" => \"record\"\n        case \"statement/enum\" => \"enum\"\n        case \"statement/newtype\" => \"newtype\"\n        case _ => \"\"\n      }\n      let typeDeclaration = nominalKind != \"\" || item.kind == \"statement/type-alias\"\n      let reservedNominal = (nominalKind != \"\" && name == \"template\") || (typeDeclaration && state.languageMode == \"topaz-5.21\" && (name == \"Length\" || name == \"Pt\" || name == \"Mm\" || name == \"Cm\" || name == \"In\" || name == \"Em\"))\n      if reservedNominal {\n        let collision = if name == \"template\" {\n          \"the builtin `template` type\"\n        } else {\n          \"a compiler-owned type\"\n        }\n        addDiagnostic(\n          state,\n          module.moduleIndex,\n          \"TPZ5022\",\n          \"{nominalKind} name `{name}` collides with {collision}; choose another name\",\n          \"\",\n          match nameNode {\n            case Some(found) => found\n            case None => item\n          },\n        )\n      }\n      if !reservedNominal &&\n        (item.kind == \"statement/record\" || item.kind == \"statement/enum\" ||\n        item.kind == \"statement/newtype\" ||\n        item.kind == \"statement/type-alias\") {\n        registerTypeParameters(\n          state,\n          module.moduleIndex,\n          module.source,\n          item,\n        )\n      }\n      if !reservedNominal && item.kind == \"statement/record\" {\n        recordIndexes.insert(\n          definitionNameKey(module.moduleIndex, name),\n          records.length,\n        )\n        records.push(RecordDefinition {\n          moduleIndex: module.moduleIndex,\n          name: name,\n          typeParameters: parameters,\n          fields: [],\n        })\n      } else if !reservedNominal && item.kind == \"statement/enum\" {\n        enumIndexes.insert(\n          definitionNameKey(module.moduleIndex, name),\n          enums.length,\n        )\n        enums.push(EnumDefinition {\n          moduleIndex: module.moduleIndex,\n          name: name,\n          typeParameters: parameters,\n          variants: [],\n        })\n      } else if !reservedNominal && item.kind == \"statement/newtype\" {\n        newtypeIndexes.insert(\n          definitionNameKey(module.moduleIndex, name),\n          newtypes.length,\n        )\n        newtypes.push(NewtypeDefinition {\n          moduleIndex: module.moduleIndex,\n          name: name,\n          typeParameters: parameters,\n          base: emptyType(\"unknown\"),\n        })\n      } else if !reservedNominal && item.kind == \"statement/type-alias\" {\n        aliasIndexes.insert(\n          definitionNameKey(module.moduleIndex, name),\n          aliases.length,\n        )\n        aliases.push(AliasDefinition {\n          moduleIndex: module.moduleIndex,\n          name: name,\n          typeParameters: parameters,\n          declaration: item,\n          origin: \"source:{module.sourceOrdinal}:{item.lo}:{item.hi}\",\n          body: emptyType(\"unknown\"),\n          resolution: \"pending\",\n          deferCollectionKeys: false,\n          collectionKeys: [],\n        })\n      }\n    }\n  }\n  ()\n}\n\nrecord NominalFillContext {\n  state: CheckerState,\n  module: ModuleSyntax,\n  item: SyntaxNode,\n  name: string,\n  origin: string,\n  parameters: Array<string>,\n}\n\nfunction nominalFillContext(\n  state: CheckerState,\n  module: ModuleSyntax,\n  item: SyntaxNode,\n) -> NominalFillContext {\n  let name = match child(item, \"name\") {\n    case Some(found) => text(module.source, found)\n    case None => \"\"\n  }\n  NominalFillContext {\n    state: state,\n    module: module,\n    item: item,\n    name: name,\n    origin: \"source:{module.sourceOrdinal}:{item.lo}:{item.hi}\",\n    parameters: typeParameterNames(module.source, item),\n  }\n}\n\nfunction formNominalChildType(\n  service: CheckerService,\n  context: NominalFillContext,\n  node: SyntaxNode,\n  field: string,\n) -> TypeValue {\n  match child(node, field) {\n    case Some(found) => formType(\n      service,\n      context.state,\n      context.module.moduleIndex,\n      context.module.source,\n      found,\n      context.parameters,\n      context.origin,\n    )\n    case None => emptyType(\"unknown\")\n  }\n}\n\nfunction fillRecordNominal(service: CheckerService, context: NominalFillContext) -> () {\n  let index = recordDefinitionIndex(\n    context.state,\n    context.module.moduleIndex,\n    context.name,\n  )\n  let mut fields: Array<RecordField> = []\n  let mut names: Array<string> = []\n  for field in children(context.item, \"fields\") {\n    let name = match child(field, \"name\") {\n      case Some(found) => text(context.module.source, found)\n      case None => \"\"\n    }\n    if containsString(names, name) {\n      addDiagnostic(context.state, context.module.moduleIndex, \"TPZ5008\",\n        \"record field `{name}` is declared twice in `{context.name}`\", \"\", field)\n      continue\n    }\n    names.push(name)\n    let typeValue = formNominalChildType(service, context, field, \"type\")\n    match child(field, \"type\") {\n      case Some(typeNode) => addNode(\n        context.state,\n        context.module.moduleIndex,\n        \"type\",\n        typeNode,\n        typeValue,\n      )\n      case None => ()\n    }\n    fields.push(RecordField {\n      name: name,\n      typeValue: typeValue,\n      hasDefault: match child(field, \"default\") {\n        case Some(_) => true\n        case None => false\n      },\n    })\n  }\n  if index >= 0 {\n    replaceRecordDefinition(context.state, index, RecordDefinition {\n      moduleIndex: context.module.moduleIndex,\n      name: context.name,\n      typeParameters: context.parameters,\n      fields: fields,\n    })\n  }\n}\n\nfunction fillEnumNominal(service: CheckerService, context: NominalFillContext) -> () {\n  let index = enumDefinitionIndex(\n    context.state,\n    context.module.moduleIndex,\n    context.name,\n  )\n  let mut variants: Array<EnumVariant> = []\n  for variant in children(context.item, \"variants\") {\n    let nameNode = match child(variant, \"name\") { case Some(found) => found; case None => variant }\n    let name = text(context.module.source, nameNode)\n    if name == \"None\" || name == \"Some\" || name == \"Ok\" || name == \"Err\" {\n      addDiagnostic(context.state, context.module.moduleIndex, \"TPZ5022\",\n        \"enum variant `{name}` collides with a reserved prelude constructor; choose another variant name\",\n        \"\", nameNode)\n      continue\n    }\n    let mut payloads: Array<TypeValue> = []\n    for payload in children(variant, \"payload\") {\n      let typeValue = formType(\n        service,\n        context.state,\n        context.module.moduleIndex,\n        context.module.source,\n        payload,\n        context.parameters,\n        context.origin,\n      )\n      addNode(\n        context.state,\n        context.module.moduleIndex,\n        \"type\",\n        payload,\n        typeValue,\n      )\n      payloads.push(typeValue)\n      if typeValue.kind == \"union\" {\n        let mut containsEnum = false\n        for member in typeValue.members {\n          if member.kind == \"enum\" { containsEnum = true }\n        }\n        if containsEnum {\n          addDiagnostic(context.state, context.module.moduleIndex, \"TPZ5022\",\n            \"enum variant `{name}` has a payload `{typeText(typeValue)}` that is a union containing an enum — enum-in-union payloads are not supported\",\n            \"\", nameNode)\n        }\n      }\n    }\n    variants.push(EnumVariant {\n      name: name,\n      payloads: payloads,\n    })\n  }\n  if index >= 0 {\n    replaceEnumDefinition(context.state, index, EnumDefinition {\n      moduleIndex: context.module.moduleIndex,\n      name: context.name,\n      typeParameters: context.parameters,\n      variants: variants,\n    })\n  }\n}\n\nfunction fillNewtypeNominal(service: CheckerService, context: NominalFillContext) -> () {\n  let index = newtypeDefinitionIndex(\n    context.state,\n    context.module.moduleIndex,\n    context.name,\n  )\n  if index >= 0 {\n    let base = formNominalChildType(service, context, context.item, \"base\")\n    match child(context.item, \"base\") {\n      case Some(typeNode) => addNode(\n        context.state,\n        context.module.moduleIndex,\n        \"type\",\n        typeNode,\n        base,\n      )\n      case None => ()\n    }\n    replaceNewtypeDefinition(context.state, index, NewtypeDefinition {\n      moduleIndex: context.module.moduleIndex,\n      name: context.name,\n      typeParameters: context.parameters,\n      base: base,\n    })\n  }\n}\n\n// Normalize a dependency on demand: declaration order must not turn a forward\n// alias into unknown. The active state detects cycles before substituting any\n// type arguments, including cycles whose arguments grow on each expansion.\nfunction resolveAliasBody(\n  service: CheckerService,\n  state: CheckerState,\n  index: int,\n  useModule: int,\n  useNode: SyntaxNode,\n  deferCollectionKeys: bool,\n) -> TypeValue {\n  let alias = match state.aliases.get(index) {\n    case Some(found) => found\n    case None => return emptyType(\"unknown\")\n  }\n  if alias.resolution == \"ready\" {\n    return alias.body\n  }\n  if alias.resolution == \"active\" {\n    addDiagnostic(\n      state,\n      useModule,\n      \"TPZ5023\",\n      \"type alias `{alias.name}` refers to itself (alias cycle)\",\n      \"\",\n      useNode,\n    )\n    return emptyType(\"unknown\")\n  }\n  let module = match moduleAt(state, alias.moduleIndex) {\n    case Some(found) => found\n    case None => return emptyType(\"unknown\")\n  }\n  let context = nominalFillContext(state, module, alias.declaration)\n  let mut aliases = state.aliases\n  aliases[index] = AliasDefinition {\n    ...alias,\n    resolution: \"active\",\n    deferCollectionKeys: deferCollectionKeys,\n  }\n  let body = formNominalChildType(service, context, alias.declaration, \"type\")\n  aliases[index] = AliasDefinition { ...alias, body: body, resolution: \"ready\" }\n  body\n}\n\nfunction fillAliasNominal(service: CheckerService, context: NominalFillContext) -> () {\n  let index = aliasDefinitionIndex(\n    context.state,\n    context.module.moduleIndex,\n    context.name,\n  )\n  if index >= 0 {\n    let body = resolveAliasBody(\n      service,\n      context.state,\n      index,\n      context.module.moduleIndex,\n      context.item,\n      false,\n    )\n    match context.state.aliases.get(index) {\n      case Some(alias) => {\n        let mut keys = alias.collectionKeys\n        for check in keys {\n          serviceGateCollectionKey(\n            service,\n            context.state,\n            alias.moduleIndex,\n            check.node,\n            check.key,\n          )\n        };\n        keys.clear()\n      }\n      case None => ()\n    }\n    match child(context.item, \"type\") {\n      case Some(typeNode) => addNode(\n        context.state,\n        context.module.moduleIndex,\n        \"type\",\n        typeNode,\n        body,\n      )\n      case None => ()\n    }\n  }\n}\n\nfunction fillNominalDefinition(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  item: SyntaxNode,\n) -> () {\n  if item.kind != \"statement/record\" && item.kind != \"statement/enum\" &&\n    item.kind != \"statement/newtype\" && item.kind != \"statement/type-alias\" {\n    return ()\n  }\n  let context = nominalFillContext(state, module, item)\n  match item.kind {\n    case \"statement/record\" => fillRecordNominal(service, context)\n    case \"statement/enum\" => fillEnumNominal(service, context)\n    case \"statement/newtype\" => fillNewtypeNominal(service, context)\n    case \"statement/type-alias\" => fillAliasNominal(service, context)\n    case _ => ()\n  }\n}\n\nexport function fillNominals(service: CheckerService, state: CheckerState) -> () {\n  for module in state.modules {\n    for statement in module.root.children {\n      fillNominalDefinition(service, state, module, unwrapExport(statement))\n    }\n  }\n  ()\n}\n\nfunction normalizedProtocolType(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  node: SyntaxNode,\n  explicitParameter: string,\n  origin: string,\n  conformingType: TypeValue,\n) -> TypeValue {\n  let mut parameters: Array<string> = [\"Self\"]\n  let mut replacements: Array<TypeValue> = [conformingType]\n  if explicitParameter != \"\" {\n    parameters.push(explicitParameter)\n    replacements.push(conformingType)\n  }\n  substitute(\n    formType(\n      service,\n      state,\n      module.moduleIndex,\n      module.source,\n      node,\n      parameters,\n      origin,\n    ),\n    parameters,\n    replacements,\n  )\n}\n\nfunction checkProtocolMethod(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  protocolName: string,\n  explicitParameter: string,\n  origin: string,\n  method: SyntaxNode,\n  methodIndexes: Map<string, int>,\n) -> Option<ProtocolMethodDefinition> {\n  let methodNameNode = match child(method, \"name\") {\n    case Some(found) => found\n    case None => return None\n  }\n  let methodName = text(module.source, methodNameNode)\n  match methodIndexes.get(methodName) {\n    case Some(_) => {\n      addDiagnostic(\n        state,\n        module.moduleIndex,\n        \"TPZ5008\",\n        \"method `{methodName}` is already declared in protocol `{protocolName}`\",\n        \"\",\n        methodNameNode,\n      )\n      return None\n    }\n    case None => ()\n  }\n  if children(method, \"typeParameters\").length > 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"protocol method `{protocolName}.{methodName}` cannot be generic\",\n      \"\",\n      methodNameNode,\n    )\n    return None\n  }\n  let methodParameters = children(method, \"parameters\")\n  if methodParameters.length == 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"protocol method `{protocolName}.{methodName}` must take the conforming value as its first parameter\",\n      \"\",\n      methodNameNode,\n    )\n    return None\n  }\n  let firstParameter = methodParameters[0]\n  let returnTypeNodes = children(method, \"returnType\")\n  if returnTypeNodes.length == 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"protocol method `{protocolName}.{methodName}` requires an explicit return type (use `-> ()` for unit)\",\n      \"\",\n      methodNameNode,\n    )\n    return None\n  }\n  let returnTypeNode = returnTypeNodes[0]\n  for parameter in methodParameters {\n    if boolAttribute(parameter, \"variadic\") {\n      addDiagnostic(\n        state,\n        module.moduleIndex,\n        \"TPZ5022\",\n        \"protocol method `{protocolName}.{methodName}` cannot be variadic\",\n        \"\",\n        parameter,\n      )\n      return None\n    }\n  }\n  for parameter in methodParameters {\n    match child(parameter, \"default\") {\n      case Some(_) => {\n        addDiagnostic(\n          state,\n          module.moduleIndex,\n          \"TPZ5022\",\n          \"protocol method `{protocolName}.{methodName}` cannot declare parameter defaults\",\n          \"\",\n          parameter,\n        )\n        return None\n      }\n      case None => ()\n    }\n  }\n  let conformingType = rigid(\"Self\", origin)\n  let mut parameterTypes: Array<TypeValue> = []\n  for parameter in methodParameters {\n    parameterTypes.push(match child(parameter, \"type\") {\n      case Some(found) => normalizedProtocolType(\n        service,\n        state,\n        module,\n        found,\n        explicitParameter,\n        origin,\n        conformingType,\n      )\n      case None => emptyType(\"unknown\")\n    })\n  }\n  let firstTypeNode = match child(firstParameter, \"type\") {\n    case Some(found) => found\n    case None => firstParameter\n  }\n  let firstType = match parameterTypes.get(0) {\n    case Some(found) => found\n    case None => emptyType(\"unknown\")\n  }\n  if !typeEqual(firstType, conformingType) {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"protocol method `{protocolName}.{methodName}` must use `Self` or the protocol's type parameter as its first parameter type\",\n      \"\",\n      firstTypeNode,\n    )\n    return None\n  }\n  let resultType = normalizedProtocolType(\n    service,\n    state,\n    module,\n    returnTypeNode,\n    explicitParameter,\n    origin,\n    conformingType,\n  )\n  let mut indexes = methodIndexes\n  indexes.insert(methodName, 1)\n  let mut parameterNames: Array<string> = []\n  for parameter in methodParameters {\n    parameterNames.push(match child(parameter, \"name\") {\n      case Some(found) => text(module.source, found)\n      case None => \"\"\n    })\n  }\n  Some(ProtocolMethodDefinition {\n    name: methodName,\n    parameterNames: parameterNames,\n    typeValue: functionType(parameterTypes, [], resultType),\n  })\n}\n\nfunction collectProtocol(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  statement: SyntaxNode,\n) -> () {\n  let item = unwrapExport(statement)\n  if item.kind != \"statement/protocol\" {\n    return ()\n  }\n  let nameNode = match child(item, \"name\") {\n    case Some(found) => found\n    case None => return ()\n  }\n  let name = text(module.source, nameNode)\n  if name == \"Show\" || name == \"Eq\" || name == \"Order\" || name == \"JSON\" {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5008\",\n      \"`{name}` is a builtin protocol and cannot be redeclared\",\n      \"\",\n      nameNode,\n    )\n    return ()\n  }\n  if protocolDefinitionIndex(state, module.moduleIndex, name) >= 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5008\",\n      \"protocol `{name}` is already declared\",\n      \"\",\n      nameNode,\n    )\n    return ()\n  }\n  if recordDefinitionIndex(state, module.moduleIndex, name) >= 0 ||\n    enumDefinitionIndex(state, module.moduleIndex, name) >= 0 ||\n    newtypeDefinitionIndex(state, module.moduleIndex, name) >= 0 ||\n    aliasDefinitionIndex(state, module.moduleIndex, name) >= 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"`{name}` is already a type and cannot also be a protocol\",\n      \"\",\n      nameNode,\n    )\n    return ()\n  }\n  let typeParameters = typeParameterNames(module.source, item)\n  if typeParameters.length > 1 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"protocol `{name}` takes at most one conforming-type parameter; found {typeParameters.length}\",\n      \"\",\n      nameNode,\n    )\n    return ()\n  }\n  let explicitParameter = match typeParameters.get(0) {\n    case Some(found) => found\n    case None => \"\"\n  }\n  let origin = \"{module.identity}::{name}::protocol\"\n  let mut methodIndexes: Map<string, int> = map {}\n  let mut protocolMethods: Array<ProtocolMethodDefinition> = []\n  for method in children(item, \"methods\") {\n    match checkProtocolMethod(\n      service,\n      state,\n      module,\n      name,\n      explicitParameter,\n      origin,\n      method,\n      methodIndexes,\n    ) {\n      case Some(found) => protocolMethods.push(found)\n      case None => ()\n    }\n  }\n  let mut indexes = state.protocolIndexes\n  let mut protocols = state.protocols\n  indexes.insert(definitionNameKey(module.moduleIndex, name), protocols.length)\n  protocols.push(ProtocolDefinition {\n    name: name,\n    methods: protocolMethods,\n  })\n  ()\n}\n\nexport function collectProtocols(service: CheckerService, state: CheckerState) -> () {\n  for module in state.modules {\n    for statement in module.root.children {\n      collectProtocol(service, state, module, statement)\n    }\n  }\n  ()\n}\n",
      "sourceSha256": "3a196752d9d6b2f96d3cef37da189f2c3e13e94aa5a59c3bb7d8770c7e1b75c4"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/patterns.tpz",
      "language": "topaz",
      "bytes": 47023,
      "sha256": "cb0e92d481ad5490a1b3dc9a8456ba6e67764abbe24516b943173b34fc0bc614",
      "content": "// Pattern typing, bindings, narrowing, coverage, and exhaustiveness.\n// Nominal catalogs enter as checker state; match control and diagnostics consume\n// the coverage result without duplicating pattern traversal.\n\nimport types { SyntaxNode }\nimport checker_types { TypeValue }\nimport unicode { didYouMean }\nimport resolver.modules_tables { collectPatternBindings }\nimport checker.model {\n  CheckerService,\n  CheckerState,\n  CoverageGap,\n  EnumDefinition,\n  EnumVariant,\n  PatternCoverage,\n  RecordDefinition,\n  constructor,\n  emptyType,\n  inference,\n  literal,\n  nominal,\n  primitive,\n  rigid,\n  serviceInferExpression,\n}\nimport checker.type_algebra {\n  typeDecidable,\n  typesOverlap,\n  assignable,\n  hasHole,\n  stringJoin,\n  typeText,\n  unionType,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  addNode,\n  bindSymbol,\n  child,\n  children,\n  containsString,\n  moduleIdentityAt,\n  newtypeDefinitionIndex,\n  recordDefinitionIndex,\n  symbolTypeAt,\n  text,\n}\nimport checker.nominals {\n  formType,\n  substitute,\n  targetType,\n}\nimport checker.protocols_methods {\n  enumDefinitionForType,\n  newtypeDefinitionForType,\n}\nimport checker.members_capabilities {\n  typeArgument,\n}\n\nexport function patternBindingNodes(pattern: SyntaxNode) -> Array<SyntaxNode> {\n  let mut output: Array<SyntaxNode> = []\n  if pattern.kind == \"pattern/binding\" || pattern.kind == \"pattern/typed\" {\n    match child(pattern, \"name\") {\n      case Some(found) => output.push(found)\n      case None => ()\n    }\n    return output\n  }\n  for nested in pattern.children {\n    for found in patternBindingNodes(nested) {\n      output.push(found)\n    }\n  }\n  output\n}\n\nfunction patternAlternativeBindingNodes(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n) -> Array<SyntaxNode> {\n  if pattern.kind == \"pattern/binding\" {\n    let nameNode = match child(pattern, \"name\") {\n      case Some(found) => found\n      case None => pattern\n    }\n    let name = text(source, nameNode)\n    match enumDefinitionForType(state, moduleIndex, expected) {\n      case Some(definition) => for variant in definition.variants {\n        if variant.name == name && variant.payloads.length == 0 {\n          let empty: Array<SyntaxNode> = []\n          return empty\n        }\n      }\n      case None => ()\n    }\n  }\n  patternBindingNodes(pattern)\n}\n\nfunction patternAlternativeHasBinding(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  name: string,\n) -> bool {\n  for found in patternAlternativeBindingNodes(\n    state,\n    moduleIndex,\n    source,\n    pattern,\n    expected,\n  ) {\n    if text(source, found) == name {\n      return true\n    }\n  }\n  false\n}\n\n// Let bindings use the same type-aware coverage as match patterns. In\n// particular, record fields are wrappers and pure-rest arrays and single\n// constructor types can be irrefutable despite their surface syntax.\nexport function patternIsIrrefutable(\n  state: CheckerState,\n  moduleIndex: int,\n  expected: TypeValue,\n  coverage: PatternCoverage,\n) -> bool {\n  hasHole(expected) || coverageCoversAt(state, moduleIndex, coverage, expected, \"\")\n}\n\nexport function emptyPatternCoverage() -> PatternCoverage {\n  PatternCoverage { irrefutable: false, keys: [] }\n}\n\nfunction irrefutablePatternCoverage() -> PatternCoverage {\n  PatternCoverage { irrefutable: true, keys: [] }\n}\n\nfunction coverageHasKey(coverage: PatternCoverage, key: string) -> bool {\n  containsString(coverage.keys, key)\n}\n\nfunction coverageWithKey(key: string) -> PatternCoverage {\n  PatternCoverage { irrefutable: false, keys: [key] }\n}\n\nexport function mergePatternCoverage(\n  left: PatternCoverage,\n  right: PatternCoverage,\n) -> PatternCoverage {\n  let mut keys = left.keys\n  for key in right.keys {\n    if !containsString(keys, key) {\n      keys.push(key)\n    }\n  }\n  PatternCoverage {\n    irrefutable: left.irrefutable || right.irrefutable,\n    keys: keys,\n  }\n}\n\nfunction coveragePath(prefix: string, part: string) -> string {\n  if prefix == \"\" { part } else { \"{prefix}/{part}\" }\n}\n\nfunction prefixPatternCoverage(\n  prefix: string,\n  nested: PatternCoverage,\n) -> PatternCoverage {\n  let mut keys: Array<string> = []\n  if nested.irrefutable {\n    keys.push(\"{prefix}/*\")\n  }\n  for key in nested.keys {\n    keys.push(\"{prefix}/{key}\")\n  }\n  PatternCoverage { irrefutable: false, keys: keys }\n}\n\nfunction patternTypeOpaque(value: TypeValue) -> bool {\n  value.kind == \"unknown\" || value.kind == \"inference-variable\" ||\n    value.kind == \"rigid\" || value.kind == \"foreign\"\n}\n\n\nfunction narrowPatternType(\n  scrutinee: TypeValue,\n  formed: TypeValue,\n) -> TypeValue {\n  if hasHole(scrutinee) { return formed }\n  if assignable(formed, scrutinee) { return scrutinee }\n  if assignable(scrutinee, formed) { return formed }\n  if scrutinee.kind == \"union\" {\n    let mut kept: Array<TypeValue> = []\n    for member in scrutinee.members {\n      if typesOverlap(member, formed) {\n        kept.push(narrowPatternType(member, formed))\n      }\n    }\n    if kept.length > 0 { return unionType(kept) }\n  }\n  formed\n}\n\nfunction patternNameSuggestion(\n  target: string,\n  candidates: Array<string>,\n) -> string {\n  didYouMean(target, candidates)\n}\n\nfunction recordPatternHeadSuggestion(\n  state: CheckerState,\n  moduleIndex: int,\n  target: string,\n) -> string {\n  let mut candidates: Array<string> = []\n  for definition in state.records {\n    if definition.moduleIndex == moduleIndex {\n      candidates.push(definition.name)\n    }\n  }\n  patternNameSuggestion(target, candidates)\n}\n\nfunction recordFieldSuggestion(\n  definition: RecordDefinition,\n  target: string,\n) -> string {\n  let mut candidates: Array<string> = []\n  for field in definition.fields { candidates.push(field.name) }\n  patternNameSuggestion(target, candidates)\n}\n\nfunction structuralFieldSuggestion(\n  value: TypeValue,\n  target: string,\n) -> string {\n  patternNameSuggestion(target, value.fieldNames)\n}\n\nfunction enumVariantSuggestion(\n  definition: EnumDefinition,\n  target: string,\n) -> string {\n  let mut candidates: Array<string> = []\n  for variant in definition.variants { candidates.push(variant.name) }\n  patternNameSuggestion(target, candidates)\n}\n\nfunction nominalPatternIdentityFor(identity: string, origin: string) -> string {\n  if origin == \"\" { identity }\n  else { \"{origin}::{identity}\" }\n}\n\nfunction nominalPatternIdentity(value: TypeValue) -> string {\n  nominalPatternIdentityFor(value.identity, value.origin)\n}\n\nfunction coverageCoversAt(\n  state: CheckerState,\n  moduleIndex: int,\n  coverage: PatternCoverage,\n  value: TypeValue,\n  prefix: string,\n) -> bool {\n  if prefix == \"\" && coverage.irrefutable {\n    return true\n  }\n  if prefix != \"\" && coverageHasKey(coverage, \"{prefix}/*\") {\n    return true\n  }\n  if value.kind == \"primitive\" && value.name == \"bool\" {\n    return coverageHasKey(\n      coverage,\n      coveragePath(prefix, \"literal:true\"),\n    ) && coverageHasKey(\n      coverage,\n      coveragePath(prefix, \"literal:false\"),\n    )\n  }\n  if value.kind == \"literal\" {\n    return coverageHasKey(\n      coverage,\n      coveragePath(prefix, \"literal:{typeText(value)}\"),\n    )\n  }\n  if value.kind == \"union\" {\n    if value.members.length == 0 { return false }\n    for member in value.members {\n      if !coverageCoversAt(state, moduleIndex, coverage, member, prefix) {\n        return false\n      }\n    }\n    return true\n  }\n  if value.kind == \"constructor\" && value.name == \"Option\" {\n    return coverageCoversAt(\n      state,\n      moduleIndex,\n      coverage,\n      typeArgument(value, 0),\n      coveragePath(prefix, \"constructor:Some\"),\n    ) && coverageHasKey(\n      coverage,\n      coveragePath(prefix, \"constructor:None/*\"),\n    )\n  }\n  if value.kind == \"constructor\" && value.name == \"Result\" {\n    return coverageCoversAt(\n      state,\n      moduleIndex,\n      coverage,\n      typeArgument(value, 0),\n      coveragePath(prefix, \"constructor:Ok\"),\n    ) && coverageCoversAt(\n      state,\n      moduleIndex,\n      coverage,\n      typeArgument(value, 1),\n      coveragePath(prefix, \"constructor:Err\"),\n    )\n  }\n  if value.kind == \"enum\" {\n    return match enumDefinitionForType(state, moduleIndex, value) {\n      case Some(definition) => {\n        for variant in definition.variants {\n          let variantPrefix = coveragePath(\n            prefix,\n            \"constructor:{variant.name}\",\n          )\n          if variant.payloads.length == 0 {\n            if !coverageHasKey(coverage, \"{variantPrefix}/*\") {\n              return false\n            }\n          } else if variant.payloads.length == 1 {\n            let payload = match variant.payloads.get(0) {\n              case Some(found) => substitute(\n                found,\n                definition.typeParameters,\n                value.arguments,\n              )\n              case None => emptyType(\"unknown\")\n            }\n            if !coverageCoversAt(\n              state,\n              definition.moduleIndex,\n              coverage,\n              payload,\n              variantPrefix,\n            ) {\n              return false\n            }\n          } else if !coverageHasKey(coverage, \"{variantPrefix}/*\") {\n            return false\n          }\n        }\n        true\n      }\n      case None => false\n    }\n  }\n  if value.kind == \"nominal-record\" {\n    return coverageHasKey(\n      coverage,\n      coveragePath(prefix, \"record:{nominalPatternIdentity(value)}\"),\n    )\n  }\n  false\n}\n\nexport function coverageGap(\n  state: CheckerState,\n  moduleIndex: int,\n  coverage: PatternCoverage,\n  value: TypeValue,\n) -> CoverageGap {\n  if coverage.irrefutable {\n    return CoverageGap { decidable: true, missing: [] }\n  }\n  let mut missing: Array<string> = []\n  if value.kind == \"primitive\" && value.name == \"bool\" {\n    for spelling in [\"true\", \"false\"] {\n      if !coverageHasKey(coverage, \"literal:{spelling}\") {\n        missing.push(\"`{spelling}`\")\n      }\n    }\n    return CoverageGap { decidable: true, missing: missing }\n  }\n  if value.kind == \"newtype\" {\n    missing.push(\"`{typeText(value)}(_)`\")\n    return CoverageGap { decidable: true, missing: missing }\n  }\n  if value.kind == \"union\" {\n    let mut decidable = true\n    for member in value.members {\n      if member.kind == \"literal\" {\n        if !coverageHasKey(coverage, \"literal:{typeText(member)}\") {\n          missing.push(\"`{typeText(member)}`\")\n        }\n      } else if member.kind == \"nominal-record\" {\n        if !coverageHasKey(\n          coverage,\n          \"record:{nominalPatternIdentity(member)}\",\n        ) {\n          missing.push(\"`{typeText(member)} \\{ … \\}`\")\n        }\n      } else {\n        decidable = false\n      }\n    }\n    return CoverageGap {\n      decidable: decidable,\n      missing: if decidable { missing } else { [] },\n    }\n  }\n  if value.kind == \"constructor\" && value.name == \"Option\" {\n    if !coverageCoversAt(\n      state,\n      moduleIndex,\n      coverage,\n      typeArgument(value, 0),\n      \"constructor:Some\",\n    ) {\n      missing.push(\"`Some`\")\n    }\n    if !coverageHasKey(coverage, \"constructor:None/*\") {\n      missing.push(\"`None`\")\n    }\n    return CoverageGap { decidable: true, missing: missing }\n  }\n  if value.kind == \"constructor\" && value.name == \"Result\" {\n    if !coverageCoversAt(\n      state,\n      moduleIndex,\n      coverage,\n      typeArgument(value, 0),\n      \"constructor:Ok\",\n    ) {\n      missing.push(\"`Ok`\")\n    }\n    if !coverageCoversAt(\n      state,\n      moduleIndex,\n      coverage,\n      typeArgument(value, 1),\n      \"constructor:Err\",\n    ) {\n      missing.push(\"`Err`\")\n    }\n    return CoverageGap { decidable: true, missing: missing }\n  }\n  if value.kind == \"enum\" {\n    return match enumDefinitionForType(state, moduleIndex, value) {\n      case Some(definition) => {\n        for variant in definition.variants {\n          let prefix = \"constructor:{variant.name}\"\n          let mut covered = false\n          if variant.payloads.length == 0 || variant.payloads.length > 1 {\n            covered = coverageHasKey(coverage, \"{prefix}/*\")\n          } else {\n            let payload = match variant.payloads.get(0) {\n              case Some(found) => substitute(\n                found,\n                definition.typeParameters,\n                value.arguments,\n              )\n              case None => emptyType(\"unknown\")\n            }\n            covered = coverageCoversAt(\n              state,\n              definition.moduleIndex,\n              coverage,\n              payload,\n              prefix,\n            )\n          }\n          if !covered {\n            missing.push(\"`{typeText(value)}.{variant.name}`\")\n          }\n        }\n        CoverageGap { decidable: true, missing: missing }\n      }\n      case None => CoverageGap { decidable: false, missing: [] }\n    }\n  }\n  if value.kind == \"nominal-record\" {\n    if !coverageHasKey(\n      coverage,\n      \"record:{nominalPatternIdentity(value)}\",\n    ) {\n      missing.push(\"`{typeText(value)} \\{ … \\}`\")\n    }\n    return CoverageGap { decidable: true, missing: missing }\n  }\n  CoverageGap { decidable: false, missing: [] }\n}\n\nfunction checkLiteralPattern(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n) -> PatternCoverage {\n  let mut coverage = emptyPatternCoverage()\n  for fieldName in [\"value\", \"low\", \"high\"] {\n    match child(pattern, fieldName) {\n      case Some(value) => {\n        let inferred = serviceInferExpression(service, state, moduleIndex, source, value)\n        if pattern.kind == \"pattern/literal\" && fieldName == \"value\" {\n          coverage = coverageWithKey(\"literal:{typeText(inferred)}\")\n          if typeDecidable(expected) && !hasHole(inferred) &&\n            !typesOverlap(inferred, expected) {\n            addDiagnostic(\n              state,\n              moduleIndex,\n              \"TPZ5001\",\n              \"this pattern can never match `{typeText(expected)}`\",\n              \"\",\n              value,\n            )\n          }\n        }\n      }\n      case None => ()\n    }\n  }\n  addNode(state, moduleIndex, \"pattern\", pattern, expected)\n  coverage\n}\n\nexport function bindNamedPatternType(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  typeValue: TypeValue,\n  mutable: bool,\n) -> () {\n  let nameNode = match child(pattern, \"name\") {\n    case Some(found) => found\n    case None => pattern\n  }\n  let name = text(source, nameNode)\n  if pattern.kind == \"pattern/binding\" {\n    match enumDefinitionForType(state, moduleIndex, expected) {\n      case Some(definition) => for variant in definition.variants {\n        if variant.name == name && variant.payloads.length == 0 {\n          addNode(state, moduleIndex, \"pattern\", pattern, expected)\n          return ()\n        }\n      }\n      case None => ()\n    }\n  }\n  bindSymbol(\n    state,\n    moduleIndex,\n    nameNode.lo,\n    nameNode.hi,\n    name,\n    typeValue,\n    mutable,\n  )\n  addNode(\n    state,\n    moduleIndex,\n    \"pattern\",\n    pattern,\n    if pattern.kind == \"pattern/typed\" { expected } else { typeValue },\n  )\n  addNode(state, moduleIndex, \"binding\", nameNode, typeValue)\n}\n\nfunction bindNamedPattern(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  mutable: bool,\n) -> PatternCoverage {\n  let typeValue = if pattern.kind == \"pattern/typed\" {\n    match child(pattern, \"type\") {\n      case Some(found) => formType(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        [],\n        \"pattern\",\n      )\n      case None => expected\n    }\n  } else {\n    expected\n  }\n  let mut coverage = irrefutablePatternCoverage()\n  let mut bound = typeValue\n  if pattern.kind == \"pattern/typed\" {\n    if !hasHole(expected) && !hasHole(typeValue) &&\n      assignable(typeValue, expected) {\n      coverage = irrefutablePatternCoverage()\n    } else {\n      coverage = emptyPatternCoverage()\n      if typeDecidable(expected) && typeDecidable(typeValue) &&\n        !typesOverlap(expected, typeValue) {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5001\",\n          \"this pattern can never match `{typeText(expected)}`\",\n          \"\",\n          pattern,\n        )\n      }\n    }\n    bound = narrowPatternType(expected, typeValue)\n  }\n  bindNamedPatternType(\n    state,\n    moduleIndex,\n    source,\n    pattern,\n    expected,\n    bound,\n    mutable,\n  )\n  coverage\n}\n\nfunction recordFieldType(value: TypeValue, name: string) -> Option<TypeValue> {\n  if value.kind != \"record\" { return None }\n  let mut index = 0\n  for fieldName in value.fieldNames {\n    if fieldName == name {\n      return value.fields.get(index)\n    }\n    index += 1\n  }\n  None\n}\n\nfunction literalPatternType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n) -> Option<TypeValue> {\n  if pattern.kind != \"pattern/literal\" { return None }\n  match child(pattern, \"value\") {\n    case Some(value) => Some(serviceInferExpression(service, state, moduleIndex, source, value))\n    case None => None\n  }\n}\n\nfunction structuralRecordCandidate(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  value: TypeValue,\n) -> bool {\n  if value.kind != \"record\" { return false }\n  for field in children(pattern, \"fields\") {\n    let nameNode = match child(field, \"name\") {\n      case Some(found) => found\n      case None => field\n    }\n    let fieldType = match recordFieldType(value, text(source, nameNode)) {\n      case Some(found) => found\n      case None => return false\n    }\n    match child(field, \"pattern\") {\n      case Some(nested) => match literalPatternType(\n        service,\n        state,\n        moduleIndex,\n        source,\n        nested,\n      ) {\n        case Some(literalType) => if typeDecidable(fieldType) &&\n          !typesOverlap(literalType, fieldType) {\n          return false\n        }\n        case None => ()\n      }\n      case None => ()\n    }\n  }\n  true\n}\n\nfunction bindRecordPattern(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  mutable: bool,\n) -> PatternCoverage {\n  if pattern.kind == \"pattern/nominal-record\" {\n    let nameNode = match child(pattern, \"name\") {\n      case Some(found) => found\n      case None => pattern\n    }\n    let recordName = text(source, nameNode)\n    let target = targetType(state, moduleIndex, nameNode)\n    let targetModule = target.moduleIndex\n    let targetName = target.name\n    let targetOrigin = moduleIdentityAt(state, targetModule)\n    let mut definition: Option<RecordDefinition> = None\n    let index = recordDefinitionIndex(state, targetModule, targetName)\n    if index >= 0 {\n      definition = state.records.get(index)\n    }\n    let mut candidates: Array<TypeValue> = []\n    let mut members: Array<TypeValue> = if expected.kind == \"union\" {\n      expected.members\n    } else {\n      [expected]\n    }\n    let mut hasRigid = false\n    let mut hasGradual = false\n    let mut allMatch = members.length > 0\n    for member in members {\n      if member.kind == \"nominal-record\" &&\n        member.identity == targetName && member.origin == targetOrigin {\n        candidates.push(member)\n      } else {\n        allMatch = false\n        if member.kind == \"rigid\" || member.kind == \"foreign\" {\n          hasRigid = true\n        }\n        if hasHole(member) { hasGradual = true }\n      }\n    }\n    match definition {\n      case Some(recordDefinition) => {\n        if hasRigid {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"a `{recordName}` pattern cannot establish nominal identity for rigid scrutinee type `{typeText(expected)}`\",\n            \"\",\n            pattern,\n          )\n        } else if candidates.length == 0 && !hasGradual {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"this `{recordName}` pattern can never match `{typeText(expected)}`\",\n            \"\",\n            pattern,\n          )\n        }\n        let mut allIrrefutable = true\n        let mut seenFields: Array<string> = []\n        for field in children(pattern, \"fields\") {\n          let fieldNameNode = match child(field, \"name\") {\n            case Some(found) => found\n            case None => field\n          }\n          let fieldName = text(source, fieldNameNode)\n          let duplicate = containsString(seenFields, fieldName)\n          seenFields.push(fieldName)\n          if duplicate {\n            addDiagnostic(\n              state,\n              moduleIndex,\n              \"TPZ5008\",\n              \"nominal record pattern field `{fieldName}` is specified more than once\",\n              \"\",\n              field,\n            )\n          }\n          let mut knownField = false\n          for declared in recordDefinition.fields {\n            if declared.name == fieldName { knownField = true }\n          }\n          if !knownField {\n            addDiagnostic(\n              state,\n              moduleIndex,\n              \"TPZ5006\",\n              \"record `{recordName}` has no field `{fieldName}`\" +\n                recordFieldSuggestion(recordDefinition, fieldName),\n              \"\",\n              field,\n            )\n          }\n          let mut fieldTypes: Array<TypeValue> = []\n          for candidate in candidates {\n            for declared in recordDefinition.fields {\n              if declared.name == fieldName {\n                fieldTypes.push(substitute(\n                  declared.typeValue,\n                  recordDefinition.typeParameters,\n                  candidate.arguments,\n                ))\n              }\n            }\n          }\n          if hasGradual { fieldTypes.push(emptyType(\"unknown\")) }\n          let fieldType = if fieldTypes.length == 0 {\n            let mut fallback = emptyType(\"unknown\")\n            for declared in recordDefinition.fields {\n              if declared.name == fieldName { fallback = declared.typeValue }\n            }\n            fallback\n          } else {\n            unionType(fieldTypes)\n          }\n          match child(field, \"pattern\") {\n            case Some(nested) => {\n              let nestedCoverage = patternBindingTypeAt(\n                service,\n                state,\n                moduleIndex,\n                source,\n                nested,\n                fieldType,\n                mutable,\n                false,\n              )\n              allIrrefutable = allIrrefutable && nestedCoverage.irrefutable\n            }\n            case None => bindSymbol(\n              state,\n              moduleIndex,\n              fieldNameNode.lo,\n              fieldNameNode.hi,\n              fieldName,\n              fieldType,\n              mutable,\n            )\n          }\n        }\n        addNode(state, moduleIndex, \"pattern\", pattern, expected)\n        if allIrrefutable {\n          let targetIdentity = nominalPatternIdentityFor(\n            targetName,\n            targetOrigin,\n          )\n          let keyed = coverageWithKey(\"record:{targetIdentity}\")\n          return if allMatch {\n            PatternCoverage { irrefutable: true, keys: keyed.keys }\n          } else {\n            keyed\n          }\n        }\n        return emptyPatternCoverage()\n      }\n      case None => {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5002\",\n          \"unbound nominal record pattern head `{recordName}`\" +\n            recordPatternHeadSuggestion(state, moduleIndex, recordName),\n          \"\",\n          nameNode,\n        )\n        addNode(state, moduleIndex, \"pattern\", pattern, expected)\n        return emptyPatternCoverage()\n      }\n    }\n  }\n\n  let mut members: Array<TypeValue> = if expected.kind == \"union\" {\n    expected.members\n  } else {\n    [expected]\n  }\n  let mut candidates: Array<TypeValue> = []\n  let mut rigids: Array<TypeValue> = []\n  let mut hasGradual = false\n  for member in members {\n    if structuralRecordCandidate(\n      service,\n      state,\n      moduleIndex,\n      source,\n      pattern,\n      member,\n    ) {\n      candidates.push(member)\n    } else if member.kind == \"rigid\" || member.kind == \"foreign\" {\n      rigids.push(member)\n    } else if hasHole(member) {\n      hasGradual = true\n    }\n  }\n  if expected.kind != \"record\" && candidates.length == 0 &&\n    rigids.length == 0 && !hasGradual &&\n    typeDecidable(expected) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"this pattern can never match `{typeText(expected)}`\",\n      \"\",\n      pattern,\n    )\n  }\n  let mut allIrrefutable = expected.kind == \"record\"\n  for field in children(pattern, \"fields\") {\n    let nameNode = match child(field, \"name\") {\n      case Some(found) => found\n      case None => field\n    }\n    let fieldName = text(source, nameNode)\n    let mut fieldTypes: Array<TypeValue> = []\n    for candidate in candidates {\n      match recordFieldType(candidate, fieldName) {\n        case Some(found) => fieldTypes.push(found)\n        case None => ()\n      }\n    }\n    for rigidMember in rigids {\n      fieldTypes.push(rigid(\n        \"FieldOf<{typeText(rigidMember)}, {fieldName}>\",\n        \"builtin::record-pattern\",\n      ))\n    }\n    if hasGradual { fieldTypes.push(emptyType(\"unknown\")) }\n    if expected.kind == \"record\" &&\n      recordFieldType(expected, fieldName) == None {\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5006\",\n        \"`{typeText(expected)}` has no field `{fieldName}`\" +\n          structuralFieldSuggestion(expected, fieldName),\n        \"\",\n        field,\n      )\n    }\n    let fieldType = if fieldTypes.length == 0 {\n      emptyType(\"unknown\")\n    } else {\n      unionType(fieldTypes)\n    }\n    match child(field, \"pattern\") {\n      case Some(found) => {\n        let nested = patternBindingTypeAt(\n          service,\n          state,\n          moduleIndex,\n          source,\n          found,\n          fieldType,\n          mutable,\n          false,\n        )\n        allIrrefutable = allIrrefutable && nested.irrefutable\n      }\n      case None => bindSymbol(\n        state,\n        moduleIndex,\n        nameNode.lo,\n        nameNode.hi,\n        text(source, nameNode),\n        fieldType,\n        mutable,\n      )\n    }\n  }\n  addNode(state, moduleIndex, \"pattern\", pattern, expected)\n  if allIrrefutable { irrefutablePatternCoverage() } else { emptyPatternCoverage() }\n}\n\nfunction bindConstructorPattern(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  mutable: bool,\n) -> PatternCoverage {\n  let nameNode = match child(pattern, \"name\") {\n    case Some(found) => found\n    case None => pattern\n  }\n  let name = text(source, nameNode)\n  let target = targetType(state, moduleIndex, nameNode)\n  let targetModule = target.moduleIndex\n  let targetName = target.name\n  let targetOrigin = moduleIdentityAt(state, targetModule)\n  let arguments = children(pattern, \"arguments\")\n\n  if expected.kind == \"newtype\" {\n    let mut coverage = emptyPatternCoverage()\n    match newtypeDefinitionForType(state, moduleIndex, expected) {\n      case Some(definition) => {\n        let base = substitute(\n          definition.base,\n          definition.typeParameters,\n          expected.arguments,\n        )\n        if targetName != expected.identity || targetOrigin != expected.origin ||\n          newtypeDefinitionIndex(state, targetModule, targetName) < 0 {\n          for argument in arguments {\n            let _ = patternBindingTypeAt(\n              service,\n              state,\n              moduleIndex,\n              source,\n              argument,\n              emptyType(\"unknown\"),\n              mutable,\n              false,\n            )\n          }\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"this `{name}` pattern can never match `{typeText(expected)}`\",\n            \"\",\n            pattern,\n          )\n        } else if arguments.length != 1 {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5004\",\n            \"newtype `{typeText(expected)}` pattern takes 1 subpattern (the wrapped `{typeText(base)}`), found {arguments.length}\",\n            \"\",\n            pattern,\n          )\n        } else {\n          let nested = match arguments.get(0) {\n            case Some(argument) => patternBindingTypeAt(\n              service,\n              state,\n              moduleIndex,\n              source,\n              argument,\n              base,\n              mutable,\n              false,\n            )\n            case None => emptyPatternCoverage()\n          }\n          coverage = if nested.irrefutable {\n            irrefutablePatternCoverage()\n          } else {\n            emptyPatternCoverage()\n          }\n        }\n      }\n      case None => ()\n    }\n    addNode(state, moduleIndex, \"pattern\", pattern, expected)\n    return coverage\n  }\n\n  if expected.kind == \"enum\" {\n    let mut coverage = emptyPatternCoverage()\n    match enumDefinitionForType(state, moduleIndex, expected) {\n      case Some(definition) => {\n        let mut selected: Option<EnumVariant> = None\n        for variant in definition.variants {\n          if variant.name == name { selected = Some(variant) }\n        }\n        match selected {\n          case Some(variant) => {\n            if arguments.length != variant.payloads.length {\n              for argument in arguments {\n                let _ = patternBindingTypeAt(\n                  service,\n                  state,\n                  moduleIndex,\n                  source,\n                  argument,\n                  emptyType(\"unknown\"),\n                  mutable,\n                  false,\n                )\n              }\n              let wanted = if variant.payloads.length == 0 {\n                \"no subpattern\"\n              } else {\n                \"{variant.payloads.length} subpattern\" +\n                  if variant.payloads.length == 1 { \"\" } else { \"s\" }\n              }\n              addDiagnostic(\n                state,\n                moduleIndex,\n                \"TPZ5004\",\n                \"enum variant `{typeText(expected)}.{name}` takes {wanted}, found {arguments.length}\",\n                \"\",\n                pattern,\n              )\n            } else if arguments.length == 0 {\n              coverage = coverageWithKey(\"constructor:{name}/*\")\n            } else if arguments.length == 1 {\n              let payload = match variant.payloads.get(0) {\n                case Some(found) => substitute(\n                  found,\n                  definition.typeParameters,\n                  expected.arguments,\n                )\n                case None => emptyType(\"unknown\")\n              }\n              let nested = match arguments.get(0) {\n                case Some(argument) => patternBindingTypeAt(\n                  service,\n                  state,\n                  moduleIndex,\n                  source,\n                  argument,\n                  payload,\n                  mutable,\n                  false,\n                )\n                case None => emptyPatternCoverage()\n              }\n              coverage = prefixPatternCoverage(\"constructor:{name}\", nested)\n            } else {\n              let mut allIrrefutable = true\n              let mut index = 0\n              for argument in arguments {\n                let payload = match variant.payloads.get(index) {\n                  case Some(found) => substitute(\n                    found,\n                    definition.typeParameters,\n                    expected.arguments,\n                  )\n                  case None => emptyType(\"unknown\")\n                }\n                let nested = patternBindingTypeAt(\n                  service,\n                  state,\n                  moduleIndex,\n                  source,\n                  argument,\n                  payload,\n                  mutable,\n                  false,\n                )\n                allIrrefutable = allIrrefutable && nested.irrefutable\n                index += 1\n              }\n              if allIrrefutable {\n                coverage = coverageWithKey(\"constructor:{name}/*\")\n              }\n            }\n          }\n          case None => addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"enum `{typeText(expected)}` has no variant `{name}`\" +\n              enumVariantSuggestion(definition, name),\n            \"\",\n            pattern,\n          )\n        }\n      }\n      case None => ()\n    }\n    addNode(state, moduleIndex, \"pattern\", pattern, expected)\n    return coverage\n  }\n\n  let known = name == \"Some\" || name == \"None\" ||\n    name == \"Ok\" || name == \"Err\"\n  let correctArity = if name == \"None\" {\n    arguments.length == 0\n  } else if known {\n    arguments.length == 1\n  } else {\n    true\n  }\n  let mut members: Array<TypeValue> = if expected.kind == \"union\" {\n    expected.members\n  } else {\n    [expected]\n  }\n  let mut payloads: Array<TypeValue> = []\n  let mut matchable = false\n  for member in members {\n    if name == \"Some\" && member.kind == \"constructor\" &&\n      member.name == \"Option\" && correctArity {\n      matchable = true\n      payloads.push(typeArgument(member, 0))\n    } else if name == \"None\" && member.kind == \"constructor\" &&\n      member.name == \"Option\" && correctArity {\n      matchable = true\n    } else if name == \"Ok\" && member.kind == \"constructor\" &&\n      member.name == \"Result\" && correctArity {\n      matchable = true\n      payloads.push(typeArgument(member, 0))\n    } else if name == \"Err\" && member.kind == \"constructor\" &&\n      member.name == \"Result\" && correctArity {\n      matchable = true\n      payloads.push(typeArgument(member, 1))\n    } else if (member.kind == \"rigid\" || member.kind == \"foreign\") &&\n      (!known || correctArity) {\n      matchable = true\n      if arguments.length > 0 {\n        payloads.push(rigid(\n          \"PayloadOf<{typeText(member)}, {name}>\",\n          \"builtin::constructor-pattern\",\n        ))\n      }\n    } else if hasHole(member) && (!known || correctArity) {\n      matchable = true\n      if arguments.length > 0 { payloads.push(emptyType(\"unknown\")) }\n    }\n  }\n  if known && !correctArity {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5004\",\n      if name == \"None\" {\n        \"`None` pattern takes no subpattern\"\n      } else {\n        \"`{name}` pattern takes one subpattern\"\n      },\n      \"\",\n      pattern,\n    )\n  } else if known && !matchable {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"this pattern can never match `{typeText(expected)}`\",\n      \"\",\n      pattern,\n    )\n  }\n  let payload = if payloads.length == 0 {\n    emptyType(\"unknown\")\n  } else {\n    unionType(payloads)\n  }\n  let mut nested = irrefutablePatternCoverage()\n  for argument in arguments {\n    nested = patternBindingTypeAt(\n      service,\n      state,\n      moduleIndex,\n      source,\n      argument,\n      payload,\n      mutable,\n      false,\n    )\n  }\n  addNode(state, moduleIndex, \"pattern\", pattern, expected)\n  if matchable && known {\n    prefixPatternCoverage(\"constructor:{name}\", nested)\n  } else {\n    emptyPatternCoverage()\n  }\n}\n\nfunction bindListPattern(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  mutable: bool,\n) -> PatternCoverage {\n  let mut members: Array<TypeValue> = if expected.kind == \"union\" {\n    expected.members\n  } else {\n    [expected]\n  }\n  let mut itemTypes: Array<TypeValue> = []\n  let mut restTypes: Array<TypeValue> = []\n  let mut opaque = false\n  for member in members {\n    if member.kind == \"constructor\" && member.name == \"Array\" {\n      itemTypes.push(typeArgument(member, 0))\n      restTypes.push(member)\n    } else if member.kind == \"rigid\" || member.kind == \"foreign\" {\n      let projected = rigid(\n        \"ElemOf<{typeText(member)}>\",\n        \"builtin::list-pattern\",\n      )\n      itemTypes.push(projected)\n      restTypes.push(constructor(\"Array\", [projected]))\n      opaque = true\n    } else if hasHole(member) {\n      itemTypes.push(emptyType(\"unknown\"))\n      restTypes.push(emptyType(\"unknown\"))\n      opaque = true\n    }\n  }\n  if itemTypes.length == 0 && !opaque && typeDecidable(expected) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"this pattern can never match `{typeText(expected)}`\",\n      \"\",\n      pattern,\n    )\n  }\n  let item = if itemTypes.length == 0 {\n    emptyType(\"unknown\")\n  } else {\n    unionType(itemTypes)\n  }\n  let rest = if restTypes.length == 0 {\n    emptyType(\"unknown\")\n  } else {\n    unionType(restTypes)\n  }\n  let mut elementCount = 0\n  let mut onlyRestIrrefutable = false\n  for element in children(pattern, \"elements\") {\n    if element.kind == \"list-pattern/rest\" {\n      match child(element, \"binding\") {\n        case Some(found) => {\n          let nested = patternBindingTypeAt(\n            service,\n            state,\n            moduleIndex,\n            source,\n            found,\n            rest,\n            mutable,\n            false,\n          )\n          onlyRestIrrefutable = nested.irrefutable\n        }\n        case None => { onlyRestIrrefutable = true }\n      }\n    } else {\n      elementCount += 1\n      let _ = patternBindingTypeAt(\n        service,\n        state,\n        moduleIndex,\n        source,\n        element,\n        item,\n        mutable,\n        false,\n      )\n    }\n  }\n  addNode(state, moduleIndex, \"pattern\", pattern, expected)\n  if expected.kind == \"constructor\" && expected.name == \"Array\" &&\n    elementCount == 0 && children(pattern, \"elements\").length == 1 &&\n    onlyRestIrrefutable {\n    irrefutablePatternCoverage()\n  } else {\n    emptyPatternCoverage()\n  }\n}\n\nfunction disconnectedPatternTypes(values: Array<TypeValue>) -> bool {\n  if values.length < 2 { return false }\n  let mut reached: Array<bool> = []\n  let mut index = 0\n  while index < values.length {\n    reached.push(index == 0)\n    index += 1\n  }\n  let mut stack: Array<int> = [0]\n  while stack.length > 0 {\n    let current = match stack.pop() {\n      case Some(found) => found\n      case None => 0\n    }\n    let currentType = match values.get(current) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n    index = 0\n    while index < values.length {\n      let seen = match reached.get(index) {\n        case Some(found) => found\n        case None => false\n      }\n      let candidate = match values.get(index) {\n        case Some(found) => found\n        case None => emptyType(\"unknown\")\n      }\n      if !seen && (hasHole(currentType) || hasHole(candidate) ||\n        typesOverlap(currentType, candidate)) {\n        reached[index] = true\n        stack.push(index)\n      }\n      index += 1\n    }\n  }\n  for seen in reached {\n    if !seen { return true }\n  }\n  false\n}\n\nfunction bindOrPattern(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  mutable: bool,\n  topLevel: bool,\n) -> PatternCoverage {\n  let alternatives = children(pattern, \"alternatives\")\n  let mut coverage = emptyPatternCoverage()\n  for alternative in alternatives {\n    for binding in patternAlternativeBindingNodes(\n      state,\n      moduleIndex,\n      source,\n      alternative,\n      expected,\n    ) {\n      let name = text(source, binding)\n      let mut presentEverywhere = true\n      for other in alternatives {\n        if !patternAlternativeHasBinding(\n          state,\n          moduleIndex,\n          source,\n          other,\n          expected,\n          name,\n        ) {\n          presentEverywhere = false\n        }\n      }\n      if !presentEverywhere {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5710\",\n          \"or-pattern alternatives must bind the same names — `{name}` is bound in one alternative but not another\",\n          \"\",\n          alternative,\n        )\n      }\n    }\n    let nested = patternBindingTypeAt(\n      service,\n      state,\n      moduleIndex,\n      source,\n      alternative,\n      expected,\n      mutable,\n      topLevel,\n    )\n    coverage = mergePatternCoverage(coverage, nested)\n  }\n  // The resolver traversal coalesces names across alternatives while retaining\n  // repeated bindings inside each alternative. Variant patterns are not bindings.\n  let mut bindingNodes: Array<SyntaxNode> = []\n  collectPatternBindings(pattern, source, bindingNodes)\n  let mut declaredNames: Array<string> = []\n  for binding in bindingNodes {\n    match symbolTypeAt(state, moduleIndex, binding.lo, binding.hi) {\n      case Some(_) => {\n        let name = text(source, binding)\n        if containsString(declaredNames, name) {\n          addDiagnostic(state, moduleIndex, \"TPZ5008\", \"`{name}` is already declared in this scope\", \"\", binding)\n        } else { declaredNames.push(name) }\n      }\n      case None => ()\n    }\n  }\n  let mut names: Array<string> = []\n  for alternative in alternatives {\n    for binding in patternAlternativeBindingNodes(\n      state,\n      moduleIndex,\n      source,\n      alternative,\n      expected,\n    ) {\n      let name = text(source, binding)\n      if !containsString(names, name) { names.push(name) }\n    }\n  }\n  for name in names {\n    let mut types: Array<TypeValue> = []\n    let mut bindings: Array<SyntaxNode> = []\n    for alternative in alternatives {\n      for binding in patternAlternativeBindingNodes(\n        state,\n        moduleIndex,\n        source,\n        alternative,\n        expected,\n      ) {\n        if text(source, binding) == name {\n          bindings.push(binding)\n          match symbolTypeAt(\n            state,\n            moduleIndex,\n            binding.lo,\n            binding.hi,\n          ) {\n            case Some(found) => types.push(found)\n            case None => ()\n          }\n        }\n      }\n    }\n    if types.length == alternatives.length && disconnectedPatternTypes(types) {\n      let first = match types.get(0) {\n        case Some(found) => found\n        case None => emptyType(\"unknown\")\n      }\n      let mut conflicting = first\n      for candidate in types {\n        if !typesOverlap(first, candidate) {\n          conflicting = candidate\n        }\n      }\n      let diagnosticNode = match alternatives.get(0) {\n        case Some(found) => found\n        case None => pattern\n      }\n      addDiagnostic(\n        state,\n        moduleIndex,\n        \"TPZ5711\",\n        \"binding `{name}` has type `{typeText(first)}` in one or-pattern alternative and `{typeText(conflicting)}` in another\",\n        \"\",\n        diagnosticNode,\n      )\n    }\n    if types.length > 0 {\n      let unified = unionType(types)\n      for binding in bindings {\n        bindSymbol(\n          state,\n          moduleIndex,\n          binding.lo,\n          binding.hi,\n          name,\n          unified,\n          mutable,\n        )\n      }\n    }\n  }\n  addNode(state, moduleIndex, \"pattern\", pattern, expected)\n  coverage\n}\n\nexport function patternBindingTypeAt(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  mutable: bool,\n  topLevel: bool,\n) -> PatternCoverage {\n  match pattern.kind {\n    case \"pattern/literal\" | \"pattern/range\" =>\n      checkLiteralPattern(service, state, moduleIndex, source, pattern, expected)\n    case \"pattern/binding\" => {\n      let nameNode = match child(pattern, \"name\") {\n        case Some(found) => found\n        case None => pattern\n      }\n      let name = text(source, nameNode)\n      match enumDefinitionForType(state, moduleIndex, expected) {\n        case Some(definition) => {\n          let mut variant: Option<EnumVariant> = None\n          for found in definition.variants {\n            if found.name == name { variant = Some(found) }\n          }\n          match variant {\n            case Some(found) => {\n              if found.payloads.length > 0 {\n                let underscores: Array<string> = []\n                let mut parts = underscores\n                let mut index = 0\n                while index < found.payloads.length {\n                  parts.push(\"_\")\n                  index += 1\n                }\n                addDiagnostic(\n                  state,\n                  moduleIndex,\n                  \"TPZ5004\",\n                  \"enum variant `{typeText(expected)}.{name}` carries {found.payloads.length} payload\" +\n                    if found.payloads.length == 1 { \"\" } else { \"s\" } +\n                    \" — write `case {name}(\" + stringJoin(parts, \", \") + \")` to match it\",\n                  \"\",\n                  nameNode,\n                )\n              }\n              addNode(state, moduleIndex, \"pattern\", pattern, expected)\n              return coverageWithKey(\"constructor:{name}/*\")\n            }\n            case None => if topLevel {\n              addDiagnostic(\n                state,\n                moduleIndex,\n                \"TPZ5001\",\n                \"`{name}` is not a variant of enum `{typeText(expected)}`\" +\n                  enumVariantSuggestion(definition, name) +\n                  \" (use `_` for a catch-all)\",\n                \"\",\n                nameNode,\n              )\n              addNode(state, moduleIndex, \"pattern\", pattern, expected)\n              return irrefutablePatternCoverage()\n            }\n          }\n        }\n        case None => ()\n      }\n      bindNamedPattern(service, state, moduleIndex, source, pattern, expected, mutable)\n    }\n    case \"pattern/typed\" => bindNamedPattern(\n      service,\n      state,\n      moduleIndex,\n      source,\n      pattern,\n      expected,\n      mutable,\n    )\n    case \"pattern/record\" | \"pattern/nominal-record\" => bindRecordPattern(\n      service,\n      state,\n      moduleIndex,\n      source,\n      pattern,\n      expected,\n      mutable,\n    )\n    case \"pattern/constructor\" => bindConstructorPattern(\n      service,\n      state,\n      moduleIndex,\n      source,\n      pattern,\n      expected,\n      mutable,\n    )\n    case \"pattern/list\" => bindListPattern(\n      service,\n      state,\n      moduleIndex,\n      source,\n      pattern,\n      expected,\n      mutable,\n    )\n    case \"pattern/or\" => bindOrPattern(\n      service,\n      state,\n      moduleIndex,\n      source,\n      pattern,\n      expected,\n      mutable,\n      topLevel,\n    )\n    case \"pattern/wildcard\" => {\n      addNode(state, moduleIndex, \"pattern\", pattern, expected)\n      irrefutablePatternCoverage()\n    }\n    case _ => {\n      addNode(state, moduleIndex, \"pattern\", pattern, expected)\n      emptyPatternCoverage()\n    }\n  }\n}\n\nexport function patternBindingType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  pattern: SyntaxNode,\n  expected: TypeValue,\n  mutable: bool,\n) -> PatternCoverage {\n  patternBindingTypeAt(\n    service,\n    state,\n    moduleIndex,\n    source,\n    pattern,\n    expected,\n    mutable,\n    false,\n  )\n}\n",
      "sourceSha256": "cb0e92d481ad5490a1b3dc9a8456ba6e67764abbe24516b943173b34fc0bc614"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/protocols_methods.tpz",
      "language": "topaz",
      "bytes": 43868,
      "sha256": "7786cf11b77feea419d3b324080efce5887a385d44f903d119731f5e6d95f4d1",
      "content": "// Collection and validation of protocols, conformances, and receiver methods.\n// Nominal formation precedes this leaf, and member capability lookup consumes\n// the resulting catalogs afterward.\n\nimport types { SyntaxNode }\nimport checker_types { TypeValue }\nimport checker.model {\n  CallSignature,\n  CheckerService,\n  CheckerState,\n  EnumDefinition,\n  FunctionDefinition,\n  ModuleSyntax,\n  NewtypeDefinition,\n  ProtocolConformance,\n  ProtocolDefinition,\n  ProtocolMethodDefinition,\n  ReceiverMethodDefinition,\n  RecordDefinition,\n  emptyType,\n  functionType,\n  nominal,\n  nominalInModule,\n  primitive,\n  rigid,\n}\nimport checker.type_algebra {\n  typeEqual,\n  typeListText,\n  typeText,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  bindSymbol,\n  boolAttribute,\n  child,\n  children,\n  containsString,\n  declarationFor,\n  definitionNameKey,\n  enumDefinitionIndex,\n  functionBounds,\n  moduleIdentityAt,\n  moduleIndexByIdentity,\n  newtypeDefinitionIndex,\n  protocolDefinition,\n  protocolMethodDefinition,\n  recordDefinitionIndex,\n  referenceFor,\n  registerTypeParameters,\n  resolvedTypeOfReference,\n  spanKey,\n  text,\n  typeParameterNames,\n  unwrapExport,\n}\nimport checker.nominals {\n  formType,\n  substitute,\n}\n\nexport function protocolConformanceIndex(\n  state: CheckerState,\n  moduleIndex: int,\n  typeName: string,\n  protocol: string,\n) -> int {\n  match state.conformanceIndexes.get(conformanceKey(\n    moduleIndex,\n    typeName,\n    protocol,\n  )) {\n    case Some(index) => index\n    case None => -1\n  }\n}\n\nexport function appendConformance(\n  state: CheckerState,\n  moduleIndex: int,\n  typeName: string,\n  protocol: string,\n  derived: bool,\n) -> () {\n  let mut conformances = state.conformances\n  let index = conformances.length\n  let mut indexes = state.conformanceIndexes\n  indexes.insert(conformanceKey(moduleIndex, typeName, protocol), index)\n  let mut typeIndexes = state.conformanceTypeIndexes\n  typeIndexes.insert(conformanceTypeKey(typeName, protocol), index)\n  conformances.push(ProtocolConformance {\n    moduleIndex: moduleIndex,\n    typeName: typeName,\n    protocol: protocol,\n    derived: derived,\n  })\n  ()\n}\n\nexport function builtinProtocolDefinition(name: string) -> Option<ProtocolDefinition> {\n  let conforming = rigid(\"Self\", \"builtin::{name}::protocol\")\n  if name == \"Show\" {\n    return Some(ProtocolDefinition {\n      name: name,\n      methods: [ProtocolMethodDefinition {\n        name: \"show\",\n        parameterNames: [\"value\"],\n        typeValue: functionType([conforming], [], primitive(\"string\")),\n      }],\n    })\n  }\n  if name == \"Eq\" {\n    return Some(ProtocolDefinition {\n      name: name,\n      methods: [ProtocolMethodDefinition {\n        name: \"equals\",\n        parameterNames: [\"a\", \"b\"],\n        typeValue: functionType(\n          [conforming, conforming],\n          [],\n          primitive(\"bool\"),\n        ),\n      }],\n    })\n  }\n  if name == \"Order\" {\n    return Some(ProtocolDefinition {\n      name: name,\n      methods: [ProtocolMethodDefinition {\n        name: \"compare\",\n        parameterNames: [\"a\", \"b\"],\n        typeValue: functionType(\n          [conforming, conforming],\n          [],\n          primitive(\"int\"),\n        ),\n      }],\n    })\n  }\n  if name == \"JSON\" {\n    return Some(ProtocolDefinition { name: name, methods: [] })\n  }\n  None\n}\n\nfunction protocolDefinitionForImpl(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<ProtocolDefinition> {\n  match builtinProtocolDefinition(name) {\n    case Some(found) => Some(found)\n    case None => protocolDefinition(state, moduleIndex, name)\n  }\n}\n\nrecord OwnNominalImplTarget {\n  typeValue: TypeValue,\n  typeParameterCount: int,\n}\n\nfunction ownNominalImplTarget(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<OwnNominalImplTarget> {\n  let recordIndex = recordDefinitionIndex(state, moduleIndex, name)\n  if recordIndex >= 0 {\n    return match state.records.get(recordIndex) {\n      case Some(definition) => Some(OwnNominalImplTarget {\n        typeValue: nominalInModule(\n          \"nominal-record\",\n          name,\n          [],\n          moduleIdentityAt(state, moduleIndex),\n        ),\n        typeParameterCount: definition.typeParameters.length,\n      })\n      case None => None\n    }\n  }\n  let enumIndex = enumDefinitionIndex(state, moduleIndex, name)\n  if enumIndex >= 0 {\n    return match state.enums.get(enumIndex) {\n      case Some(definition) => Some(OwnNominalImplTarget {\n        typeValue: nominalInModule(\n          \"enum\",\n          name,\n          [],\n          moduleIdentityAt(state, moduleIndex),\n        ),\n        typeParameterCount: definition.typeParameters.length,\n      })\n      case None => None\n    }\n  }\n  let newtypeIndex = newtypeDefinitionIndex(state, moduleIndex, name)\n  if newtypeIndex >= 0 {\n    return match state.newtypes.get(newtypeIndex) {\n      case Some(definition) => Some(OwnNominalImplTarget {\n        typeValue: nominalInModule(\n          \"newtype\",\n          name,\n          [],\n          moduleIdentityAt(state, moduleIndex),\n        ),\n        typeParameterCount: definition.typeParameters.length,\n      })\n      case None => None\n    }\n  }\n  None\n}\n\nfunction predeclareProtocolImplMethod(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  declaration: SyntaxNode,\n) -> () {\n  let prepared = prepareFunctionDeclaration(\n    service,\n    state,\n    module,\n    declaration,\n    None,\n  )\n  let mut functions = state.functions\n  let index = functions.length\n  functions.push(prepared.definition)\n  let mut pending = state.pendingFunctions\n  pending.push(prepared.definition.result.kind == \"unknown\")\n  let mut indexes = state.functionIndexes\n  indexes.insert(\n    spanKey(\n      module.moduleIndex,\n      prepared.nameNode.lo,\n      prepared.nameNode.hi,\n    ),\n    index,\n  )\n  ()\n}\n\nfunction protocolImplMethodDefinition(\n  state: CheckerState,\n  moduleIndex: int,\n  declaration: SyntaxNode,\n) -> Option<FunctionDefinition> {\n  let nameNode = match child(declaration, \"name\") {\n    case Some(found) => found\n    case None => return None\n  }\n  match state.functionIndexes.get(spanKey(\n    moduleIndex,\n    nameNode.lo,\n    nameNode.hi,\n  )) {\n    case Some(index) => state.functions.get(index)\n    case None => None\n  }\n}\n\nfunction protocolImplExpectedType(\n  method: ProtocolMethodDefinition,\n  receiver: TypeValue,\n) -> TypeValue {\n  substitute(method.typeValue, [\"Self\"], [receiver])\n}\n\nfunction protocolImplSignatureText(value: TypeValue) -> string {\n  \"(\" + typeListText(value.parameters) + \") -> `\" +\n    typeText(match value.result.get(0) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }) + \"`\"\n}\n\nfunction registerManualConformance(\n  state: CheckerState,\n  moduleIndex: int,\n  typeName: string,\n  protocol: string,\n) -> () {\n  appendConformance(state, moduleIndex, typeName, protocol, false)\n}\n\nrecord ProtocolImplCheckContext {\n  state: CheckerState,\n  module: ModuleSyntax,\n  protocol: string,\n  typeName: string,\n  definition: ProtocolDefinition,\n  receiver: TypeValue,\n}\n\nfunction checkProtocolImplMethod(\n  context: ProtocolImplCheckContext,\n  method: SyntaxNode,\n  seen: Set<string>,\n) -> bool {\n  let declaration = match child(method, \"declaration\") {\n    case Some(found) => found\n    case None => return false\n  }\n  let methodNameNode = match child(declaration, \"name\") {\n    case Some(found) => found\n    case None => return false\n  }\n  let methodName = text(context.module.source, methodNameNode)\n  match protocolMethodDefinition(\n    context.definition,\n    methodName,\n  ) {\n    case Some(expectedMethod) => checkProtocolImplMethodAgainstDefinition(\n      context,\n      method,\n      seen,\n      declaration,\n      methodNameNode,\n      methodName,\n      expectedMethod,\n    )\n    case None => {\n      addDiagnostic(\n        context.state,\n        context.module.moduleIndex,\n        \"TPZ5022\",\n        \"protocol `{context.protocol}` has no method `{methodName}`\",\n        \"\",\n        methodNameNode,\n      )\n      false\n    }\n  }\n}\n\nfunction checkProtocolImplMethodAgainstDefinition(\n  context: ProtocolImplCheckContext,\n  method: SyntaxNode,\n  seen: Set<string>,\n  declaration: SyntaxNode,\n  methodNameNode: SyntaxNode,\n  methodName: string,\n  expectedMethod: ProtocolMethodDefinition,\n) -> bool {\n  if seen.contains(methodName) {\n    addDiagnostic(\n      context.state,\n      context.module.moduleIndex,\n      \"TPZ5008\",\n      \"method `{methodName}` is implemented twice in `impl {context.protocol}<{context.typeName}>`\",\n      \"\",\n      methodNameNode,\n    )\n    return false\n  }\n  let mut acceptedNames = seen\n  acceptedNames.add(methodName)\n  if boolAttribute(method, \"exported\") {\n    addDiagnostic(\n      context.state,\n      context.module.moduleIndex,\n      \"TPZ5022\",\n      \"protocol implementation method `{context.protocol}.{methodName}` is module-local and cannot be exported\",\n      \"\",\n      method,\n    )\n    return false\n  }\n  if children(declaration, \"typeParameters\").length > 0 {\n    addDiagnostic(\n      context.state,\n      context.module.moduleIndex,\n      \"TPZ5022\",\n      \"protocol implementation method `{context.protocol}.{methodName}` cannot be generic\",\n      \"\",\n      methodNameNode,\n    )\n    return false\n  }\n  match child(declaration, \"returnType\") {\n    case Some(_) => ()\n    case None => {\n      addDiagnostic(\n        context.state,\n        context.module.moduleIndex,\n        \"TPZ5022\",\n        \"protocol implementation method `{context.protocol}.{methodName}` requires an explicit return type (use `-> ()` for unit)\",\n        \"\",\n        methodNameNode,\n      )\n      return false\n    }\n  }\n  for parameter in children(declaration, \"parameters\") {\n    if boolAttribute(parameter, \"variadic\") {\n      addDiagnostic(\n        context.state,\n        context.module.moduleIndex,\n        \"TPZ5022\",\n        \"protocol implementation method `{context.protocol}.{methodName}` cannot be variadic\",\n        \"\",\n        parameter,\n      )\n      return false\n    }\n  }\n  for parameter in children(declaration, \"parameters\") {\n    match child(parameter, \"default\") {\n      case Some(_) => {\n        addDiagnostic(\n          context.state,\n          context.module.moduleIndex,\n          \"TPZ5022\",\n          \"protocol implementation method `{context.protocol}.{methodName}` cannot declare parameter defaults\",\n          \"\",\n          parameter,\n        )\n        return false\n      }\n      case None => ()\n    }\n  }\n  let actualDefinition = match protocolImplMethodDefinition(\n    context.state,\n    context.module.moduleIndex,\n    declaration,\n  ) {\n    case Some(found) => found\n    case None => return false\n  }\n  let actualType = functionType(\n    actualDefinition.parameterTypes,\n    actualDefinition.variadic,\n    actualDefinition.result,\n  )\n  let expectedType = protocolImplExpectedType(\n    expectedMethod,\n    context.receiver,\n  )\n  if typeEqual(actualType, expectedType) {\n    return true\n  }\n  addDiagnostic(\n    context.state,\n    context.module.moduleIndex,\n    \"TPZ5022\",\n    \"protocol implementation method `{context.protocol}.{methodName}` must match the declared signature exactly; expected {protocolImplSignatureText(expectedType)}, found {protocolImplSignatureText(actualType)}\",\n    \"\",\n    methodNameNode,\n  )\n  false\n}\n\nfunction collectProtocolImpl(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  statement: SyntaxNode,\n) -> () {\n  let item = unwrapExport(statement)\n  if item.kind != \"statement/impl\" {\n    return ()\n  }\n  if statement.kind == \"statement/export\" {\n    return ()\n  }\n  let targetNode = match child(item, \"target\") {\n    case Some(found) => found\n    case None => return ()\n  }\n  let protocolNode = match child(item, \"name\") {\n    case Some(found) => found\n    case None => return ()\n  }\n  for method in children(item, \"methods\") {\n    match child(method, \"declaration\") {\n      case Some(declaration) => predeclareProtocolImplMethod(\n        service,\n        state,\n        module,\n        declaration,\n      )\n      case None => ()\n    }\n  }\n  let protocol = text(module.source, protocolNode)\n  let typeName = text(module.source, targetNode)\n  match protocolDefinitionForImpl(\n    state,\n    module.moduleIndex,\n    protocol,\n  ) {\n    case Some(protocolDefinitionValue) => collectProtocolImplForDefinition(\n      state,\n      module,\n      item,\n      targetNode,\n      protocolNode,\n      protocol,\n      typeName,\n      protocolDefinitionValue,\n    )\n    case None => {\n      addDiagnostic(\n        state,\n        module.moduleIndex,\n        \"TPZ5022\",\n        \"unknown protocol `{protocol}` in `impl {protocol}<{typeName}>`\",\n        \"\",\n        protocolNode,\n      )\n      ()\n    }\n  }\n}\n\nfunction collectProtocolImplForDefinition(\n  state: CheckerState,\n  module: ModuleSyntax,\n  item: SyntaxNode,\n  targetNode: SyntaxNode,\n  protocolNode: SyntaxNode,\n  protocol: string,\n  typeName: string,\n  protocolDefinitionValue: ProtocolDefinition,\n) -> () {\n  if protocol == \"JSON\" {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"`JSON` conformance is derive-only; use `derives JSON`\",\n      \"\",\n      protocolNode,\n    )\n    return ()\n  }\n  match ownNominalImplTarget(\n    state,\n    module.moduleIndex,\n    typeName,\n  ) {\n    case Some(target) => collectProtocolImplForTarget(\n      state,\n      module,\n      item,\n      targetNode,\n      protocolNode,\n      protocol,\n      typeName,\n      protocolDefinitionValue,\n      target,\n    )\n    case None => {\n      let ownProtocol = match builtinProtocolDefinition(protocol) {\n        case Some(_) => false\n        case None => true\n      }\n      addDiagnostic(\n        state,\n        module.moduleIndex,\n        \"TPZ5520\",\n        if ownProtocol {\n          \"cannot implement `{protocol}` for `{typeName}`: a protocol impl's conforming type must be an own-module record/enum/newtype\"\n        } else {\n          \"cannot implement foreign protocol `{protocol}` for foreign type `{typeName}` (orphan rule §4.2): the protocol or the type must be defined in this module\"\n        },\n        \"\",\n        targetNode,\n      )\n      ()\n    }\n  }\n}\n\nfunction collectProtocolImplForTarget(\n  state: CheckerState,\n  module: ModuleSyntax,\n  item: SyntaxNode,\n  targetNode: SyntaxNode,\n  protocolNode: SyntaxNode,\n  protocol: string,\n  typeName: string,\n  protocolDefinitionValue: ProtocolDefinition,\n  target: OwnNominalImplTarget,\n) -> () {\n  if target.typeParameterCount > 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"cannot implement protocol `{protocol}` for generic nominal `{typeName}` yet; generic conformance binders are not defined\",\n      \"\",\n      targetNode,\n    )\n    return ()\n  }\n  let existingIndex = protocolConformanceIndex(\n    state,\n    module.moduleIndex,\n    typeName,\n    protocol,\n  )\n  if existingIndex >= 0 {\n    let how = match state.conformances.get(existingIndex) {\n      case Some(existing) => if existing.derived {\n        \"via `derives`\"\n      } else {\n        \"by a previous `impl`\"\n      }\n      case None => \"by a previous `impl`\"\n    }\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5521\",\n      \"`{typeName}` already conforms to `{protocol}` {how}; a conformance must be unique\",\n      \"\",\n      targetNode,\n    )\n    return ()\n  }\n  let mut seen: Set<string> = set {}\n  let mut valid = true\n  let context = ProtocolImplCheckContext {\n    state: state,\n    module: module,\n    protocol: protocol,\n    typeName: typeName,\n    definition: protocolDefinitionValue,\n    receiver: target.typeValue,\n  }\n  for method in children(item, \"methods\") {\n    if !checkProtocolImplMethod(context, method, seen) {\n      valid = false\n    }\n  }\n  for required in protocolDefinitionValue.methods {\n    if !seen.contains(required.name) {\n      addDiagnostic(\n        state,\n        module.moduleIndex,\n        \"TPZ5022\",\n        \"`impl {protocol}<{typeName}>` is missing method `{required.name}`\",\n        \"\",\n        protocolNode,\n      )\n      valid = false\n    }\n  }\n  if valid {\n    registerManualConformance(\n      state,\n      module.moduleIndex,\n      typeName,\n      protocol,\n    )\n  }\n  ()\n}\n\nexport function collectProtocolImpls(service: CheckerService, state: CheckerState) -> () {\n  for module in state.modules {\n    for statement in module.root.children {\n      collectProtocolImpl(service, state, module, statement)\n    }\n  }\n  ()\n}\n\nfunction receiverMethodKey(\n  moduleIndex: int,\n  typeName: string,\n  methodName: string,\n) -> string {\n  definitionNameKey(moduleIndex, \"{typeName}.{methodName}\")\n}\n\nexport function conformanceTypeKey(typeName: string, protocol: string) -> string {\n  \"{protocol.byteLength()}:{protocol}{typeName}\"\n}\n\nfunction conformanceKey(\n  moduleIndex: int,\n  typeName: string,\n  protocol: string,\n) -> string {\n  definitionNameKey(moduleIndex, conformanceTypeKey(typeName, protocol))\n}\n\nfunction builtinReceiverTypeName(name: string) -> bool {\n  match name {\n    case \"int\" | \"float\" | \"string\" | \"bool\" | \"template\" | \"Array\" | \"Map\" |\n      \"Set\" | \"Option\" | \"Result\" | \"JSONValue\" | \"File\" | \"Bytes\" |\n      \"ByteBuffer\" | \"Path\" | \"Regex\" | \"Match\" | \"TOMLValue\" | \"URL\" |\n      \"Date\" | \"BigInt\" | \"Decimal\" | \"RoundingMode\" => true\n    case _ => false\n  }\n}\n\nfunction reservedReceiverMethodName(name: string, languageMode: string) -> bool {\n  if languageMode == \"topaz-5.21\" && (name == \"mapErr\" || name == \"unwrapOr\" || name == \"and\" || name == \"or\" || name == \"xor\" || name == \"shift\" || name == \"encodeUtf8\" || name == \"concat\" || name == \"sha256\" || name == \"sha512\" || name == \"hmacSha256\" || name == \"crc32\" || name == \"gzipCompress\" || name == \"gzipDecompress\" || name == \"deflateCompress\" || name == \"deflateFixedCompress\" || name == \"zlibFixedCompress\" || name == \"reedSolomon255223Protect\" || name == \"deflateDecompress\" || name == \"zstdCompress\" || name == \"zstdDecompress\" || name == \"hasFlag\" || name == \"option\" || name == \"options\" || name == \"positionals\" || name == \"toBigInt\" || name == \"toDecimal\" || name == \"toJson\" || name == \"decode\") { return true }\n  if languageMode == \"topaz-5.21\" && (name == \"trunc\" || name == \"floor\" || name == \"ceil\" || name == \"sqrt\" || name == \"abs\" || name == \"sin\" || name == \"cos\" || name == \"tan\" || name == \"isNaN\" || name == \"isFinite\" || name == \"parseFloat\" || name == \"toFloat\" || name == \"toIntRadix\" || name == \"toCodePoint\") { return true }\n  match name {\n    case \"atLeast\" | \"atMost\" | \"scalars\" | \"startsWith\" | \"endsWith\" |\n      \"contains\" | \"indexOf\" | \"lastIndexOf\" | \"trim\" | \"trimStart\" |\n      \"trimEnd\" | \"byteLength\" | \"codePointAt\" | \"split\" | \"slice\" |\n      \"replace\" | \"okOr\" | \"okOrElse\" | \"map\" | \"flatMap\" | \"filter\" |\n      \"reduce\" | \"push\" | \"get\" | \"length\" | \"join\" | \"sorted\" |\n      \"sortedBy\" | \"pop\" | \"clear\" | \"reverse\" | \"insert\" | \"removeAt\" |\n      \"sort\" | \"sortBy\" | \"retain\" | \"getOr\" | \"remove\" | \"keys\" |\n      \"values\" | \"entries\" | \"isEmpty\" | \"containsKey\" | \"update\" |\n      \"mapValues\" | \"add\" | \"toArray\" | \"union\" | \"intersection\" |\n      \"difference\" | \"read\" | \"write\" | \"close\" | \"tag\" | \"parts\" |\n      \"kind\" | \"isNull\" | \"asString\" | \"asBool\" | \"asInt\" |\n      \"numberText\" | \"at\" | \"asArray\" | \"decodeUtf8\" | \"toHex\" |\n      \"toBase64\" | \"set\" | \"fill\" | \"copy\" | \"toBytes\" | \"parent\" |\n      \"fileName\" | \"extension\" | \"withExtension\" | \"normalize\" |\n      \"toString\" | \"isMatch\" | \"find\" | \"findAll\" | \"replaceAll\" |\n      \"start\" | \"end\" | \"text\" | \"groups\" | \"named\" | \"scheme\" |\n      \"host\" | \"path\" | \"query\" | \"fragment\" | \"toIso\" | \"addDays\" |\n      \"year\" | \"month\" | \"day\" | \"toInt\" | \"div\" | \"mod\" | \"scale\" |\n      \"round\" | \"value\" => true\n    case _ => false\n  }\n}\n\nfunction bareSelfParameter(source: Bytes, parameter: SyntaxNode) -> bool {\n  let nameNode = match child(parameter, \"name\") {\n    case Some(found) => found\n    case None => return false\n  }\n  let implicitType = match child(parameter, \"type\") {\n    case Some(found) => found.kind == \"type/named\" &&\n      found.lo == nameNode.lo && found.hi == nameNode.hi\n    case None => false\n  }\n  let noDefault = match child(parameter, \"default\") {\n    case Some(_) => false\n    case None => true\n  }\n  text(source, nameNode) == \"self\" && !boolAttribute(parameter, \"variadic\") && implicitType &&\n    noDefault\n}\n\nfunction predeclareReceiverImplMethod(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  declaration: SyntaxNode,\n  typeName: string,\n  receiver: TypeValue,\n  exported: bool,\n) -> () {\n  let prepared = prepareFunctionDeclaration(\n    service,\n    state,\n    module,\n    declaration,\n    Some(receiver),\n  )\n  let definition = prepared.definition\n  let mut functions = state.functions\n  let functionIndex = functions.length\n  functions.push(definition)\n  let mut pending = state.pendingFunctions\n  pending.push(definition.result.kind == \"unknown\")\n  let mut functionIndexes = state.functionIndexes\n  functionIndexes.insert(\n    spanKey(module.moduleIndex, prepared.nameNode.lo, prepared.nameNode.hi),\n    functionIndex,\n  )\n  let mut receiverMethods = state.receiverMethods\n  let methodIndex = receiverMethods.length\n  receiverMethods.push(ReceiverMethodDefinition {\n    moduleIndex: module.moduleIndex,\n    typeName: typeName,\n    name: definition.name,\n    functionIndex: functionIndex,\n    exported: exported,\n  })\n  let mut indexes = state.receiverMethodIndexes\n  indexes.insert(\n    receiverMethodKey(module.moduleIndex, typeName, definition.name),\n    methodIndex,\n  )\n  ()\n}\n\nfunction collectReceiverImplMethod(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  method: SyntaxNode,\n  declaration: SyntaxNode,\n  typeName: string,\n  receiver: TypeValue,\n) -> () {\n  let methodNameNode = match child(declaration, \"name\") {\n    case Some(found) => found\n    case None => declaration\n  }\n  let methodName = text(module.source, methodNameNode)\n  let parameters = children(declaration, \"parameters\")\n  if parameters.length == 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"method `{methodName}` on `{typeName}` must take `self` as its first parameter\",\n      \"\",\n      methodNameNode,\n    )\n    return ()\n  }\n  let first = parameters[0]\n  if !bareSelfParameter(module.source, first) {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"method `{methodName}` on `{typeName}` must take bare `self` as its first parameter (no type annotation, default, or variadic marker)\",\n      \"\",\n      first,\n    )\n    return ()\n  }\n  if children(declaration, \"typeParameters\").length > 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"generic methods are not supported yet (method `{methodName}`)\",\n      \"\",\n      methodNameNode,\n    )\n    return ()\n  }\n  if reservedReceiverMethodName(methodName, state.languageMode) {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"method name `{methodName}` on `{typeName}` collides with a builtin member; choose another name\",\n      \"\",\n      methodNameNode,\n    )\n    return ()\n  }\n  let key = receiverMethodKey(module.moduleIndex, typeName, methodName)\n  match state.receiverMethodIndexes.get(key) {\n    case Some(_) => {\n      addDiagnostic(\n        state,\n        module.moduleIndex,\n        \"TPZ5008\",\n        \"method `{methodName}` is already defined for `{typeName}`\",\n        \"\",\n        methodNameNode,\n      )\n      return ()\n    }\n    case None => ()\n  }\n  let recordIndex = recordDefinitionIndex(\n    state,\n    module.moduleIndex,\n    typeName,\n  )\n  let mut fieldCollision = false\n  match state.records.get(recordIndex) {\n    case Some(definition) => for field in definition.fields {\n      if field.name == methodName {\n        fieldCollision = true\n      }\n    }\n    case None => ()\n  }\n  if fieldCollision {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"method `{methodName}` on `{typeName}` collides with a field of the same name; rename the method (a field shadows a method)\",\n      \"\",\n      methodNameNode,\n    )\n    return ()\n  }\n  predeclareReceiverImplMethod(\n    service,\n    state,\n    module,\n    declaration,\n    typeName,\n    receiver,\n    boolAttribute(method, \"exported\"),\n  )\n  ()\n}\n\nfunction collectReceiverImpl(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  statement: SyntaxNode,\n) -> () {\n  let item = unwrapExport(statement)\n  if item.kind != \"statement/impl\" {\n    return ()\n  }\n  if statement.kind == \"statement/export\" {\n    let nameNode = match child(item, \"name\") {\n      case Some(found) => found\n      case None => item\n    }\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"an `impl` block cannot be exported; mark individual methods with `export`\",\n      \"\",\n      nameNode,\n    )\n    return ()\n  }\n  match child(item, \"target\") {\n    case Some(_) => return ()\n    case None => ()\n  }\n  let nameNode = match child(item, \"name\") {\n    case Some(found) => found\n    case None => return ()\n  }\n  let typeName = text(module.source, nameNode)\n  match ownNominalImplTarget(\n    state,\n    module.moduleIndex,\n    typeName,\n  ) {\n    case Some(target) => collectReceiverImplForTarget(\n      service,\n      state,\n      module,\n      item,\n      nameNode,\n      typeName,\n      target,\n    )\n    case None => {\n      let what = if builtinReceiverTypeName(typeName) {\n        \"a builtin type\"\n      } else {\n        \"not a declared record/enum/newtype in this module\"\n      }\n      addDiagnostic(\n        state,\n        module.moduleIndex,\n        \"TPZ5022\",\n        \"cannot define methods on `{typeName}` ({what}); `impl` is only allowed on an own-module record, enum, or newtype\",\n        \"\",\n        nameNode,\n      )\n      ()\n    }\n  }\n}\n\nfunction collectReceiverImplForTarget(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  item: SyntaxNode,\n  nameNode: SyntaxNode,\n  typeName: string,\n  target: OwnNominalImplTarget,\n) -> () {\n  if target.typeParameterCount > 0 {\n    addDiagnostic(\n      state,\n      module.moduleIndex,\n      \"TPZ5022\",\n      \"cannot define receiver methods on generic nominal `{typeName}` yet; generic `impl` binders are not defined\",\n      \"\",\n      nameNode,\n    )\n    return ()\n  }\n  for method in children(item, \"methods\") {\n    match child(method, \"declaration\") {\n      case Some(declaration) => collectReceiverImplMethod(\n        service,\n        state,\n        module,\n        method,\n        declaration,\n        typeName,\n        target.typeValue,\n      )\n      case None => ()\n    }\n  }\n  ()\n}\n\nexport function collectReceiverImpls(service: CheckerService, state: CheckerState) -> () {\n  for module in state.modules {\n    for statement in module.root.children {\n      collectReceiverImpl(service, state, module, statement)\n    }\n  }\n  ()\n}\n\nfunction receiverMethodDefinitionForType(\n  state: CheckerState,\n  moduleIndex: int,\n  receiver: TypeValue,\n  methodName: string,\n) -> Option<ReceiverMethodDefinition> {\n  let mut targetModule = -1\n  let mut targetName = receiver.identity\n  match recordDefinitionForType(state, moduleIndex, receiver) {\n    case Some(definition) => {\n      targetModule = definition.moduleIndex\n      targetName = definition.name\n    }\n    case None => match enumDefinitionForType(state, moduleIndex, receiver) {\n      case Some(definition) => {\n        targetModule = definition.moduleIndex\n        targetName = definition.name\n      }\n      case None => match newtypeDefinitionForType(state, moduleIndex, receiver) {\n        case Some(definition) => {\n          targetModule = definition.moduleIndex\n          targetName = definition.name\n        }\n        case None => ()\n      }\n    }\n  }\n  if targetModule < 0 {\n    if receiver.kind == \"foreign\" {\n      for definition in state.receiverMethods {\n        if definition.name == methodName &&\n          \"{moduleIdentityAt(state, definition.moduleIndex)}::{definition.typeName}\" == receiver.identity &&\n          definition.exported {\n          return Some(definition)\n        }\n      }\n    }\n    return None\n  }\n  let index = match state.receiverMethodIndexes.get(receiverMethodKey(\n    targetModule,\n    targetName,\n    methodName,\n  )) {\n    case Some(found) => found\n    case None => return None\n  }\n  match state.receiverMethods.get(index) {\n    case Some(definition) => if definition.moduleIndex == moduleIndex ||\n      definition.exported {\n      Some(definition)\n    } else {\n      None\n    }\n    case None => None\n  }\n}\n\nfunction receiverMethodFunction(\n  state: CheckerState,\n  moduleIndex: int,\n  receiver: TypeValue,\n  methodName: string,\n) -> Option<FunctionDefinition> {\n  match receiverMethodDefinitionForType(\n    state,\n    moduleIndex,\n    receiver,\n    methodName,\n  ) {\n    case Some(method) => state.functions.get(method.functionIndex)\n    case None => None\n  }\n}\n\nexport function receiverMethodType(\n  state: CheckerState,\n  moduleIndex: int,\n  receiver: TypeValue,\n  methodName: string,\n) -> Option<TypeValue> {\n  match receiverMethodFunction(\n    state,\n    moduleIndex,\n    receiver,\n    methodName,\n  ) {\n    case Some(definition) => {\n      let mut parameters: Array<TypeValue> = []\n      let mut index = 1\n      while index < definition.parameterTypes.length {\n        match definition.parameterTypes.get(index) {\n          case Some(found) => parameters.push(found)\n          case None => ()\n        }\n        index += 1\n      }\n      Some(functionType(parameters, definition.variadic, definition.result))\n    }\n    case None => None\n  }\n}\n\nexport function receiverMethodCallSignature(\n  state: CheckerState,\n  moduleIndex: int,\n  receiver: TypeValue,\n  methodName: string,\n) -> Option<CallSignature> {\n  match receiverMethodFunction(\n    state,\n    moduleIndex,\n    receiver,\n    methodName,\n  ) {\n    case Some(definition) => {\n      let mut names: Array<string> = []\n      let mut defaults: Array<bool> = []\n      let mut index = 1\n      while index < definition.parameterNames.length {\n        match definition.parameterNames.get(index) {\n          case Some(found) => names.push(found)\n          case None => ()\n        }\n        index += 1\n      }\n      index = 1\n      while index < definition.parameterDefaults.length {\n        match definition.parameterDefaults.get(index) {\n          case Some(found) => defaults.push(found)\n          case None => ()\n        }\n        index += 1\n      }\n      Some(CallSignature {\n        parameterNames: names,\n        parameterDefaults: defaults,\n        parameterCount: definition.parameterTypes.length - 1,\n        variadic: definition.variadic.length > 0,\n        positionalOnlyIdentity: \"\",\n      })\n    }\n    case None => None\n  }\n}\n\nexport function receiverMethodTargetIdentity(\n  state: CheckerState,\n  moduleIndex: int,\n  receiver: TypeValue,\n  methodName: string,\n) -> string {\n  match receiverMethodDefinitionForType(\n    state,\n    moduleIndex,\n    receiver,\n    methodName,\n  ) {\n    case Some(method) => \"{moduleIdentityAt(state, method.moduleIndex)}::{method.typeName}\"\n    case None => \"\"\n  }\n}\n\nexport function functionDeclaration(item: SyntaxNode) -> Option<SyntaxNode> {\n  if item.kind != \"statement/function\" {\n    return None\n  }\n  child(item, \"declaration\")\n}\n\nrecord FunctionParameterShape {\n  names: Array<string>,\n  types: Array<TypeValue>,\n  defaults: Array<bool>,\n  variadic: Array<TypeValue>,\n}\n\nrecord PreparedFunctionDeclaration {\n  nameNode: SyntaxNode,\n  definition: FunctionDefinition,\n  typeValue: TypeValue,\n}\n\nfunction formFunctionParameterType(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  parameter: SyntaxNode,\n  parameters: Array<string>,\n  origin: string,\n) -> TypeValue {\n  match child(parameter, \"type\") {\n    case Some(found) => formType(\n      service,\n      state,\n      module.moduleIndex,\n      module.source,\n      found,\n      parameters,\n      origin,\n    )\n    case None => emptyType(\"unknown\")\n  }\n}\n\nfunction formFunctionParameterShape(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  declaration: SyntaxNode,\n  parameters: Array<string>,\n  origin: string,\n  firstType: Option<TypeValue>,\n) -> FunctionParameterShape {\n  let mut names: Array<string> = []\n  let mut types: Array<TypeValue> = []\n  let mut defaults: Array<bool> = []\n  let mut variadic: Array<TypeValue> = []\n  let mut parameterIndex = 0\n  for parameter in children(declaration, \"parameters\") {\n    names.push(match child(parameter, \"name\") {\n      case Some(found) => text(module.source, found)\n      case None => \"\"\n    })\n    let formed = if parameterIndex == 0 {\n      match firstType {\n        case Some(found) => found\n        case None => formFunctionParameterType(\n          service,\n          state,\n          module,\n          parameter,\n          parameters,\n          origin,\n        )\n      }\n    } else {\n      formFunctionParameterType(\n        service,\n        state,\n        module,\n        parameter,\n        parameters,\n        origin,\n      )\n    }\n    if boolAttribute(parameter, \"variadic\") {\n      variadic.push(formed)\n    } else {\n      types.push(formed)\n      defaults.push(match child(parameter, \"default\") {\n        case Some(_) => true\n        case None => false\n      })\n    }\n    parameterIndex += 1\n  }\n  FunctionParameterShape {\n    names: names,\n    types: types,\n    defaults: defaults,\n    variadic: variadic,\n  }\n}\n\nfunction prepareFunctionDeclaration(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  declaration: SyntaxNode,\n  firstType: Option<TypeValue>,\n) -> PreparedFunctionDeclaration {\n  let nameNode = match child(declaration, \"name\") {\n    case Some(found) => found\n    case None => declaration\n  }\n  let name = text(module.source, nameNode)\n  let parameters = typeParameterNames(module.source, declaration)\n  registerTypeParameters(state, module.moduleIndex, module.source, declaration)\n  let origin = \"source:{module.sourceOrdinal}:{declaration.lo}:{declaration.hi}\"\n  let mut typeParameterOrigins: Array<string> = []\n  for parameter in children(declaration, \"typeParameters\") {\n    typeParameterOrigins.push(\n      \"source:{module.sourceOrdinal}:{parameter.lo}:{parameter.hi}\",\n    )\n  }\n  let shape = formFunctionParameterShape(\n    service,\n    state,\n    module,\n    declaration,\n    parameters,\n    origin,\n    firstType,\n  )\n  let result = match child(declaration, \"returnType\") {\n    case Some(found) => formType(\n      service,\n      state,\n      module.moduleIndex,\n      module.source,\n      found,\n      parameters,\n      origin,\n    )\n    case None => emptyType(\"unknown\")\n  }\n  PreparedFunctionDeclaration {\n    nameNode: nameNode,\n    definition: FunctionDefinition {\n      moduleIndex: module.moduleIndex,\n      name: name,\n      lo: nameNode.lo,\n      hi: nameNode.hi,\n      typeParameters: parameters,\n      typeParameterOrigins: typeParameterOrigins,\n      parameterNames: shape.names,\n      parameterTypes: shape.types,\n      parameterDefaults: shape.defaults,\n      variadic: shape.variadic,\n      result: result,\n      bounds: functionBounds(module.source, declaration),\n    },\n    typeValue: functionType(shape.types, shape.variadic, result),\n  }\n}\n\nfunction predeclareFunction(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n  declaration: SyntaxNode,\n  moduleLevel: bool,\n) -> () {\n  let prepared = prepareFunctionDeclaration(\n    service,\n    state,\n    module,\n    declaration,\n    None,\n  )\n  let mut functions = state.functions\n  let index = functions.length\n  functions.push(prepared.definition)\n  let mut pending = state.pendingFunctions\n  pending.push(prepared.definition.result.kind == \"unknown\")\n  let mut indexes = state.functionIndexes\n  indexes.insert(\n    spanKey(module.moduleIndex, prepared.nameNode.lo, prepared.nameNode.hi),\n    index,\n  )\n  if moduleLevel {\n    let mut nameIndexes = state.functionNameIndexes\n    nameIndexes.insert(\n      definitionNameKey(module.moduleIndex, prepared.definition.name),\n      index,\n    )\n  }\n  bindSymbol(\n    state,\n    module.moduleIndex,\n    prepared.nameNode.lo,\n    prepared.nameNode.hi,\n    prepared.definition.name,\n    prepared.typeValue,\n    false,\n  )\n}\n\nexport function predeclareFunctions(service: CheckerService, state: CheckerState) -> () {\n  for module in state.modules {\n    for statement in module.root.children {\n      match functionDeclaration(unwrapExport(statement)) {\n        case Some(declaration) => predeclareFunction(service, state, module, declaration, true)\n        case None => ()\n      }\n    }\n  }\n  ()\n}\n\nexport function predeclareBlockFunctions(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  block: SyntaxNode,\n) -> () {\n  let mut names: Array<string> = []\n  match state.modules.get(moduleIndex) {\n    case Some(module) => for statement in children(block, \"statements\") {\n      match functionDeclaration(unwrapExport(statement)) {\n        case Some(declaration) => {\n          let name = match child(declaration, \"name\") {\n            case Some(found) => found\n            case None => declaration\n          }\n          let declaredName = text(module.source, name)\n          let duplicate = containsString(names, declaredName)\n          names.push(declaredName)\n          // A contextual revisit reuses the declaration's resolver identity.\n          match state.functionIndexes.get(spanKey(moduleIndex, name.lo, name.hi)) {\n            case Some(_) => ()\n            case None => {\n              if duplicate {\n                addDiagnostic(state, moduleIndex, \"TPZ5008\",\n                  \"`{declaredName}` is already declared in this scope\", \"\", name)\n              }\n              predeclareFunction(service, state, module, declaration, false)\n            }\n          }\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction recordTypeForName(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<TypeValue> {\n  let index = recordDefinitionIndex(state, moduleIndex, name)\n  if index < 0 {\n    return None\n  }\n  match state.records.get(index) {\n    case Some(definition) => {\n      let mut arguments: Array<TypeValue> = []\n      for parameter in definition.typeParameters {\n        arguments.push(rigid(parameter, \"{moduleIndex}::{name}\"))\n      }\n      Some(nominalInModule(\n        \"nominal-record\",\n        name,\n        arguments,\n        moduleIdentityAt(state, definition.moduleIndex),\n      ))\n    }\n    case None => None\n  }\n}\n\nfunction enumTypeForName(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<TypeValue> {\n  let index = enumDefinitionIndex(state, moduleIndex, name)\n  if index < 0 {\n    return None\n  }\n  match state.enums.get(index) {\n    case Some(definition) => {\n      let mut arguments: Array<TypeValue> = []\n      for parameter in definition.typeParameters {\n        arguments.push(rigid(parameter, \"{moduleIndex}::{name}\"))\n      }\n      Some(nominalInModule(\n        \"enum\",\n        name,\n        arguments,\n        moduleIdentityAt(state, definition.moduleIndex),\n      ))\n    }\n    case None => None\n  }\n}\n\nfunction newtypeTypeForName(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<TypeValue> {\n  let index = newtypeDefinitionIndex(state, moduleIndex, name)\n  if index < 0 {\n    return None\n  }\n  match state.newtypes.get(index) {\n    case Some(definition) => {\n      let mut arguments: Array<TypeValue> = []\n      for parameter in definition.typeParameters {\n        arguments.push(rigid(parameter, \"{moduleIndex}::{name}\"))\n      }\n      Some(nominalInModule(\n        \"newtype\",\n        name,\n        arguments,\n        moduleIdentityAt(state, definition.moduleIndex),\n      ))\n    }\n    case None => None\n  }\n}\n\nexport function nominalTypeHead(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> bool {\n  let name = if node.kind == \"expression/member\" {\n    match child(node, \"field\") { case Some(field) => field; case None => node }\n  } else {\n    node\n  }\n  match referenceFor(state, moduleIndex, name.lo, name.hi) {\n    case Some(reference) => reference.targetNamespace == \"type\"\n    case None => false\n  }\n}\n\nexport function referenceTargetType(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> Option<TypeValue> {\n  match resolvedTypeOfReference(state, moduleIndex, node) {\n    case Some(found) => Some(found)\n    case None => match referenceFor(state, moduleIndex, node.lo, node.hi) {\n      case Some(reference) => {\n        // Exact value targets were handled above. A type head must follow\n        // its selected declaration, never a same-name local in another scope.\n        if reference.targetNamespace != \"type\" { return None }\n        let mut targetModule = reference.targetModuleIndex\n        let mut targetName = reference.targetName\n        match declarationFor(\n          state,\n          reference.targetModuleIndex,\n          reference.targetLo,\n          reference.targetHi,\n        ) {\n          case Some(declaration) => if declaration.targetModule != \"\" {\n            targetModule = moduleIndexByIdentity(state, declaration.targetModule)\n            targetName = declaration.targetName\n          } else {\n            ()\n          }\n          case None => ()\n        }\n        match recordTypeForName(\n          state,\n          targetModule,\n          targetName,\n        ) {\n          case Some(found) => Some(found)\n          case None => match enumTypeForName(\n            state,\n            targetModule,\n            targetName,\n          ) {\n            case Some(found) => Some(found)\n            case None => newtypeTypeForName(\n              state,\n              targetModule,\n              targetName,\n            )\n          }\n        }\n      }\n      case None => None\n    }\n  }\n}\n\nexport function recordDefinitionForType(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n) -> Option<RecordDefinition> {\n  if value.kind != \"nominal-record\" {\n    return None\n  }\n  if value.origin != \"\" {\n    for definition in state.records {\n      if definition.name == value.identity &&\n        moduleIdentityAt(state, definition.moduleIndex) == value.origin {\n        return Some(definition)\n      }\n    }\n    return None\n  }\n  let mut preferred = recordDefinitionIndex(state, moduleIndex, value.identity)\n  if preferred >= 0 {\n    return state.records.get(preferred)\n  }\n  preferred = 0\n  for definition in state.records {\n    if definition.name == value.identity {\n      return Some(definition)\n    }\n    preferred += 1\n  }\n  None\n}\n\nexport function enumDefinitionForType(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n) -> Option<EnumDefinition> {\n  if value.kind != \"enum\" {\n    return None\n  }\n  if value.origin != \"\" {\n    for definition in state.enums {\n      if definition.name == value.identity &&\n        moduleIdentityAt(state, definition.moduleIndex) == value.origin {\n        return Some(definition)\n      }\n    }\n    return None\n  }\n  let index = enumDefinitionIndex(state, moduleIndex, value.identity)\n  if index >= 0 {\n    return state.enums.get(index)\n  }\n  for definition in state.enums {\n    if definition.name == value.identity {\n      return Some(definition)\n    }\n  }\n  None\n}\n\nexport function newtypeDefinitionForType(\n  state: CheckerState,\n  moduleIndex: int,\n  value: TypeValue,\n) -> Option<NewtypeDefinition> {\n  if value.kind != \"newtype\" {\n    return None\n  }\n  if value.origin != \"\" {\n    for definition in state.newtypes {\n      if definition.name == value.identity &&\n        moduleIdentityAt(state, definition.moduleIndex) == value.origin {\n        return Some(definition)\n      }\n    }\n    return None\n  }\n  let index = newtypeDefinitionIndex(state, moduleIndex, value.identity)\n  if index >= 0 {\n    return state.newtypes.get(index)\n  }\n  for definition in state.newtypes {\n    if definition.name == value.identity {\n      return Some(definition)\n    }\n  }\n  None\n}\n",
      "sourceSha256": "7786cf11b77feea419d3b324080efce5887a385d44f903d119731f5e6d95f4d1"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/statements.tpz",
      "language": "topaz",
      "bytes": 65183,
      "sha256": "3c64e9de6bebec0b5259a0212fa754b0db92f4464cfe1a908c405d003ae2ceb3",
      "content": "import literal { signedIntegerInput, decodeIntegerLiteral, decodeDecimalFloatLiteral }\n// Statement checking for bindings, assignment, effects, and control transfer.\n// Block sequencing is owned here; expression inference returns through the\n// checker service so imports remain one-way.\n\nimport length { decodeLength, signedLengthInput, roundFraction, lengthFloatMultiply, lengthRatio, lengthResolve, fromMilliPoints, toMilliPoints }\nimport types {\n  KnownLiteralRender,\n  KnownLiteralRenderField,\n  renderKnownLiteral,\n  PreviewAstAttribute,\n  SyntaxNode,\n}\nimport checker_types { TypeValue }\nimport checker.model {\n  FoldedConstant,\n  constantRenderEpoch,\n  advanceConstantRenderEpoch,\n  restoreConstantRenderEpoch,\n  CheckerService,\n  CheckerRequest,\n  CheckerState,\n  LoopFrame,\n  MAX_CONSTANT_EXPONENT,\n  MINIMUM_INT_DECIMAL,\n  ModuleSyntax,\n  constructor,\n  emptyType,\n  functionType,\n  primitive,\n  lengthUnit,\n  rigid,\n}\nimport checker.type_algebra {\n  assignable,\n  hasHole,\n  hasPartialHole,\n  typeText,\n  widen,\n}\nimport checker.syntax_index {\n  addDiagnostic,\n  moduleAt,\n  addNode,\n  attribute,\n  bindSymbol,\n  boolAttribute,\n  child,\n  children,\n  functionIndexForReference,\n  declarationOriginForReference,\n  declarationFor,\n  resolvedTypeOfReference,\n  declarationConstantForReference,\n  setDeclarationConstant,\n  referenceFor,\n  replaceNodeType,\n  spanKey,\n  text,\n  unwrapExport,\n}\nimport checker.nominals {\n  formType,\n  substitute,\n  targetType,\n}\nimport checker.patterns {\n  bindNamedPatternType,\n  patternBindingType,\n  patternIsIrrefutable,\n}\nimport checker.protocols_methods { predeclareBlockFunctions }\nimport checker.call_facts {\n  calleeReference,\n  recordBoundBuiltin,\n  argumentValue,\n  checkExpressionExpected,\n  checkExpressionExpectedResult,\n  checkReturn,\n  currentExpressionChecksResult,\n  inferExpressionContext,\n  inferExpressionWithExpected,\n  refineExpressionToExpected,\n  reportExpectedType,\n}\nimport checker.expression_core {\n  hasBranchJoinContext,\n  checkAssignmentRootMutable,\n  expressionTerminates,\n  hasLiteralJoinContext,\n  inferLambda,\n  optionalReceiver,\n}\nimport checker.expression_control {\n  checkLoopExitStatement,\n  inferBinaryExpression,\n  inferExpression,\n}\n\nfunction bindingAnnotationType(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n) -> Option<TypeValue> {\n  match child(item, \"type\") {\n    case Some(found) => return Some(formType(\n      service,\n      state,\n      moduleIndex,\n      source,\n      found,\n      [],\n      \"binding\",\n    ))\n    case None => ()\n  }\n  match child(item, \"pattern\") {\n    case Some(pattern) => if pattern.kind == \"pattern/typed\" {\n      match child(pattern, \"type\") {\n        case Some(found) => return Some(formType(\n          service,\n          state,\n          moduleIndex,\n          source,\n          found,\n          [],\n          \"binding\",\n        ))\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  None\n}\n\nfunction inferBindingValue(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n  annotation: Option<TypeValue>,\n) -> TypeValue {\n  match child(item, \"value\") {\n    case Some(value) => match annotation {\n      case Some(expected) => if value.kind == \"expression/lambda\" &&\n        expected.kind == \"function\" {\n        let inferred = inferLambda(\n          service,\n          state,\n          moduleIndex,\n          source,\n          value,\n          Some(expected),\n        )\n        addNode(state, moduleIndex, \"expression\", value, inferred)\n        inferred\n      } else {\n        inferExpressionWithExpected(\n          service,\n          state,\n          moduleIndex,\n          source,\n          value,\n          expected,\n          true,\n        )\n      }\n      case None => {\n        // Like Stage 0's at_bare_binding, the reporting site is the\n        // initializer itself. Parentheses and block tails preserve it;\n        // receivers, arguments, elements and loop iterables do not.\n        let mut contexts = state.bareBindingExpressions\n        contexts.push(bareBindingExpression(value))\n        let diagnosticStart = state.diagnostics.length\n        let inferred = inferExpression(service, state, moduleIndex, source, value)\n        contexts.pop()\n        // Callable aliases retain their declaration scheme until a value-use\n        // context instantiates it (including generated standard wrappers).\n        if inferred.kind != \"function\" && hasPartialHole(inferred) &&\n          state.diagnostics.length == diagnosticStart {\n          addDiagnostic(state, moduleIndex, \"TPZ5020\",\n            \"this expression needs a contextual type (§22.1): annotate the binding or surrounding expectation\",\n            \"\", bareBindingExpression(value))\n        }\n        inferred\n      }\n    }\n    case None => emptyType(\"unknown\")\n  }\n}\n\nfunction bareBindingExpression(value: SyntaxNode) -> SyntaxNode {\n  if value.kind == \"expression/parenthesized\" {\n    match child(value, \"operand\") {\n      case Some(inner) => return bareBindingExpression(inner)\n      case None => ()\n    }\n  }\n  if value.kind == \"expression/block\" {\n    match child(value, \"block\") {\n      case Some(block) => match child(block, \"tail\") {\n        case Some(tail) => return bareBindingExpression(tail)\n        case None => ()\n      }\n      case None => ()\n    }\n  }\n  value\n}\n\nfunction bindCheckedDeclaration(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n  expected: TypeValue,\n) -> () {\n  if item.kind == \"statement/let\" {\n    match child(item, \"pattern\") {\n      case Some(pattern) => {\n        if pattern.kind == \"pattern/typed\" {\n          bindNamedPatternType(\n            state,\n            moduleIndex,\n            source,\n            pattern,\n            expected,\n            expected,\n            boolAttribute(item, \"mutable\"),\n          )\n        } else {\n          let coverage = patternBindingType(\n            service,\n            state,\n            moduleIndex,\n            source,\n            pattern,\n            expected,\n            boolAttribute(item, \"mutable\"),\n          )\n          if pattern.kind != \"pattern/binding\" &&\n            !patternIsIrrefutable(state, moduleIndex, expected, coverage) {\n            addDiagnostic(\n              state,\n              moduleIndex,\n              \"TPZ5026\",\n              \"refutable pattern in `let`: it does not match every value of the type — use `if let` to handle the non-matching case\",\n              \"\",\n              pattern,\n            )\n          }\n        }\n      }\n      case None => ()\n    }\n    return ()\n  }\n  let nameNode = match child(item, \"name\") {\n    case Some(found) => found\n    case None => item\n  }\n  match declarationFor(state, moduleIndex, nameNode.lo, nameNode.hi) {\n    case Some(declaration) => {\n      let key = \"lexical:{moduleIndex}:{declaration.scopeOrdinal}:{declaration.namespace}:{declaration.name}\"\n      match state.declarationIndexes.get(key) {\n        case Some(index) => match state.resolved.declarations.get(index) {\n          case Some(first) => if first.lo < declaration.lo {\n            addDiagnostic(state, moduleIndex, \"TPZ5008\", \"`{declaration.name}` is already declared in this scope\", \"\", nameNode)\n          }\n          case None => ()\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  bindSymbol(\n    state,\n    moduleIndex,\n    nameNode.lo,\n    nameNode.hi,\n    text(source, nameNode),\n    expected,\n    false,\n  )\n  addNode(state, moduleIndex, \"binding\", nameNode, expected)\n}\n\nfunction aliasReferenceNode(node: SyntaxNode) -> Option<SyntaxNode> {\n  if node.kind == \"expression/identifier\" {\n    return Some(node)\n  }\n  if node.kind == \"expression/parenthesized\" {\n    return match child(node, \"operand\") {\n      case Some(found) => aliasReferenceNode(found)\n      case None => None\n    }\n  }\n  if node.kind == \"expression/block\" {\n    return match child(node, \"block\") {\n      case Some(block) => if children(block, \"statements\").length == 0 {\n        match child(block, \"tail\") {\n          case Some(found) => aliasReferenceNode(found)\n          case None => None\n        }\n      } else {\n        None\n      }\n      case None => None\n    }\n  }\n  None\n}\n\nfunction bindingDeclarationNode(item: SyntaxNode) -> Option<SyntaxNode> {\n  if item.kind == \"statement/const\" {\n    return child(item, \"name\")\n  }\n  match child(item, \"pattern\") {\n    case Some(pattern) => if pattern.kind == \"pattern/binding\" ||\n      pattern.kind == \"pattern/typed\" {\n      child(pattern, \"name\")\n    } else {\n      None\n    }\n    case None => None\n  }\n}\n\nfunction recordFunctionAlias(\n  state: CheckerState,\n  moduleIndex: int,\n  item: SyntaxNode,\n) -> () {\n  let declaration = match bindingDeclarationNode(item) {\n    case Some(found) => found\n    case None => return ()\n  }\n  let value = match child(item, \"value\") {\n    case Some(found) => found\n    case None => return ()\n  }\n  let referenceNode = match aliasReferenceNode(value) {\n    case Some(found) => found\n    case None => return ()\n  }\n  match referenceFor(\n    state,\n    moduleIndex,\n    referenceNode.lo,\n    referenceNode.hi,\n  ) {\n    case Some(reference) => {\n      let functionIndex = functionIndexForReference(state, reference)\n      if functionIndex >= 0 {\n        let mut aliases = state.functionAliases\n        aliases.insert(\n          spanKey(\n            moduleIndex,\n            declaration.lo,\n            declaration.hi,\n          ),\n          functionIndex,\n        )\n      }\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction functionAliasSemanticType(\n  state: CheckerState,\n  moduleIndex: int,\n  item: SyntaxNode,\n) -> Option<TypeValue> {\n  let declaration = match bindingDeclarationNode(item) {\n    case Some(found) => found\n    case None => return None\n  }\n  let functionIndex = match state.functionAliases.get(spanKey(\n    moduleIndex,\n    declaration.lo,\n    declaration.hi,\n  )) {\n    case Some(found) => found\n    case None => return None\n  }\n  let definition = match state.functions.get(functionIndex) {\n    case Some(found) => found\n    case None => return None\n  }\n  if definition.typeParameters.length == 0 {\n    return None\n  }\n  let mut arguments: Array<TypeValue> = []\n  let mut index = 0\n  for parameter in definition.typeParameters {\n    let origin = match definition.typeParameterOrigins.get(index) {\n      case Some(found) => found\n      case None => return None\n    }\n    arguments.push(rigid(parameter, origin))\n    index += 1\n  }\n  Some(substitute(\n    functionType(\n      definition.parameterTypes,\n      definition.variadic,\n      definition.result,\n    ),\n    definition.typeParameters,\n    arguments,\n  ))\n}\n\nfunction checkBindingStatement(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n) -> () {\n  let renderEpoch = constantRenderEpoch(state)\n  let annotation = bindingAnnotationType(service, state, moduleIndex, source, item)\n  let mut value = inferBindingValue(\n    service,\n    state,\n    moduleIndex,\n    source,\n    item,\n    annotation,\n  )\n  let expected = match annotation {\n    case Some(found) => found\n    case None => if item.kind == \"statement/const\" { value } else { widen(value) }\n  }\n  match annotation {\n    case Some(_) => ()\n    case None => match child(item, \"value\") {\n      case Some(found) => if found.kind == \"expression/comprehension\" &&\n        hasHole(value) {\n        addDiagnostic(\n          state,\n          moduleIndex,\n          \"TPZ5612\",\n          \"this comprehension's element type cannot be inferred (§6.4): annotate the binding with its collection type\",\n          \"\",\n          found,\n        )\n      }\n      case None => ()\n    }\n  }\n  match child(item, \"value\") {\n    case Some(found) => {\n      value = refineExpressionToExpected(\n        state,\n        moduleIndex,\n        found,\n        value,\n        expected,\n      )\n    }\n    case None => ()\n  }\n  match child(item, \"value\") {\n    case Some(found) => reportExpectedType(state, moduleIndex, found, expected, value)\n    case None => ()\n  }\n  if item.kind == \"statement/const\" { restoreConstantRenderEpoch(state, renderEpoch) }\n  let mut constant: Option<FoldedConstant> = None\n  if item.kind == \"statement/const\" {\n    match child(item, \"value\") {\n      case Some(found) => match constantExpressionInvalid(state, moduleIndex, found, false) {\n        case Some(invalid) => {\n          let unavailable = match referenceFor(state, moduleIndex, invalid.lo, invalid.hi) {\n            case Some(reference) => match declarationOriginForReference(state, reference) {\n              case Some(declaration) => declaration.declarationKind == \"const\" &&\n                reference.scopeOrdinal == 0 && declaration.moduleIndex == moduleIndex &&\n                declaration.lo > invalid.lo\n              case None => false\n            }\n            case None => false\n          }\n          if unavailable {\n            addDiagnostic(state, moduleIndex, \"TPZ5002\", \"`{text(source, invalid)}` is not bound\", \"\", invalid)\n          } else {\n            addDiagnostic(state, moduleIndex, \"TPZ5001\", \"`const` initializers must be constant expressions (§4)\", \"\", invalid)\n          }\n        }\n        case None => match foldConstantScalar(state, moduleIndex, found) {\n          case Ok(value) => { constant = Some(value) }\n          case Err(_) => ()\n        }\n      }\n      case None => ()\n    }\n  }\n  bindCheckedDeclaration(service, state, moduleIndex, source, item, expected)\n  match constant {\n    case Some(value) => match child(item, \"name\") {\n      case Some(name) => setDeclarationConstant(state, moduleIndex, name.lo, name.hi, value)\n      case None => ()\n    }\n    case None => ()\n  }\n  match [bindingDeclarationNode(item), child(item, \"value\")] {\n    case [Some(declaration), Some(initializer)] => recordBoundBuiltin(service, state, moduleIndex, source, declaration, initializer, value)\n    case _ => ()\n  }\n  recordFunctionAlias(state, moduleIndex, item)\n  match annotation {\n    case None => match functionAliasSemanticType(state, moduleIndex, item) {\n      case Some(projected) => match bindingDeclarationNode(item) {\n        case Some(declaration) => replaceNodeType(\n          state,\n          moduleIndex,\n          \"binding\",\n          declaration,\n          projected,\n        )\n        case None => ()\n      }\n      case None => ()\n    }\n    case Some(_) => ()\n  }\n  ()\n}\n\nfunction checkUsingStatement(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n) -> () {\n  match child(item, \"value\") {\n    case Some(found) => {\n      let _ = checkExpressionExpected(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        emptyType(\"file\"),\n      )\n    }\n    case None => ()\n  }\n  match child(item, \"name\") {\n    case Some(name) => {\n      bindSymbol(\n        state,\n        moduleIndex,\n        name.lo,\n        name.hi,\n        text(source, name),\n        emptyType(\"file\"),\n        false,\n      )\n      addNode(state, moduleIndex, \"binding\", name, emptyType(\"file\"))\n    }\n    case None => ()\n  }\n  match child(item, \"body\") {\n    case Some(body) => {\n      let _ = checkBlock(service, state, moduleIndex, source, body)\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction checkEffectStatement(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n) -> () {\n  let expression = if item.kind == \"statement/defer\" {\n    child(item, \"value\")\n  } else {\n    item.children.get(0)\n  }\n  match expression {\n    case Some(found) => if found.kind == \"expression/for\" {\n      let mut contexts = state.statementExpressionContexts\n      contexts.push(found.lo)\n      let _ = inferExpression(service, state, moduleIndex, source, found)\n      contexts.pop()\n    } else {\n      let _ = inferExpression(service, state, moduleIndex, source, found)\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction assignmentTargetHasOptional(node: SyntaxNode) -> bool {\n  if node.kind == \"expression/optional-access\" {\n    return true\n  }\n  match child(node, \"object\") {\n    case Some(object) => assignmentTargetHasOptional(object)\n    case None => false\n  }\n}\n\nfunction lastAssignmentIndex(node: SyntaxNode) -> Option<SyntaxNode> {\n  if node.kind == \"expression/member\" {\n    return match child(node, \"object\") {\n      case Some(object) => lastAssignmentIndex(object)\n      case None => None\n    }\n  }\n  if node.kind == \"expression/index\" {\n    return Some(node)\n  }\n  None\n}\n\nfunction reportMapAssignmentTarget(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  target: SyntaxNode,\n) -> () {\n  match lastAssignmentIndex(target) {\n    case Some(index) => match child(index, \"object\") {\n      case Some(object) => {\n        let objectType = inferExpression(service, state, moduleIndex, source, object)\n        if objectType.kind == \"constructor\" && objectType.name == \"Map\" {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"a Map is not index-assignable; use `m.insert` (§22)\",\n            \"\",\n            target,\n          )\n        }\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction assignmentBinaryNode(\n  item: SyntaxNode,\n  target: SyntaxNode,\n  value: SyntaxNode,\n) -> SyntaxNode {\n  SyntaxNode {\n    kind: \"expression/binary\",\n    lo: item.lo,\n    hi: item.hi,\n    field: \"\",\n    index: 0,\n    attributes: [PreviewAstAttribute {\n      name: \"operator\",\n      kind: \"string\",\n      value: attribute(item, \"operator\"),\n    }],\n    children: [\n      SyntaxNode { ...target, field: \"left\", index: 0 },\n      SyntaxNode { ...value, field: \"right\", index: 1 },\n    ],\n  }\n}\n\nfunction checkAssignmentStatement(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n) -> () {\n  let target = match child(item, \"target\") {\n    case Some(found) => found\n    case None => return ()\n  }\n  let value = match child(item, \"value\") {\n    case Some(found) => found\n    case None => return ()\n  }\n  checkAssignmentRootMutable(state, moduleIndex, source, target, false)\n  if assignmentTargetHasOptional(target) {\n    addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5001\",\n      \"cannot assign through optional access `?.` (§4)\",\n      \"\",\n      target,\n    )\n  }\n  reportMapAssignmentTarget(service, state, moduleIndex, source, target)\n  let operator = attribute(item, \"operator\")\n  if operator == \"assign\" {\n    let targetType = inferExpression(service, state, moduleIndex, source, target)\n    let _ = checkExpressionExpected(\n      service,\n      state,\n      moduleIndex,\n      source,\n      value,\n      targetType,\n    )\n    return ()\n  }\n  if operator == \"coalesce\" {\n    let targetType = inferExpression(service, state, moduleIndex, source, target)\n    match optionalReceiver(targetType) {\n      case Some(_) => {\n        let _ = checkExpressionExpected(\n          service,\n          state,\n          moduleIndex,\n          source,\n          value,\n          targetType,\n        )\n      }\n      case None => {\n        if !hasHole(targetType) {\n          addDiagnostic(\n            state,\n            moduleIndex,\n            \"TPZ5001\",\n            \"`??=` needs an Option or nullable target, found `{typeText(targetType)}`\",\n            \"\",\n            target,\n          )\n        }\n        let _ = inferExpression(service, state, moduleIndex, source, value)\n      }\n    }\n    return ()\n  }\n  let targetType = inferExpression(service, state, moduleIndex, source, target)\n  let result = inferBinaryExpression(\n    service,\n    state,\n    moduleIndex,\n    source,\n    assignmentBinaryNode(item, target, value),\n  )\n  reportExpectedType(\n    state,\n    moduleIndex,\n    item,\n    widen(targetType),\n    result,\n  )\n  ()\n}\n\nfunction checkWhileStatement(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  item: SyntaxNode,\n) -> () {\n  match child(item, \"condition\") {\n    case Some(found) => {\n      let _ = checkExpressionExpected(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        primitive(\"bool\"),\n      )\n    }\n    case None => ()\n  }\n  let mut frames = state.loopFrames\n  frames.push(LoopFrame {\n    label: \"\",\n    valueLoop: false,\n    bareTarget: true,\n    bareError: \"\",\n    expected: None,\n    breaks: [],\n  })\n  match child(item, \"body\") {\n    case Some(found) => {\n      let _ = checkBlock(service, state, moduleIndex, source, found)\n    }\n    case None => ()\n  }\n  frames.pop()\n  ()\n}\n\nfunction checkModuleOnlyDeclaration(\n  state: CheckerState,\n  moduleIndex: int,\n  statement: SyntaxNode,\n  kind: string,\n) -> () {\n  match child(statement, \"name\") {\n    case Some(name) => addDiagnostic(\n      state,\n      moduleIndex,\n      \"TPZ5022\",\n      \"{kind} declarations are module-top-level only\",\n      \"\",\n      name,\n    )\n    case None => ()\n  }\n  ()\n}\n\nexport function checkStatement(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  statement: SyntaxNode,\n) -> () {\n  let item = unwrapExport(statement)\n  match item.kind {\n    case \"statement/function\" => match child(item, \"declaration\") {\n      case Some(declaration) => {\n        let _ = service(state, CheckerRequest {\n          kind: \"check-function\",\n          moduleIndex: moduleIndex,\n          source: source,\n          node: declaration,\n          typeValue: emptyType(\"unknown\"),\n        })\n      }\n      case None => ()\n    }\n    case \"statement/let\" | \"statement/const\" =>\n      checkBindingStatement(service, state, moduleIndex, source, item)\n    case \"statement/using\" => checkUsingStatement(\n      service,\n      state,\n      moduleIndex,\n      source,\n      item,\n    )\n    case \"statement/return\" =>\n      checkReturn(service, state, moduleIndex, source, item)\n    case \"statement/break\" | \"statement/continue\" =>\n      checkLoopExitStatement(service, state, moduleIndex, source, item)\n    case \"statement/expression\" | \"statement/defer\" =>\n      checkEffectStatement(service, state, moduleIndex, source, item)\n    case \"statement/assign\" => {\n      advanceConstantRenderEpoch(state)\n      checkAssignmentStatement(service, state, moduleIndex, source, item)\n    }\n    case \"statement/while\" => checkWhileStatement(\n      service,\n      state,\n      moduleIndex,\n      source,\n      item,\n    )\n    case \"statement/protocol\" => checkModuleOnlyDeclaration(state, moduleIndex, item, \"protocol\")\n    case \"statement/impl\" => checkModuleOnlyDeclaration(state, moduleIndex, item, \"impl\")\n    case \"statement/record\" => checkModuleOnlyDeclaration(state, moduleIndex, item, \"record\")\n    case \"statement/enum\" => checkModuleOnlyDeclaration(state, moduleIndex, item, \"enum\")\n    case \"statement/newtype\" => checkModuleOnlyDeclaration(state, moduleIndex, item, \"newtype\")\n    case _ => ()\n  }\n}\n\nexport function checkBlock(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  block: SyntaxNode,\n) -> TypeValue {\n  let inheritedContext = hasLiteralJoinContext(state, block)\n  let inheritedJoin = hasBranchJoinContext(state, block)\n  if inheritedContext {\n    let mut contexts = state.literalJoinContexts\n    contexts.pop()\n  }\n  predeclareBlockFunctions(service, state, moduleIndex, block)\n  for statement in children(block, \"statements\") {\n    checkStatement(service, state, moduleIndex, source, statement)\n  }\n  let result = match child(block, \"tail\") {\n    case Some(found) => {\n      let mut joins = state.branchJoinContexts\n      if inheritedJoin { joins.push(found.lo) }\n      let inferred = if inheritedContext {\n        inferExpressionContext(service, state, moduleIndex, source, found)\n      } else {\n        inferExpression(service, state, moduleIndex, source, found)\n      }\n      if inheritedJoin { joins.pop() }\n      inferred\n    }\n    case None => primitive(\"unit\")\n  }\n  if inheritedContext {\n    let mut contexts = state.literalJoinContexts\n    contexts.push(block.lo)\n  }\n  result\n}\n\nexport function checkBlockExpected(\n  service: CheckerService,\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  block: SyntaxNode,\n  expectedReturn: TypeValue,\n) -> TypeValue {\n  let checkResult = currentExpressionChecksResult(state, block)\n  predeclareBlockFunctions(service, state, moduleIndex, block)\n  for statement in children(block, \"statements\") {\n    checkStatement(service, state, moduleIndex, source, statement)\n  }\n  match child(block, \"tail\") {\n    case Some(found) => {\n      checkExpressionExpectedResult(\n        service,\n        state,\n        moduleIndex,\n        source,\n        found,\n        expectedReturn,\n        true,\n        checkResult && !expressionTerminates(found),\n      )\n    }\n    case None => primitive(\"unit\")\n  }\n}\n\nexport function precheckTopLevelBindings(\n  service: CheckerService,\n  state: CheckerState,\n  module: ModuleSyntax,\n) -> () {\n  for statement in module.root.children {\n    let item = unwrapExport(statement)\n    if item.kind == \"statement/const\" {\n      checkStatement(\n        service,\n        state,\n        module.moduleIndex,\n        module.source,\n        statement,\n      )\n    } else if item.kind == \"statement/let\" {\n      let mut suppressions = state.typeCapabilitySuppressions\n      suppressions.push(true)\n      match child(item, \"pattern\") {\n        case Some(pattern) => {\n          let mut expectedValues: Array<TypeValue> = []\n          match child(item, \"type\") {\n            case Some(typeNode) => expectedValues.push(formType(\n              service,\n              state,\n              module.moduleIndex,\n              module.source,\n              typeNode,\n              [],\n              \"binding\",\n            ))\n            case None => if pattern.kind == \"pattern/typed\" {\n              match child(pattern, \"type\") {\n                case Some(typeNode) => expectedValues.push(formType(\n                  service,\n                  state,\n                  module.moduleIndex,\n                  module.source,\n                  typeNode,\n                  [],\n                  \"binding\",\n                ))\n                case None => ()\n              }\n            } else {\n              ()\n            }\n          }\n          match expectedValues.get(0) {\n            case Some(expected) => patternBindingType(\n              service,\n              state,\n              module.moduleIndex,\n              module.source,\n              pattern,\n              expected,\n              boolAttribute(item, \"mutable\"),\n            )\n            case None => ()\n          }\n        }\n        case None => ()\n      }\n      suppressions.pop()\n    }\n  }\n  ()\n}\n\nexport function constantExpressionShape(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  defaultValue: bool,\n) -> bool {\n  match constantExpressionInvalid(state, moduleIndex, node, defaultValue) {\n    case Some(_) => false\n    case None => true\n  }\n}\n\nfunction constantFloatShape(state: CheckerState, moduleIndex: int, node: SyntaxNode) -> bool {\n  if node.kind == \"expression/float\" { return true }\n  if node.kind == \"expression/identifier\" {\n    return match resolvedTypeOfReference(state, moduleIndex, node) { case Some(value) => value.name == \"float\"; case None => false }\n  }\n  if node.kind == \"expression/parenthesized\" || node.kind == \"expression/unary\" {\n    return match child(node, \"operand\") { case Some(value) => constantFloatShape(state, moduleIndex, value); case None => false }\n  }\n  if node.kind == \"expression/binary\" {\n    let operator = attribute(node, \"operator\")\n    if operator != \"add\" && operator != \"subtract\" && operator != \"multiply\" && operator != \"divide\" && operator != \"remainder\" && operator != \"power\" { return false }\n    let left = match child(node, \"left\") { case Some(value) => value; case None => return false }\n    let right = match child(node, \"right\") { case Some(value) => value; case None => return false }\n    return constantFloatShape(state, moduleIndex, left) && constantFloatShape(state, moduleIndex, right)\n  }\n  false\n}\n\nfunction constantIntegerBitShape(state: CheckerState, moduleIndex: int, node: SyntaxNode) -> bool {\n  if node.kind == \"expression/integer\" { return true }\n  if node.kind == \"expression/identifier\" {\n    return match resolvedTypeOfReference(state, moduleIndex, node) { case Some(value) => value.name == \"int\"; case None => false }\n  }\n  if node.kind == \"expression/parenthesized\" || node.kind == \"expression/unary\" {\n    return match child(node, \"operand\") { case Some(value) => constantIntegerBitShape(state, moduleIndex, value); case None => false }\n  }\n  if node.kind == \"expression/binary\" {\n    let operator = attribute(node, \"operator\")\n    if operator != \"add\" && operator != \"subtract\" && operator != \"multiply\" && operator != \"divide\" && operator != \"remainder\" && operator != \"power\" { return false }\n    let left = match child(node, \"left\") { case Some(value) => value; case None => return false }\n    let right = match child(node, \"right\") { case Some(value) => value; case None => return false }\n    return constantIntegerBitShape(state, moduleIndex, left) && constantIntegerBitShape(state, moduleIndex, right)\n  }\n  match integerBitConstant(state, moduleIndex, node) { case Some(_) => true; case None => false }\n}\n\nfunction integerBitConstant(state: CheckerState, moduleIndex: int, node: SyntaxNode) -> Option<SyntaxNode> {\n  if state.languageMode != \"topaz-5.21\" || node.kind != \"expression/call\" || children(node, \"arguments\").length != 1 || children(node, \"typeArguments\").length != 0 { return None }\n  let callee = match child(node, \"callee\") { case Some(value) => value; case None => return None }\n  if callee.kind != \"expression/member\" { return None }\n  let object = match child(callee, \"object\") { case Some(value) => value; case None => return None }\n  let field = match child(callee, \"field\") { case Some(value) => value; case None => return None }\n  let source = match moduleAt(state, moduleIndex) { case Some(module) => module.source; case None => return None }\n  let name = text(source, field)\n  if name != \"and\" && name != \"or\" && name != \"xor\" && name != \"shift\" { return None }\n  let argument = children(node, \"arguments\")[0]\n  if argument.kind == \"call-argument/spread\" { return None }\n  if argument.kind == \"call-argument/named\" {\n    let parameter = match child(argument, \"name\") { case Some(value) => text(source, value); case None => return None }\n    if parameter != (if name == \"shift\" { \"count\" } else { \"other\" }) { return None }\n  }\n  if constantIntegerBitShape(state, moduleIndex, object) && constantIntegerBitShape(state, moduleIndex, argumentValue(argument)) { Some(object) } else { None }\n}\n\nfunction floatIntegerConstant(state: CheckerState, moduleIndex: int, node: SyntaxNode) -> Option<SyntaxNode> {\n  if state.languageMode != \"topaz-5.21\" || node.kind != \"expression/call\" || children(node, \"arguments\").length != 0 || children(node, \"typeArguments\").length != 0 { return None }\n  let callee = match child(node, \"callee\") { case Some(value) => value; case None => return None }\n  if callee.kind != \"expression/member\" { return None }\n  let object = match child(callee, \"object\") { case Some(value) => value; case None => return None }\n  let field = match child(callee, \"field\") { case Some(value) => value; case None => return None }\n  let source = match moduleAt(state, moduleIndex) { case Some(module) => module.source; case None => return None }\n  let name = text(source, field)\n  if (name == \"trunc\" || name == \"floor\" || name == \"ceil\" || name == \"round\") && constantFloatShape(state, moduleIndex, object) { Some(object) } else { None }\n}\n\n\nfunction lengthConstructorName(state:CheckerState,moduleIndex:int,node:SyntaxNode)->string {\n  if state.languageMode != \"topaz-5.21\" || node.kind != \"expression/call\" {return \"\"}\n  let mut generated=false\n  for module in state.modules {if module.identity == \"std.typeset\" && module.generatedStd {generated=true}}\n  if !generated {return \"\"}\n  let callee = match child(node,\"callee\") {case Some(v)=>v;case None=>return \"\"}\n  let reference = match calleeReference(state,moduleIndex,callee) {case Some(v)=>v;case None=>return \"\"}\n  if reference.targetModule == \"std.typeset\" && (reference.targetName == \"fromScaledPoints\" || reference.targetName == \"fromMilliPoints\") {return reference.targetName}\n  \"\"\n}\nfunction constantLengthUnit(state:CheckerState,moduleIndex:int,node:SyntaxNode)->string {\n  let source = match moduleAt(state,moduleIndex) {case Some(v)=>v.source;case None=>return \"\"}\n  match signedLengthInput(node,source) {case Some(input)=>return match decodeLength(input.spelling,input.negative) {case Ok(v)=>v.unit;case Err(_)=>\"\"};case None=>()}\n  if node.kind == \"expression/identifier\" {return match resolvedTypeOfReference(state,moduleIndex,node) {case Some(v)=>lengthUnit(v);case None=>\"\"}}\n  if node.kind == \"expression/parenthesized\" || node.kind == \"expression/unary\" {return match child(node,\"operand\") {case Some(v)=>constantLengthUnit(state,moduleIndex,v);case None=>\"\"}}\n  if node.kind == \"expression/binary\" {\n    let left=match child(node,\"left\") {case Some(v)=>constantLengthUnit(state,moduleIndex,v);case None=>\"\"}\n    let right=match child(node,\"right\") {case Some(v)=>constantLengthUnit(state,moduleIndex,v);case None=>\"\"}\n    let op=attribute(node,\"operator\")\n    if (op == \"add\" || op == \"subtract\") && left == right {return left}\n    if op == \"multiply\" && (left == \"\" || right == \"\") {return if left == \"\" {right} else {left}}\n    if op == \"divide\" && right == \"\" {return left}\n  }\n  if node.kind == \"expression/call\" {\n    if lengthConstructorName(state,moduleIndex,node) != \"\" {return \"Pt\"}\n    let callee=match child(node,\"callee\") {case Some(v)=>v;case None=>return \"\"}\n    let field=match child(callee,\"field\") {case Some(v)=>text(source,v);case None=>return \"\"}\n    let object=match child(callee,\"object\") {case Some(v)=>v;case None=>return \"\"}\n    let unit=constantLengthUnit(state,moduleIndex,object)\n    if unit == \"Em\" {return if field == \"resolve\" {\"Pt\"} else {\"\"}}\n    if unit != \"\" {return match field {case \"toPt\"=>\"Pt\";case \"toMm\"=>\"Mm\";case \"toCm\"=>\"Cm\";case \"toIn\"=>\"In\";case _=>\"\"}}\n  }\n  \"\"\n}\nfunction lengthConstantReceiver(state:CheckerState,moduleIndex:int,node:SyntaxNode)->Option<SyntaxNode> {\n  if state.languageMode != \"topaz-5.21\" || node.kind != \"expression/call\" {return None}\n  let source=match moduleAt(state,moduleIndex) {case Some(v)=>v.source;case None=>return None}\n  let callee=match child(node,\"callee\") {case Some(v)=>v;case None=>return None}\n  let object=match child(callee,\"object\") {case Some(v)=>v;case None=>return None}\n  let field=match child(callee,\"field\") {case Some(v)=>text(source,v);case None=>return None}\n  let unit=constantLengthUnit(state,moduleIndex,object)\n  if unit == \"Em\" {return if field == \"resolve\" {Some(object)} else {None}}\n  if unit != \"\" && (field == \"toPt\" || field == \"toMm\" || field == \"toCm\" || field == \"toIn\" || field == \"scaledPoints\" || (unit == \"Pt\" && field == \"toMilliPoints\")) {return Some(object)}\n  None\n}\nfunction constantExpressionInvalid(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  defaultValue: bool,\n) -> Option<SyntaxNode> {\n  let constructor=lengthConstructorName(state,moduleIndex,node)\n  let lengthReceiver=lengthConstantReceiver(state,moduleIndex,node)\n  if constructor != \"\" || lengthReceiver != None {\n    match lengthReceiver {case Some(object)=>match constantExpressionInvalid(state,moduleIndex,object,defaultValue) {case Some(invalid)=>return Some(invalid);case None=>()};case None=>()}\n    for arg in children(node,\"arguments\") {\n      let value=argumentValue(arg)\n      match constantExpressionInvalid(state,moduleIndex,value,defaultValue) {case Some(invalid)=>return Some(invalid);case None=>()}\n    }\n    return None\n  }\n  match integerBitConstant(state, moduleIndex, node) {\n    case Some(object) => {\n      match constantExpressionInvalid(state, moduleIndex, object, defaultValue) { case Some(invalid) => return Some(invalid); case None => () }\n      return constantExpressionInvalid(state, moduleIndex, argumentValue(children(node, \"arguments\")[0]), defaultValue)\n    }\n    case None => ()\n  }\n  match floatIntegerConstant(state, moduleIndex, node) {\n    case Some(object) => return constantExpressionInvalid(state, moduleIndex, object, defaultValue)\n    case None => ()\n  }\n  if node.kind == \"expression/length\" || node.kind == \"expression/integer\" || node.kind == \"expression/float\" ||\n    node.kind == \"expression/boolean\" || node.kind == \"expression/null\" ||\n    node.kind == \"expression/unit\" {\n    return None\n  }\n  if node.kind == \"expression/identifier\" {\n    if defaultValue { return None }\n    let reference = match referenceFor(state, moduleIndex, node.lo, node.hi) {\n      case Some(found) => found\n      case None => return None\n    }\n    let declaration = match declarationOriginForReference(state, reference) {\n      case Some(found) => found\n      case None => return None\n    }\n    if declaration.declarationKind == \"function\" { return None }\n    if declaration.declarationKind == \"const\" {\n      if reference.scopeOrdinal == 0 && declaration.moduleIndex == moduleIndex &&\n        declaration.lo > node.lo { return Some(node) }\n      return None\n    }\n    return Some(node)\n  }\n  if node.kind == \"expression/parenthesized\" || node.kind == \"expression/unary\" {\n    return match child(node, \"operand\") {\n      case Some(value) => constantExpressionInvalid(state, moduleIndex, value, defaultValue)\n      case None => Some(node)\n    }\n  }\n  if node.kind == \"expression/binary\" {\n    if attribute(node, \"operator\") == \"in\" { return Some(node) }\n    let left = match child(node, \"left\") {\n      case Some(value) => value\n      case None => return Some(node) }\n    match constantExpressionInvalid(state, moduleIndex, left, defaultValue) {\n      case Some(invalid) => return Some(invalid)\n      case None => ()\n    }\n    return match child(node, \"right\") {\n      case Some(value) => constantExpressionInvalid(state, moduleIndex, value, defaultValue)\n      case None => Some(node)\n    }\n  }\n  if node.kind == \"expression/string\" {\n    if attribute(node, \"tag\") != \"\" { return Some(node) }\n    for part in node.children {\n      if part.kind == \"string-part/interpolation\" {\n        let value = match child(part, \"value\") {\n          case Some(value) => value\n          case None => return Some(node) }\n        match constantExpressionInvalid(state, moduleIndex, value, defaultValue) {\n          case Some(invalid) => return Some(invalid)\n          case None => ()\n        }\n      } else if part.kind != \"string-part/text\" { return Some(node) }\n    }\n    return None\n  }\n  if node.kind == \"expression/array\" {\n    for element in node.children {\n      if element.kind == \"array-element/spread\" { return Some(node) }\n      match constantExpressionInvalid(state, moduleIndex, element, defaultValue) {\n        case Some(invalid) => return Some(invalid)\n        case None => ()\n      }\n    }\n    return None\n  }\n  if node.kind == \"expression/record-literal\" {\n    for field in node.children {\n      let value = match child(field, \"value\") {\n        case Some(value) => value\n        case None => return Some(node) }\n      match constantExpressionInvalid(state, moduleIndex, value, defaultValue) {\n        case Some(invalid) => return Some(invalid)\n        case None => ()\n      }\n    }\n    return None\n  }\n  Some(node)\n}\n\n\nfunction minimumInt() -> int {\n  match MINIMUM_INT_DECIMAL.toInt() {\n    case Some(found) => found\n    case None => 0\n  }\n}\n\nfunction constantExpressionFault(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  message: string,\n) -> () {\n  addDiagnostic(\n    state,\n    moduleIndex,\n    \"TPZ5001\",\n    \"constant expression error: {message}\",\n    \"\",\n    node,\n  )\n}\n\nfunction constantIntegerResult(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n  value: BigInt,\n  overflow: string,\n) -> Option<BigInt> {\n  match value.toInt() {\n    case Some(_) => Some(value)\n    case None => {\n      constantExpressionFault(state, moduleIndex, node, overflow)\n      None\n    }\n  }\n}\n\nfunction constantIntegerPower(base: BigInt, exponent: int) -> BigInt {\n  let mut result = (1).toBigInt()\n  let mut factor = base\n  let mut remaining = exponent\n  while remaining > 0 {\n    if remaining % 2 == 1 {\n      result = result * factor\n    }\n    remaining = remaining / 2\n    if remaining > 0 {\n      factor = factor * factor\n    }\n  }\n  result\n}\n\nexport function foldConstantInteger(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> Option<BigInt> {\n  match foldConstantScalar(state, moduleIndex, node) {\n    case Ok(Integer(value)) => Some(value)\n    case _ => None\n  }\n}\n\nfunction foldConstantScalar(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> Result<FoldedConstant, ()> {\n\n  let source=match moduleAt(state,moduleIndex) {case Some(v)=>v.source;case None=>return Ok(FoldedConstant.Unknown)}\n  match signedLengthInput(node,source) {\n    case Some(input)=>return match decodeLength(input.spelling,input.negative) {\n      case Ok(value)=>Ok(FoldedConstant.Length(value.unit,value.ticks))\n      case Err(message)=>{constantExpressionFault(state,moduleIndex,node,message);Err(())}\n    }\n    case None=>()\n  }\n  let constructor=lengthConstructorName(state,moduleIndex,node)\n  let receiverNode=lengthConstantReceiver(state,moduleIndex,node)\n  if constructor != \"\" || receiverNode != None {\n    let receiver=match receiverNode {case Some(v)=>foldConstantScalar(state,moduleIndex,v)?;case None=>FoldedConstant.Unknown}\n    let mut values:Array<FoldedConstant> = []\n    for arg in children(node,\"arguments\") {values.push(foldConstantScalar(state,moduleIndex,argumentValue(arg))?)}\n    let result:Result<FoldedConstant,string> = if constructor != \"\" {\n      match values.get(0) {\n        case Some(Integer(value))=>match value.toInt() {\n          case Some(value)=>if constructor == \"fromScaledPoints\" {Ok(FoldedConstant.Length(\"Pt\",value))} else {match fromMilliPoints(value) {case Ok(v)=>Ok(FoldedConstant.Length(\"Pt\",v));case Err(e)=>Err(e)}}\n          case None=>Ok(FoldedConstant.Unknown)\n        }\n        case _=>Ok(FoldedConstant.Unknown)\n      }\n    } else {\n      let callee=match child(node,\"callee\") {case Some(v)=>v;case None=>return Ok(FoldedConstant.Unknown)}\n      let method=match child(callee,\"field\") {case Some(v)=>text(source,v);case None=>return Ok(FoldedConstant.Unknown)}\n      match receiver {\n        case Length(unit,ticks)=>if method == \"scaledPoints\" {Ok(FoldedConstant.Integer((ticks).toBigInt()))}\n          else if method == \"toMilliPoints\" {match toMilliPoints(ticks) {case Ok(v)=>Ok(FoldedConstant.Integer((v).toBigInt()));case Err(e)=>Err(e)}}\n          else if method == \"resolve\" {match values.get(0) {case Some(Length(\"Pt\",font))=>match lengthResolve(ticks,font) {case Ok(v)=>Ok(FoldedConstant.Length(\"Pt\",v));case Err(e)=>Err(e)};case _=>Ok(FoldedConstant.Unknown)}}\n          else {Ok(FoldedConstant.Length(match method {case \"toPt\"=>\"Pt\";case \"toMm\"=>\"Mm\";case \"toCm\"=>\"Cm\";case \"toIn\"=>\"In\";case _=>unit},ticks))}\n        case _=>Ok(FoldedConstant.Unknown)\n      }\n    }\n    return match result {case Ok(v)=>Ok(v);case Err(message)=>{constantExpressionFault(state,moduleIndex,node,message);Err(())}}\n  }\n  match integerBitConstant(state, moduleIndex, node) {\n    case Some(object) => {\n      let left = match foldConstantScalar(state, moduleIndex, object)? { case Integer(value) => match value.toInt() { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }; case _ => return Ok(FoldedConstant.Unknown) }\n      let argument = argumentValue(children(node, \"arguments\")[0])\n      let right = match foldConstantScalar(state, moduleIndex, argument)? { case Integer(value) => match value.toInt() { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }; case _ => return Ok(FoldedConstant.Unknown) }\n      let source = match moduleAt(state, moduleIndex) { case Some(module) => module.source; case None => return Ok(FoldedConstant.Unknown) }\n      let callee = match child(node, \"callee\") { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }\n      let field = match child(callee, \"field\") { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }\n      let method = text(source, field)\n      if method == \"shift\" && (right < -63 || right > 63) {\n        constantExpressionFault(state, moduleIndex, node, \"integer shift count must be between -63 and 63\")\n        return Err(())\n      }\n      let value = match method { case \"and\" => left.and(right); case \"or\" => left.or(right); case \"xor\" => left.xor(right); case _ => left.shift(right) }\n      return Ok(FoldedConstant.Integer(value.toBigInt()))\n    }\n    case None => ()\n  }\n  match floatIntegerConstant(state, moduleIndex, node) {\n    case Some(object) => {\n      let value = match foldConstantScalar(state, moduleIndex, object)? { case Floating(value) => value; case _ => return Ok(FoldedConstant.Unknown) }\n      let source = match moduleAt(state, moduleIndex) { case Some(module) => module.source; case None => return Ok(FoldedConstant.Unknown) }\n      let callee = match child(node, \"callee\") { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }\n      let field = match child(callee, \"field\") { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }\n      let method = text(source, field)\n      // binary64 spacing at +/-2^63 makes this input interval equal\n      // to the rounded-result interval for all four integer conversions. Check\n      // before the receiver so a compiler constant error stays at the user node.\n      if !value.isFinite() || value < -9223372036854775808.0 || value >= 9223372036854775808.0 {\n        constantExpressionFault(state, moduleIndex, node, \"float.{method} result is not representable as int\")\n        return Err(())\n      }\n      let rounded = match method {\n        case \"floor\" => value.floor().toFloat()\n        case \"ceil\" => value.ceil().toFloat()\n        case \"round\" => value.round().toFloat()\n        case _ => if value < 0.0 { value.ceil().toFloat() } else { value.floor().toFloat() }\n      }\n      // Two exact 32-bit lanes\n      // transfer the binary64 integer to the arbitrary-precision fold representation.\n      // Each lane is below 2^53; shortest float text cannot round a low bit away.\n      let high = (rounded / 4294967296.0).floor().toFloat()\n      let low = rounded - high * 4294967296.0\n      let highInt = match \"{high}\".replace(\".0\", \"\").toInt() { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }\n      let lowInt = match \"{low}\".replace(\".0\", \"\").toInt() { case Some(value) => value; case None => return Ok(FoldedConstant.Unknown) }\n      return Ok(FoldedConstant.Integer((highInt * 4294967296 + lowInt).toBigInt()))\n    }\n    case None => ()\n  }\n  let integerSource = match moduleAt(state, moduleIndex) { case Some(module) => module.source; case None => Bytes.empty() }\n  match signedIntegerInput(node, integerSource) {\n    case Some(input) => return Ok(match decodeIntegerLiteral(input.spelling, input.negative) {\n      case Some(value) => FoldedConstant.Integer(value.toBigInt())\n      case None => FoldedConstant.Unknown\n    })\n    case None => ()\n  }\n  if node.kind == \"expression/integer\" {\n    return Ok(match attribute(node, \"valueDecimal\").toInt() {\n      case Some(value) => FoldedConstant.Integer(value.toBigInt())\n      case None => FoldedConstant.Unknown\n    })\n  }\n  if node.kind == \"expression/boolean\" { return Ok(FoldedConstant.Boolean(boolAttribute(node, \"value\"))) }\n  if node.kind == \"expression/null\" { return Ok(FoldedConstant.Null) }\n  if node.kind == \"expression/unit\" { return Ok(FoldedConstant.Unit) }\n  if node.kind == \"expression/float\" {\n    let source = match moduleAt(state, moduleIndex) {\n      case Some(module) => module.source\n      case None => return Ok(FoldedConstant.Unknown)\n    }\n    if state.languageMode == \"topaz-5.21\" {return Ok(match decodeDecimalFloatLiteral(text(source,node)) {case Some(value)=>FoldedConstant.Floating(value);case None=>FoldedConstant.Unknown})}\n    return Ok(match text(source, node).replace(\"_\", \"\").parseFloat() {\n      case Ok(value) => FoldedConstant.Floating(value)\n      case Err(_) => FoldedConstant.Unknown\n    })\n  }\n  if node.kind == \"expression/identifier\" {\n    match referenceFor(state, moduleIndex, node.lo, node.hi) {\n      case Some(reference) => match declarationConstantForReference(state, reference) {\n        case Some(value) => return Ok(value)\n        case None => ()\n      }\n      case None => ()\n    }\n    let value = match resolvedTypeOfReference(state, moduleIndex, node) {\n      case Some(value) => value\n      case None => return Ok(FoldedConstant.Unknown)\n    }\n    if value.kind == \"literal\" && value.name == \"int\" {\n      return Ok(match value.value.toInt() {\n        case Some(value) => FoldedConstant.Integer(value.toBigInt())\n        case None => FoldedConstant.Unknown\n      })\n    }\n    if value.kind == \"literal\" && value.name == \"bool\" { return Ok(FoldedConstant.Boolean(value.value == \"true\")) }\n    if value.name == \"null\" { return Ok(FoldedConstant.Null) }\n    return Ok(FoldedConstant.Unknown)\n  }\n  if node.kind == \"expression/parenthesized\" {\n    return match child(node, \"operand\") {\n      case Some(value) => foldConstantScalar(state, moduleIndex, value)\n      case None => Ok(FoldedConstant.Unknown)\n    }\n  }\n  if node.kind == \"expression/string\" {\n    let source = match moduleAt(state, moduleIndex) {\n      case Some(module) => module.source\n      case None => return Ok(FoldedConstant.Unknown)\n    }\n    let mut output = \"\"\n    let mut known = true\n    for part in node.children {\n      if part.kind == \"string-part/text\" {\n        output = output + attribute(part, \"cooked\")\n      } else {\n        let value = match child(part, \"value\") {\n          case Some(value) => foldConstantScalar(state, moduleIndex, value)?\n          case None => FoldedConstant.Unknown\n        }\n        match value {\n          case Text(value) => { output = output + value }\n          case Integer(value) => { output = output + value.toString(10) }\n          case Floating(value) => { output = output + \"{value}\" }\n          case Length(unit,value) => { output = output + \"Length<{unit}>({value})\" }\n          case Boolean(value) => { output = output + \"{value}\" }\n          case Null => { output = output + \"null\" }\n          case Unit => { output = output + \"()\" }\n          case Rendered(shape, mutable, epoch) => if !mutable || epoch == constantRenderEpoch(state) {\n            output = output + renderKnownLiteral(shape)\n          } else { known = false }\n          case _ => { known = false }\n        }\n      }\n    }\n    return Ok(if known { FoldedConstant.Text(output) } else { FoldedConstant.NonNull })\n  }\n  if node.kind == \"expression/array\" || node.kind == \"expression/record-literal\" {\n    let array = node.kind == \"expression/array\"\n    let source = match moduleAt(state, moduleIndex) { case Some(module) => module.source; case None => return Ok(FoldedConstant.NonNull) }\n    let mut shapes: Array<KnownLiteralRender> = []\n    let mut fields: Array<KnownLiteralRenderField> = []\n    let mut known = true\n    let mut mutable = array\n    for element in node.children {\n      let valueNode = if array { Some(element) } else { child(element, \"value\") }\n      match valueNode {\n        case Some(valueNode) => {\n          let value = foldConstantScalar(state, moduleIndex, valueNode)?\n          match foldedRenderShape(state, value) {\n            case Some(shape) => { shapes.push(shape) }\n            case None => { known = false }\n          }\n          mutable = mutable || foldedRenderIsMutable(value)\n          if !array {\n            match child(element, \"name\") {\n              case Some(name) => match foldedRenderShape(state, value) {\n                case Some(shape) => { fields.push(KnownLiteralRenderField { name: text(source, name), shape: shape }) }\n                case None => { known = false }\n              }\n              case None => { known = false }\n            }\n          }\n        }\n        case None => { known = false }\n      }\n    }\n    fields.sortBy((field) => field.name)\n    return Ok(if known {\n      FoldedConstant.Rendered(if array { KnownLiteralRender.Array(shapes) } else { KnownLiteralRender.Record(fields) }, mutable, constantRenderEpoch(state))\n    } else { FoldedConstant.NonNull })\n  }\n  if node.kind == \"expression/unary\" {\n    let operand = match child(node, \"operand\") {\n      case Some(value) => value\n      case None => return Ok(FoldedConstant.Unknown) }\n    let value = foldConstantScalar(state, moduleIndex, operand)?\n    let operator = attribute(node, \"operator\")\n    if operator == \"plus\" { return Ok(value) }\n    return match value {\n      case Length(unit,value) => if operator == \"minus\" {\n        match roundFraction(-(value).toBigInt(),(1).toBigInt()) {case Ok(v)=>Ok(FoldedConstant.Length(unit,v));case Err(message)=>{constantExpressionFault(state,moduleIndex,node,message);Err(())}}\n      } else {Ok(FoldedConstant.Unknown)}\n      case Floating(value) => if operator == \"minus\" { Ok(FoldedConstant.Floating(-value)) } else { Ok(FoldedConstant.Unknown) }\n      case Boolean(value) => if operator == \"not\" { Ok(FoldedConstant.Boolean(!value)) } else { Ok(FoldedConstant.Unknown) }\n      case Integer(value) => if operator == \"minus\" {\n        match constantIntegerResult(state, moduleIndex, node, -value, \"integer negation overflows\") {\n          case Some(value) => Ok(FoldedConstant.Integer(value))\n          case None => Err(())\n        }\n      } else { Ok(FoldedConstant.Unknown) }\n      case _ => Ok(FoldedConstant.Unknown)\n    }\n  }\n  if node.kind != \"expression/binary\" { return Ok(FoldedConstant.Unknown) }\n  let leftNode = match child(node, \"left\") {\n    case Some(value) => value\n    case None => return Ok(FoldedConstant.Unknown) }\n  let rightNode = match child(node, \"right\") {\n    case Some(value) => value\n    case None => return Ok(FoldedConstant.Unknown) }\n  let left = foldConstantScalar(state, moduleIndex, leftNode)?\n  let operator = attribute(node, \"operator\")\n  if operator == \"and\" || operator == \"or\" {\n    return match left {\n      case Boolean(value) => if (operator == \"and\" && !value) || (operator == \"or\" && value) { Ok(left) }\n        else { foldConstantScalar(state, moduleIndex, rightNode) }\n      case _ => Ok(FoldedConstant.Unknown)\n    }\n  }\n  if operator == \"coalesce\" {\n    return match left {\n      case Null => foldConstantScalar(state, moduleIndex, rightNode)\n      case Unknown => Ok(FoldedConstant.Unknown)\n      case _ => Ok(left)\n    }\n  }\n  let right = foldConstantScalar(state, moduleIndex, rightNode)?\n  match foldLengthBinary(operator,left,right) {\n    case Some(result)=>return match result {case Ok(v)=>Ok(v);case Err(message)=>{constantExpressionFault(state,moduleIndex,node,message);Err(())}}\n    case None=>()\n  }\n  if operator == \"equal\" || operator == \"not-equal\" {\n    match right {\n      case Null => {\n        let equal = match left {\n          case Unknown => return Ok(FoldedConstant.Unknown)\n          case Null => true\n          case _ => false\n        }\n        return Ok(FoldedConstant.Boolean(if operator == \"equal\" { equal } else { !equal }))\n      }\n      case _ => ()\n    }\n  }\n  match left {\n    case Text(leftValue) => return match right {\n      case Text(rightValue) => {\n        if operator == \"equal\" { return Ok(FoldedConstant.Boolean(leftValue == rightValue)) }\n        if operator == \"not-equal\" { return Ok(FoldedConstant.Boolean(leftValue != rightValue)) }\n        if operator == \"less-than\" { return Ok(FoldedConstant.Boolean(leftValue < rightValue)) }\n        if operator == \"less-or-equal\" { return Ok(FoldedConstant.Boolean(leftValue <= rightValue)) }\n        if operator == \"greater-than\" { return Ok(FoldedConstant.Boolean(leftValue > rightValue)) }\n        if operator == \"greater-or-equal\" { return Ok(FoldedConstant.Boolean(leftValue >= rightValue)) }\n        if operator == \"add\" { return Ok(FoldedConstant.Text(leftValue + rightValue)) }\n        Ok(FoldedConstant.Unknown)\n      }\n      case Null => if operator == \"equal\" { Ok(FoldedConstant.Boolean(false)) } else if operator == \"not-equal\" { Ok(FoldedConstant.Boolean(true)) } else { Ok(FoldedConstant.Unknown) }\n      case _ => Ok(FoldedConstant.Unknown)\n    }\n    case Floating(leftValue) => return match right {\n      case Floating(rightValue) => {\n        if operator == \"equal\" { return Ok(FoldedConstant.Boolean(leftValue == rightValue)) }\n        if operator == \"not-equal\" { return Ok(FoldedConstant.Boolean(leftValue != rightValue)) }\n        if operator == \"less-than\" { return Ok(FoldedConstant.Boolean(leftValue < rightValue)) }\n        if operator == \"less-or-equal\" { return Ok(FoldedConstant.Boolean(leftValue <= rightValue)) }\n        if operator == \"greater-than\" { return Ok(FoldedConstant.Boolean(leftValue > rightValue)) }\n        if operator == \"greater-or-equal\" { return Ok(FoldedConstant.Boolean(leftValue >= rightValue)) }\n        if operator == \"add\" { return Ok(FoldedConstant.Floating(leftValue + rightValue)) }\n        if operator == \"subtract\" { return Ok(FoldedConstant.Floating(leftValue - rightValue)) }\n        if operator == \"multiply\" { return Ok(FoldedConstant.Floating(leftValue * rightValue)) }\n        if operator == \"divide\" { return Ok(FoldedConstant.Floating(leftValue / rightValue)) }\n        if operator == \"power\" { return Ok(FoldedConstant.Floating(leftValue ** rightValue)) }\n        Ok(FoldedConstant.Unknown)\n      }\n      case Null => if operator == \"equal\" { Ok(FoldedConstant.Boolean(false)) } else if operator == \"not-equal\" { Ok(FoldedConstant.Boolean(true)) } else { Ok(FoldedConstant.Unknown) }\n      case _ => Ok(FoldedConstant.Unknown)\n    }\n    case Null => {\n      let equal = match right { case Null => true\n        case Unknown => return Ok(FoldedConstant.Unknown)\n        case _ => false }\n      return Ok(if operator == \"equal\" { FoldedConstant.Boolean(equal) } else if operator == \"not-equal\" { FoldedConstant.Boolean(!equal) } else { FoldedConstant.Unknown })\n    }\n    case Unit => return match right {\n      case Unit => Ok(if operator == \"equal\" { FoldedConstant.Boolean(true) } else if operator == \"not-equal\" { FoldedConstant.Boolean(false) } else { FoldedConstant.Unknown })\n      case _ => Ok(FoldedConstant.Unknown)\n    }\n    case _ => ()\n  }\n  match left {\n    case Boolean(leftValue) => return match right {\n      case Boolean(rightValue) => if operator == \"equal\" { Ok(FoldedConstant.Boolean(leftValue == rightValue)) }\n        else if operator == \"not-equal\" { Ok(FoldedConstant.Boolean(leftValue != rightValue)) }\n        else { Ok(FoldedConstant.Unknown) }\n      case _ => Ok(FoldedConstant.Unknown)\n    }\n    case _ => ()\n  }\n  let leftValue = match left {\n    case Integer(value) => value\n    case _ => return Ok(FoldedConstant.Unknown) }\n  let rightValue = match right {\n    case Integer(value) => value\n    case _ => return Ok(FoldedConstant.Unknown) }\n  if operator == \"equal\" { return Ok(FoldedConstant.Boolean(leftValue == rightValue)) }\n  if operator == \"not-equal\" { return Ok(FoldedConstant.Boolean(leftValue != rightValue)) }\n  if operator == \"less-than\" { return Ok(FoldedConstant.Boolean(leftValue < rightValue)) }\n  if operator == \"less-or-equal\" { return Ok(FoldedConstant.Boolean(leftValue <= rightValue)) }\n  if operator == \"greater-than\" { return Ok(FoldedConstant.Boolean(leftValue > rightValue)) }\n  if operator == \"greater-or-equal\" { return Ok(FoldedConstant.Boolean(leftValue >= rightValue)) }\n  match foldConstantBinaryIntegers(state, moduleIndex, node, operator, leftValue, rightValue) {\n    case Some(value) => Ok(FoldedConstant.Integer(value))\n    case None => Err(())\n  }\n}\n\nfunction foldConstantBinaryIntegers(\n  state: CheckerState, moduleIndex: int, node: SyntaxNode,\n  operator: string, left: BigInt, right: BigInt,\n) -> Option<BigInt> {\n  let leftInt = match left.toInt() {\n    case Some(found) => found\n    case None => return None\n  }\n  let rightInt = match right.toInt() {\n    case Some(found) => found\n    case None => return None\n  }\n  match operator {\n    case \"add\" => constantIntegerResult(\n      state,\n      moduleIndex,\n      node,\n      left + right,\n      \"integer addition overflows\",\n    )\n    case \"subtract\" => constantIntegerResult(\n      state,\n      moduleIndex,\n      node,\n      left - right,\n      \"integer subtraction overflows\",\n    )\n    case \"multiply\" => constantIntegerResult(\n      state,\n      moduleIndex,\n      node,\n      left * right,\n      \"integer multiplication overflows\",\n    )\n    case \"divide\" => if rightInt == 0 {\n      constantExpressionFault(\n        state,\n        moduleIndex,\n        node,\n        \"integer division by zero\",\n      )\n      None\n    } else {\n      match left.div(right) {\n        case Ok(found) => constantIntegerResult(\n          state,\n          moduleIndex,\n          node,\n          found,\n          \"integer division overflows\",\n        )\n        case Err(_) => None\n      }\n    }\n    case \"remainder\" => if rightInt == 0 {\n      constantExpressionFault(\n        state,\n        moduleIndex,\n        node,\n        \"integer remainder by zero\",\n      )\n      None\n    } else if leftInt == minimumInt() && rightInt == -1 {\n      constantExpressionFault(\n        state,\n        moduleIndex,\n        node,\n        \"integer remainder overflows\",\n      )\n      None\n    } else {\n      match left.mod(right) {\n        case Ok(found) => Some(found)\n        case Err(_) => None\n      }\n    }\n    case \"power\" => if rightInt < 0 {\n      constantExpressionFault(\n        state,\n        moduleIndex,\n        node,\n        \"integer exponent must be non-negative; use float operands\",\n      )\n      None\n    } else if rightInt > MAX_CONSTANT_EXPONENT {\n      constantExpressionFault(\n        state,\n        moduleIndex,\n        node,\n        \"integer exponentiation overflows\",\n      )\n      None\n    } else {\n      constantIntegerResult(\n        state,\n        moduleIndex,\n        node,\n        constantIntegerPower(left, rightInt),\n        \"integer exponentiation overflows\",\n      )\n    }\n    case _ => return None\n  }\n}\n\n\nfunction foldedRenderShape(state: CheckerState, value: FoldedConstant) -> Option<KnownLiteralRender> {\n  match value {\n    case Integer(value) => Some(KnownLiteralRender.Text(value.toString(10)))\n    case Floating(value) => Some(KnownLiteralRender.Text(\"{value}\"))\n    case Length(unit,value) => Some(KnownLiteralRender.Text(\"Length<{unit}>({value})\"))\n    case Text(value) => Some(KnownLiteralRender.Text(value))\n    case Boolean(value) => Some(KnownLiteralRender.Text(\"{value}\"))\n    case Null => Some(KnownLiteralRender.Text(\"null\"))\n    case Unit => Some(KnownLiteralRender.Text(\"()\"))\n    case Rendered(shape, mutable, epoch) => if !mutable || epoch == constantRenderEpoch(state) { Some(shape) } else { None }\n    case _ => None\n  }\n}\n\nfunction foldedRenderIsMutable(value: FoldedConstant) -> bool {\n  match value { case Rendered(_, mutable, _) => mutable; case _ => false }\n}\n\nfunction lengthFoldResult(unit:string,value:Result<int,string>)->Result<FoldedConstant,string> {\n  match value {case Ok(v)=>Ok(FoldedConstant.Length(unit,v));case Err(e)=>Err(e)}\n}\nfunction foldLengthBinary(op:string,left:FoldedConstant,right:FoldedConstant)->Option<Result<FoldedConstant,string>> {\n  match left {\n    case Length(unit,a)=>return match right {\n      case Length(other,b)=>if unit != other {None} else {\n        if op == \"divide\" {return Some(match lengthRatio(a,b) {case Ok(v)=>Ok(FoldedConstant.Floating(v));case Err(e)=>Err(e)})}\n        if op == \"equal\" {return Some(Ok(FoldedConstant.Boolean(a==b)))}\n        if op == \"not-equal\" {return Some(Ok(FoldedConstant.Boolean(a!=b)))}\n        if op == \"less-than\" {return Some(Ok(FoldedConstant.Boolean(a<b)))}\n        if op == \"less-or-equal\" {return Some(Ok(FoldedConstant.Boolean(a<=b)))}\n        if op == \"greater-than\" {return Some(Ok(FoldedConstant.Boolean(a>b)))}\n        if op == \"greater-or-equal\" {return Some(Ok(FoldedConstant.Boolean(a>=b)))}\n        if op == \"add\" {Some(lengthFoldResult(unit,roundFraction((a).toBigInt()+(b).toBigInt(),(1).toBigInt())))}\n        else if op == \"subtract\" {Some(lengthFoldResult(unit,roundFraction((a).toBigInt()-(b).toBigInt(),(1).toBigInt())))} else {None}\n      }\n      case Integer(b)=>if op == \"multiply\" {Some(lengthFoldResult(unit,roundFraction((a).toBigInt()*b,(1).toBigInt())))} else if op == \"divide\" {Some(lengthFoldResult(unit,roundFraction((a).toBigInt(),b)))} else {None}\n      case Floating(b)=>if op == \"multiply\" {Some(lengthFoldResult(unit,lengthFloatMultiply(a,b)))} else {None}\n      case _=>None\n    }\n    case Integer(b)=>match right {case Length(unit,a)=>if op == \"multiply\" {return Some(lengthFoldResult(unit,roundFraction((a).toBigInt()*b,(1).toBigInt())))};case _=>()}\n    case Floating(b)=>match right {case Length(unit,a)=>if op == \"multiply\" {return Some(lengthFoldResult(unit,lengthFloatMultiply(a,b)))};case _=>()}\n    case _=>()\n  }\n  None\n}\n",
      "sourceSha256": "3c64e9de6bebec0b5259a0212fa754b0db92f4464cfe1a908c405d003ae2ceb3"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/syntax_index.tpz",
      "language": "topaz",
      "bytes": 25908,
      "sha256": "d035c48f643e8c4a21ddc3194a9b5418a2642e30c6e9766a144e41fa8fb84984",
      "content": "// Syntax lookup and module indexes shared by checker phases.\n// It translates resolved preview rows into stable node and source views without\n// making type decisions or emitting diagnostics on its own.\n\nimport types {\n  KnownLiteralRender,\n  PreviewAstAttribute,\n  PreviewCheckDiagnostic,\n  PreviewModuleResult,\n  PreviewResolvedDeclaration,\n  PreviewResolvedReference,\n  PreviewResolvedScope,\n  PreviewTypedNode,\n  ResolveResult,\n  SyntaxNode,\n}\nimport checker_types { TypeValue }\nimport checker.model {\n  FoldedConstant,\n  constantRenderEpoch,\n  CheckerState,\n  EnumDefinition,\n  FunctionBound,\n  FunctionDefinition,\n  ModuleSyntax,\n  NamedNominalTarget,\n  NewtypeDefinition,\n  ProtocolDefinition,\n  ProtocolMethodDefinition,\n  RecordDefinition,\n  SymbolType,\n  TYPE_BOUND_INDEX_STRIDE,\n  TypeParameterFact,\n  nominal,\n  rigid,\n}\nimport checker.type_algebra {\n  flattenType,\n  hasHole,\n}\n\nexport function text(source: Bytes, node: SyntaxNode) -> string {\n  match source.slice(node.lo, node.hi).decodeUtf8() {\n    case Ok(value) => value\n    case Err(_) => \"\"\n  }\n}\n\nexport function child(value: SyntaxNode, field: string) -> Option<SyntaxNode> {\n  for found in value.children {\n    if found.field == field {\n      return Some(found)\n    }\n  }\n  None\n}\n\nexport function children(value: SyntaxNode, field: string) -> Array<SyntaxNode> {\n  let mut output: Array<SyntaxNode> = []\n  for found in value.children {\n    if found.field == field {\n      output.push(found)\n    }\n  }\n  output\n}\n\nexport function attribute(value: SyntaxNode, name: string) -> string {\n  for found in value.attributes {\n    if found.name == name {\n      return found.value\n    }\n  }\n  \"\"\n}\n\nexport function boolAttribute(value: SyntaxNode, name: string) -> bool {\n  attribute(value, name) == \"true\"\n}\n\nexport function unwrapExport(value: SyntaxNode) -> SyntaxNode {\n  if value.kind == \"statement/export\" {\n    match child(value, \"item\") {\n      case Some(item) => item\n      case None => value\n    }\n  } else {\n    value\n  }\n}\n\nexport function spanKey(moduleIndex: int, lo: int, hi: int) -> string {\n  \"{moduleIndex}:{lo}:{hi}\"\n}\n\nfunction nodeKey(moduleIndex: int, kind: string, lo: int, hi: int) -> string {\n  \"{moduleIndex}:{kind}:{lo}:{hi}\"\n}\n\nexport function typedNodeIndex(\n  state: CheckerState,\n  moduleIndex: int,\n  kind: string,\n  lo: int,\n  hi: int,\n) -> int {\n  match state.nodeIndexes.get(nodeKey(moduleIndex, kind, lo, hi)) {\n    case Some(index) => index\n    case None => -1\n  }\n}\n\nexport function scopeKey(moduleIndex: int, ordinal: int) -> string {\n  \"{moduleIndex}:{ordinal}\"\n}\n\nexport function definitionNameKey(moduleIndex: int, name: string) -> string {\n  \"{moduleIndex}:{name}\"\n}\n\nexport function emptyStringIntMap() -> Map<string, int> {\n  let mut value = map { \"\": 0 }\n  value.remove(\"\")\n  value\n}\n\nexport function declarationFor(\n  state: CheckerState,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<PreviewResolvedDeclaration> {\n  match state.declarationIndexes.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(index) => match state.resolved.declarations.get(index) {\n      case Some(declaration) => Some(declaration)\n      case None => None\n    }\n    case None => None\n  }\n}\n\n// Namespace member facts belong to the field token. Project a whole Member\n// head only through its actual AST and an existing namespace-member fact.\nfunction namespaceMemberReferenceFor(\n  state: CheckerState,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<PreviewResolvedReference> {\n  let module = match state.modules.get(moduleIndex) {\n    case Some(found) => found\n    case None => return None\n  }\n  let mut pending:Array<SyntaxNode> = [module.root]\n  while pending.length > 0 {\n    let node = match pending.pop() {\n      case Some(found) => found\n      case None => return None\n    }\n    if node.lo == lo && node.hi == hi && node.kind == \"expression/member\" {\n      let object = match child(node, \"object\") {\n        case Some(found) => found\n        case None => return None\n      }\n      if object.kind != \"expression/identifier\" { return None }\n      let field = match child(node, \"field\") {\n        case Some(found) => found\n        case None => return None\n      }\n      match state.referenceIndexes.get(spanKey(moduleIndex, field.lo, field.hi)) {\n        case Some(index) => match state.resolved.references.get(index) {\n          case Some(reference) => if reference.role == \"namespace-member\" {\n            return Some(reference)\n          }\n          case None => ()\n        }\n        case None => ()\n      }\n      return None\n    }\n    for found in node.children {\n      if found.lo <= lo && found.hi >= hi { pending.push(found) }\n    }\n  }\n  None\n}\n\nexport function referenceFor(\n  state: CheckerState,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<PreviewResolvedReference> {\n  match state.referenceIndexes.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(index) => match state.resolved.references.get(index) {\n      case Some(reference) => Some(reference)\n      case None => None\n    }\n    case None => namespaceMemberReferenceFor(state, moduleIndex, lo, hi)\n  }\n}\n\nexport function symbolAt(\n  state: CheckerState,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<SymbolType> {\n  match state.symbolIndexes.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(index) => match state.symbols.get(index) {\n      case Some(symbol) => Some(symbol)\n      case None => None\n    }\n    case None => None\n  }\n}\n\nexport function symbolTypeAt(\n  state: CheckerState,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<TypeValue> {\n  match symbolAt(state, moduleIndex, lo, hi) {\n    case Some(symbol) => Some(symbol.typeValue)\n    case None => None\n  }\n}\n\nexport function moduleIndexByIdentity(\n  state: CheckerState,\n  identity: string,\n) -> int {\n  for module in state.modules {\n    if module.identity == identity {\n      return module.moduleIndex\n    }\n  }\n  -1\n}\n\nexport function symbolTypeByName(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n  namespace: string,\n) -> Option<TypeValue> {\n  for declaration in state.resolved.declarations {\n    if declaration.moduleIndex == moduleIndex &&\n      declaration.name == name &&\n      declaration.namespace == namespace {\n      match symbolTypeAt(\n        state,\n        moduleIndex,\n        declaration.lo,\n        declaration.hi,\n      ) {\n        case Some(found) => return Some(found)\n        case None => ()\n      }\n    }\n  }\n  None\n}\n\nexport function bindSymbol(\n  state: CheckerState,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  name: string,\n  typeValue: TypeValue,\n  mutable: bool,\n) -> () {\n  let mut target = state.symbols\n  let key = spanKey(moduleIndex, lo, hi)\n  match state.symbolIndexes.get(key) {\n    case Some(index) => match target.get(index) {\n      case Some(symbol) => {\n        target[index] = SymbolType {\n          constantValue: symbol.constantValue,\n          moduleIndex: symbol.moduleIndex,\n          lo: symbol.lo,\n          hi: symbol.hi,\n          name: symbol.name,\n          typeValue: typeValue,\n          mutable: mutable,\n        }\n      }\n      case None => ()\n    }\n    case None => {\n      let mut indexes = state.symbolIndexes\n      indexes.insert(key, target.length)\n      target.push(SymbolType {\n        constantValue: None,\n        moduleIndex: moduleIndex,\n        lo: lo,\n        hi: hi,\n        name: name,\n        typeValue: typeValue,\n        mutable: mutable,\n      })\n    }\n  }\n}\n\n// Follow only existing selected-import declaration targets. Declaration aliases\n// retain their own Const/Let origin; function metadata is a separate consumer.\nexport function declarationOriginForReference(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> Option<PreviewResolvedDeclaration> {\n  let mut declaration = match declarationFor(state, reference.targetModuleIndex, reference.targetLo, reference.targetHi) {\n    case Some(found) => found\n    case None => return None\n  }\n  let mut remaining = state.resolved.declarations.length\n  while declaration.declarationKind == \"selected-import\" && remaining > 0 {\n    let moduleIndex = moduleIndexByIdentity(state, declaration.targetModule)\n    let key = \"original:{moduleIndex}:{declaration.namespace}:{declaration.targetName}\"\n    let index = match state.declarationIndexes.get(key) {\n      case Some(found) => found\n      case None => return None }\n    declaration = match state.resolved.declarations.get(index) {\n      case Some(found) => found\n      case None => return None }\n    remaining -= 1\n  }\n  if remaining == 0 { return None }\n  Some(declaration)\n}\n\nexport function setDeclarationConstant(\n  state: CheckerState, moduleIndex: int, lo: int, hi: int, value: FoldedConstant,\n) -> () {\n  match state.symbolIndexes.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(index) => match state.symbols.get(index) {\n      case Some(symbol) => {\n        let mut symbols = state.symbols\n        symbols[index] = SymbolType {\n          constantValue: Some(value), moduleIndex: symbol.moduleIndex,\n          lo: symbol.lo, hi: symbol.hi, name: symbol.name,\n          typeValue: symbol.typeValue, mutable: symbol.mutable,\n        }\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n}\n\nexport function declarationConstantForReference(\n  state: CheckerState, reference: PreviewResolvedReference,\n) -> Option<FoldedConstant> {\n  let declaration = match declarationOriginForReference(state, reference) {\n    case Some(value) => value\n    case None => return None\n  }\n  if declaration.declarationKind == \"function\" { return Some(FoldedConstant.Rendered(KnownLiteralRender.Text(\"<function {declaration.name}>\"), false, constantRenderEpoch(state))) }\n  match state.symbolIndexes.get(spanKey(declaration.moduleIndex, declaration.lo, declaration.hi)) {\n    case Some(index) => match state.symbols.get(index) {\n      case Some(symbol) => match symbol.constantValue {\n        case Some(Rendered(_, true, epoch)) => if declaration.moduleIndex == reference.moduleIndex &&\n          epoch == constantRenderEpoch(state) { symbol.constantValue } else { Some(FoldedConstant.NonNull) }\n        case _ => symbol.constantValue\n      }\n      case None => None\n    }\n    case None => None\n  }\n}\n\nexport function resolvedTypeOfReference(\n  state: CheckerState,\n  moduleIndex: int,\n  node: SyntaxNode,\n) -> Option<TypeValue> {\n  match referenceFor(state, moduleIndex, node.lo, node.hi) {\n    case Some(reference) => resolvedTypeFromFact(state, reference)\n    case None => None\n  }\n}\n\nexport function resolvedTypeFromFact(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> Option<TypeValue> {\n  if reference.targetModuleIndex < 0 {\n    return None\n  }\n  match symbolTypeAt(\n    state,\n    reference.targetModuleIndex,\n    reference.targetLo,\n    reference.targetHi,\n  ) {\n    case Some(found) => return Some(found)\n    case None => ()\n  }\n  match declarationFor(\n    state,\n    reference.targetModuleIndex,\n    reference.targetLo,\n    reference.targetHi,\n  ) {\n    case Some(declaration) => {\n      if declaration.targetModule == \"\" {\n        return None\n      }\n      let targetModule = moduleIndexByIdentity(\n        state,\n        declaration.targetModule,\n      )\n      symbolTypeByName(\n        state,\n        targetModule,\n        declaration.targetName,\n        reference.targetNamespace,\n      )\n    }\n    case None => None\n  }\n}\n\nexport function addNode(\n  state: CheckerState,\n  moduleIndex: int,\n  kind: string,\n  node: SyntaxNode,\n  typeValue: TypeValue,\n) -> () {\n  let mut target = state.nodes\n  let key = nodeKey(moduleIndex, kind, node.lo, node.hi)\n  match state.nodeIndexes.get(key) {\n    case Some(_) => return ()\n    case None => ()\n  }\n  let mut indexes = state.nodeIndexes\n  indexes.insert(key, target.length)\n  target.push(PreviewTypedNode {\n    moduleIndex: moduleIndex,\n    nodeKind: kind,\n    lo: node.lo,\n    hi: node.hi,\n    typeValue: flattenType(typeValue),\n    ambient: hasHole(typeValue),\n  })\n}\n\nexport function replaceNodeType(\n  state: CheckerState,\n  moduleIndex: int,\n  kind: string,\n  node: SyntaxNode,\n  typeValue: TypeValue,\n) -> () {\n  if typeValue.kind == \"unknown\" {\n    return ()\n  }\n  let mut target = state.nodes\n  let key = nodeKey(moduleIndex, kind, node.lo, node.hi)\n  match state.nodeIndexes.get(key) {\n    case Some(index) => {\n      match target.get(index) {\n        case Some(_) => {\n          target[index] = PreviewTypedNode {\n            moduleIndex: moduleIndex,\n            nodeKind: kind,\n            lo: node.lo,\n            hi: node.hi,\n            typeValue: flattenType(typeValue),\n            ambient: hasHole(typeValue),\n          }\n          return ()\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  addNode(state, moduleIndex, kind, node, typeValue)\n}\n\nexport function addDiagnostic(\n  state: CheckerState,\n  moduleIndex: int,\n  code: string,\n  message: string,\n  primaryMessage: string,\n  node: SyntaxNode,\n) -> () {\n  let mut target = state.diagnostics\n  target.push(PreviewCheckDiagnostic {\n    moduleIndex: moduleIndex,\n    code: code,\n    message: message,\n    primaryMessage: primaryMessage,\n    lo: node.lo,\n    hi: node.hi,\n    secondary: [],\n    notes: [],\n    profileRule: \"\",\n  })\n}\n\nfunction syntaxFromFlat(\n  module: PreviewModuleResult,\n  maxAstNodes: int,\n  maxAstDepth: int,\n) -> Result<SyntaxNode, string> {\n  if module.ast.length == 0 {\n    return Err(\"checker received a module without an AST\")\n  }\n  if module.ast.length > maxAstNodes {\n    return Err(\"front-end preview AST node count exceeds {maxAstNodes}\")\n  }\n  let mut rows: Array<SyntaxNode> = []\n  let mut depths: Array<int> = []\n  let mut ordinal = 0\n  for flat in module.ast {\n    let mut attributes: Array<PreviewAstAttribute> = []\n    if flat.attributeNames.length != flat.attributeKinds.length ||\n      flat.attributeNames.length != flat.attributeValues.length {\n      return Err(\"checker received malformed AST attributes\")\n    }\n    let mut attributeIndex = 0\n    while attributeIndex < flat.attributeNames.length {\n      attributes.push(PreviewAstAttribute {\n        name: match flat.attributeNames.get(attributeIndex) {\n          case Some(value) => value\n          case None => \"\"\n        },\n        kind: match flat.attributeKinds.get(attributeIndex) {\n          case Some(value) => value\n          case None => \"\"\n        },\n        value: match flat.attributeValues.get(attributeIndex) {\n          case Some(value) => value\n          case None => \"\"\n        },\n      })\n      attributeIndex += 1\n    }\n    let depth = if ordinal == 0 {\n      if flat.parent != -1 {\n        return Err(\"checker received an AST root with a parent\")\n      }\n      0\n    } else {\n      if flat.parent < 0 || flat.parent >= ordinal {\n        return Err(\"checker received a non-preorder AST parent\")\n      }\n      match depths.get(flat.parent) {\n        case Some(parentDepth) => parentDepth + 1\n        case None => return Err(\"checker received a missing AST parent\")\n      }\n    }\n    if depth > maxAstDepth {\n      return Err(\"front-end preview AST depth exceeds {maxAstDepth}\")\n    }\n    let rebuilt = SyntaxNode {\n      kind: flat.kind,\n      lo: flat.lo,\n      hi: flat.hi,\n      field: flat.field,\n      index: flat.index,\n      attributes: attributes,\n      children: [],\n    }\n    rows.push(rebuilt)\n    depths.push(depth)\n    if flat.parent >= 0 {\n      match rows.get(flat.parent) {\n        case Some(parent) => {\n          let mut children = parent.children\n          children.push(rebuilt)\n        }\n        case None => return Err(\"checker received a missing AST parent\")\n      }\n    }\n    ordinal += 1\n  }\n  match rows.get(0) {\n    case Some(root) => Ok(root)\n    case None => Err(\"checker received a module without an AST\")\n  }\n}\n\nexport function moduleSyntax(\n  resolved: ResolveResult,\n  maxAstNodes: int,\n  maxAstDepth: int,\n) -> Result<Array<ModuleSyntax>, string> {\n  let mut modules: Array<ModuleSyntax> = []\n  let mut index = 0\n  for module in resolved.modules {\n    let source = (module.source).encodeUtf8()\n    modules.push(ModuleSyntax {\n      moduleIndex: index,\n      sourceOrdinal: module.sourceOrdinal,\n      identity: module.identity,\n      source: source,\n      root: syntaxFromFlat(module, maxAstNodes, maxAstDepth)?,\n      generatedStd: module.generatedStd,\n    })\n    index += 1\n  }\n  Ok(modules)\n}\n\nexport function moduleAt(state: CheckerState, moduleIndex: int) -> Option<ModuleSyntax> {\n  state.modules.get(moduleIndex)\n}\n\nexport function typeParameterNames(source: Bytes, node: SyntaxNode) -> Array<string> {\n  let mut output: Array<string> = []\n  for parameter in children(node, \"typeParameters\") {\n    output.push(text(source, parameter))\n  }\n  output\n}\n\nexport function functionBounds(source: Bytes, node: SyntaxNode) -> Array<FunctionBound> {\n  let parameters = typeParameterNames(source, node)\n  let mut output: Array<FunctionBound> = []\n  for bound in children(node, \"typeParameterBounds\") {\n    let mut parameterIndex = 0\n    let mut encoded = bound.index\n    while encoded >= TYPE_BOUND_INDEX_STRIDE {\n      encoded -= TYPE_BOUND_INDEX_STRIDE\n      parameterIndex += 1\n    }\n    match parameters.get(parameterIndex) {\n      case Some(parameterName) => output.push(FunctionBound {\n        parameterName: parameterName,\n        protocol: text(source, bound),\n      })\n      case None => ()\n    }\n  }\n  output\n}\n\nexport function registerTypeParameters(\n  state: CheckerState,\n  moduleIndex: int,\n  source: Bytes,\n  node: SyntaxNode,\n) -> () {\n  let mut facts = state.typeParameters\n  let sourceOrdinal = match moduleAt(state, moduleIndex) {\n    case Some(found) => found.sourceOrdinal\n    case None => moduleIndex\n  }\n  let owner = \"source:{sourceOrdinal}:{node.lo}:{node.hi}\"\n  for parameter in children(node, \"typeParameters\") {\n    facts.push(TypeParameterFact {\n      moduleIndex: moduleIndex,\n      owner: owner,\n      name: text(source, parameter),\n      origin: \"source:{sourceOrdinal}:{parameter.lo}:{parameter.hi}\",\n    })\n  }\n  ()\n}\n\nexport function typeParameterOrigin(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n  fallback: string,\n) -> string {\n  let mut result = fallback\n  for fact in state.typeParameters {\n    if fact.moduleIndex == moduleIndex && fact.owner == fallback &&\n      fact.name == name {\n      result = fact.origin\n    }\n  }\n  result\n}\n\nexport function activeTypeParameter(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<TypeValue> {\n  let mut activeIndex = state.activeFunctions.length\n  while activeIndex > 0 {\n    activeIndex -= 1\n    match state.activeFunctions.get(activeIndex) {\n      case Some(functionIndex) => match state.functions.get(functionIndex) {\n        case Some(definition) => if definition.moduleIndex == moduleIndex {\n          let mut parameterIndex = 0\n          for parameterName in definition.typeParameters {\n            if parameterName == name {\n              return match definition.typeParameterOrigins.get(parameterIndex) {\n                case Some(origin) => Some(rigid(name, origin))\n                case None => None\n              }\n            }\n            parameterIndex += 1\n          }\n        }\n        case None => ()\n      }\n      case None => ()\n    }\n  }\n  None\n}\n\nexport function containsString(values: Array<string>, needle: string) -> bool {\n  for value in values {\n    if value == needle {\n      return true\n    }\n  }\n  false\n}\n\nexport function recordDefinitionIndex(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> int {\n  match state.recordIndexes.get(definitionNameKey(moduleIndex, name)) {\n    case Some(index) => index\n    case None => -1\n  }\n}\n\nexport function enumDefinitionIndex(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> int {\n  match state.enumIndexes.get(definitionNameKey(moduleIndex, name)) {\n    case Some(index) => index\n    case None => -1\n  }\n}\n\nexport function newtypeDefinitionIndex(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> int {\n  match state.newtypeIndexes.get(definitionNameKey(moduleIndex, name)) {\n    case Some(index) => index\n    case None => -1\n  }\n}\n\nexport function aliasDefinitionIndex(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> int {\n  match state.aliasIndexes.get(definitionNameKey(moduleIndex, name)) {\n    case Some(index) => index\n    case None => -1\n  }\n}\n\nexport function namedNominalTarget(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<NamedNominalTarget> {\n  let recordIndex = recordDefinitionIndex(state, moduleIndex, name)\n  if recordIndex >= 0 {\n    return match state.records.get(recordIndex) {\n      case Some(definition) => Some(NamedNominalTarget {\n        semanticKind: \"nominal-record\",\n        diagnosticKind: \"record\",\n        typeArgumentCount: definition.typeParameters.length,\n      })\n      case None => None\n    }\n  }\n  let enumIndex = enumDefinitionIndex(state, moduleIndex, name)\n  if enumIndex >= 0 {\n    return match state.enums.get(enumIndex) {\n      case Some(definition) => Some(NamedNominalTarget {\n        semanticKind: \"enum\",\n        diagnosticKind: \"enum\",\n        typeArgumentCount: definition.typeParameters.length,\n      })\n      case None => None\n    }\n  }\n  let newtypeIndex = newtypeDefinitionIndex(state, moduleIndex, name)\n  if newtypeIndex >= 0 {\n    return match state.newtypes.get(newtypeIndex) {\n      case Some(definition) => Some(NamedNominalTarget {\n        semanticKind: \"newtype\",\n        diagnosticKind: \"newtype\",\n        typeArgumentCount: definition.typeParameters.length,\n      })\n      case None => None\n    }\n  }\n  None\n}\n\nexport function protocolDefinitionIndex(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> int {\n  match state.protocolIndexes.get(definitionNameKey(moduleIndex, name)) {\n    case Some(index) => index\n    case None => -1\n  }\n}\n\nexport function protocolDefinition(\n  state: CheckerState,\n  moduleIndex: int,\n  name: string,\n) -> Option<ProtocolDefinition> {\n  state.protocols.get(protocolDefinitionIndex(state, moduleIndex, name))\n}\n\nexport function protocolMethodDefinition(\n  definition: ProtocolDefinition,\n  name: string,\n) -> Option<ProtocolMethodDefinition> {\n  for method in definition.methods {\n    if method.name == name {\n      return Some(method)\n    }\n  }\n  None\n}\n\nexport function functionDefinitionForReference(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> Option<FunctionDefinition> {\n  let key = spanKey(\n    reference.targetModuleIndex,\n    reference.targetLo,\n    reference.targetHi,\n  )\n  match state.functionIndexes.get(key) {\n    case Some(index) => return state.functions.get(index)\n    case None => ()\n  }\n  match state.functionAliases.get(key) {\n    case Some(index) => return state.functions.get(index)\n    case None => ()\n  }\n  let declaration = match declarationOriginForReference(state, reference) {\n    case Some(found) => found\n    case None => return None\n  }\n  let original = spanKey(declaration.moduleIndex, declaration.lo, declaration.hi)\n  match state.functionIndexes.get(original) {\n    case Some(index) => return state.functions.get(index)\n    case None => () }\n  match state.functionAliases.get(original) {\n    case Some(index) => return state.functions.get(index)\n    case None => () }\n  match state.functionNameIndexes.get(definitionNameKey(declaration.moduleIndex, declaration.name)) {\n    case Some(index) => state.functions.get(index)\n    case None => None\n  }\n}\n\nexport function functionIndexForReference(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> int {\n  let key = spanKey(\n    reference.targetModuleIndex,\n    reference.targetLo,\n    reference.targetHi,\n  )\n  match state.functionIndexes.get(key) {\n    case Some(index) => return index\n    case None => ()\n  }\n  match state.functionAliases.get(key) {\n    case Some(index) => return index\n    case None => ()\n  }\n  match functionDefinitionForReference(state, reference) {\n    case Some(definition) => match state.functionNameIndexes.get(\n      definitionNameKey(definition.moduleIndex, definition.name),\n    ) {\n      case Some(index) => index\n      case None => -1\n    }\n    case None => -1\n  }\n}\n\nexport function referenceTargetsPendingFunction(\n  state: CheckerState,\n  reference: PreviewResolvedReference,\n) -> bool {\n  let index = functionIndexForReference(state, reference)\n  if index < 0 {\n    return false\n  }\n  match state.pendingFunctions.get(index) {\n    case Some(found) => found\n    case None => false\n  }\n}\n\nexport function replaceRecordDefinition(\n  state: CheckerState,\n  index: int,\n  value: RecordDefinition,\n) -> () {\n  let mut target = state.records\n  target[index] = value\n  ()\n}\n\nexport function replaceEnumDefinition(\n  state: CheckerState,\n  index: int,\n  value: EnumDefinition,\n) -> () {\n  let mut target = state.enums\n  target[index] = value\n  ()\n}\n\nexport function replaceNewtypeDefinition(\n  state: CheckerState,\n  index: int,\n  value: NewtypeDefinition,\n) -> () {\n  let mut target = state.newtypes\n  target[index] = value\n  ()\n}\n\nexport function scopeFor(\n  state: CheckerState,\n  moduleIndex: int,\n  ordinal: int,\n) -> Option<PreviewResolvedScope> {\n  match state.scopeIndexes.get(scopeKey(moduleIndex, ordinal)) {\n    case Some(index) => match state.resolved.scopes.get(index) {\n      case Some(scope) => Some(scope)\n      case None => None\n    }\n    case None => None\n  }\n}\n\nexport function scopeIsWithin(\n  state: CheckerState,\n  moduleIndex: int,\n  candidateOrdinal: int,\n  ancestorOrdinal: int,\n) -> bool {\n  let mut current = candidateOrdinal\n  while current >= 0 {\n    if current == ancestorOrdinal {\n      return true\n    }\n    match scopeFor(state, moduleIndex, current) {\n      case Some(scope) => {\n        current = scope.parentOrdinal\n      }\n      case None => return false\n    }\n  }\n  false\n}\n\nexport function moduleIdentityAt(state: CheckerState, moduleIndex: int) -> string {\n  match moduleAt(state, moduleIndex) {\n    case Some(module) => module.identity\n    case None => \"<unknown>\"\n  }\n}\n",
      "sourceSha256": "d035c48f643e8c4a21ddc3194a9b5418a2642e30c6e9766a144e41fa8fb84984"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker/type_algebra.tpz",
      "language": "topaz",
      "bytes": 32885,
      "sha256": "0ba8f90b57dfad8dd8552ac730fe99de8a5f6bf4910e97db3870410fb4740862",
      "content": "// Structural type equality, assignability, joins, and partial-type solving.\n// The operations are independent of syntax traversal; checker leaves pass only\n// TypeValue data across this boundary.\n\nimport types { PreviewTypeAtom }\nimport checker_types { TypeValue }\nimport checker.model {\n  CheckerState,\n  TypeBinding,\n  constructor,\n  emptyType,\n  inference,\n  literal,\n  nominal,\n  lengthUnit,\n  primitive,\n  rigid,\n}\n\nexport function typeDecidable(value: TypeValue) -> bool {\n  if value.kind == \"primitive\" || value.kind == \"literal\" {\n    return true\n  }\n  if value.kind == \"union\" {\n    for member in value.members {\n      if !typeDecidable(member) { return false }\n    }\n    return true\n  }\n  if value.kind == \"constructor\" {\n    for argument in value.arguments {\n      if !typeDecidable(argument) { return false }\n    }\n    return true\n  }\n  if value.kind == \"record\" {\n    for field in value.fields {\n      if !typeDecidable(field) { return false }\n    }\n    return true\n  }\n  false\n}\n\nexport function typesOverlap(left: TypeValue, right: TypeValue) -> bool {\n  if hasHole(left) || hasHole(right) ||\n    assignable(left, right) || assignable(right, left) {\n    return true\n  }\n  if left.kind == \"union\" {\n    for member in left.members {\n      if typesOverlap(member, right) { return true }\n    }\n    return false\n  }\n  if right.kind == \"union\" {\n    for member in right.members {\n      if typesOverlap(left, member) { return true }\n    }\n    return false\n  }\n  if left.kind == \"constructor\" && right.kind == \"constructor\" {\n    return left.name == right.name\n  }\n  if left.kind == \"enum\" && right.kind == \"enum\" ||\n    left.kind == \"nominal-record\" && right.kind == \"nominal-record\" ||\n    left.kind == \"newtype\" && right.kind == \"newtype\" {\n    return left.kind == right.kind && left.identity == right.identity\n  }\n  if left.kind == \"record\" && right.kind == \"record\" &&\n    left.fieldNames.length == right.fieldNames.length {\n    let mut index = 0\n    while index < left.fieldNames.length {\n      let leftName = match left.fieldNames.get(index) {\n        case Some(found) => found\n        case None => return false\n      }\n      let rightName = match right.fieldNames.get(index) {\n        case Some(found) => found\n        case None => return false\n      }\n      let leftType = match left.fields.get(index) {\n        case Some(found) => found\n        case None => return false\n      }\n      let rightType = match right.fields.get(index) {\n        case Some(found) => found\n        case None => return false\n      }\n      if leftName != rightName ||\n        !typesOverlap(leftType, rightType) {\n        return false\n      }\n      index += 1\n    }\n    return true\n  }\n  false\n}\n\nexport function typeText(value: TypeValue) -> string {\n  typeTextInModule(value, \"\")\n}\n\n// Diagnostic rendering has a module context; semantic identity and projections\n// keep using typeText's context-free spelling.\nexport function diagnosticTypeText(value: TypeValue, currentModule: string) -> string {\n  typeTextInModule(value, currentModule)\n}\n\nfunction typeTextInModule(value: TypeValue, currentModule: string) -> string {\n  let unit = lengthUnit(value)\n  if unit != \"\" { return \"Length<{unit}>\" }\n  if value.kind == \"newtype\" && value.origin == \"\" && value.arguments.length == 0 && (value.identity == \"builtin:Pt\" || value.identity == \"builtin:Mm\" || value.identity == \"builtin:Cm\" || value.identity == \"builtin:In\" || value.identity == \"builtin:Em\") { return value.identity.replace(\"builtin:\",\"\") }\n\n  match value.kind {\n    case \"primitive\" => if value.name == \"unit\" { \"()\" } else { value.name }\n    case \"literal\" => match value.name {\n      case \"string\" => \"\\\"{value.value}\\\"\"\n      case \"null\" => \"null\"\n      case _ => value.value\n    }\n    case \"constructor\" => if value.name == \"Range\" {\n      \"range\"\n    } else {\n      \"{value.name}<{stringJoinTypes(value.arguments, \", \", currentModule)}>\"\n    }\n    case \"function\" => {\n      let mut parameters = value.parameters\n      let mut textValue = stringJoinTypes(parameters, \", \", currentModule)\n      match value.variadic.get(0) {\n        case Some(item) => {\n          if textValue != \"\" {\n            textValue = \"{textValue}, \"\n          }\n          textValue = \"{textValue}...{typeTextInModule(item, currentModule)}\"\n        }\n        case None => ()\n      }\n      let resultValue = match value.result.get(0) {\n        case Some(item) => item\n        case None => emptyType(\"unknown\")\n      }\n      \"({textValue}) -> {typeTextInModule(resultValue, currentModule)}\"\n    }\n    case \"union\" => stringJoinTypes(value.members, \" | \", currentModule)\n    case \"record\" => {\n      let mut fields: Array<string> = []\n      let mut index = 0\n      for field in value.fields {\n        let name = match value.fieldNames.get(index) {\n          case Some(found) => found\n          case None => \"\"\n        }\n        fields.push(\"{name}: {typeTextInModule(field, currentModule)}\")\n        index += 1\n      }\n      \"\\{ \" + stringJoin(fields, \", \") + \" \\}\"\n    }\n    case \"enum\" | \"nominal-record\" | \"newtype\" | \"foreign\" => {\n      let identity = if currentModule != \"\" && value.origin != \"\" &&\n        value.origin != currentModule { \"{value.origin}::{value.identity}\" } else { value.identity }\n      if value.arguments.length == 0 { identity }\n      else { \"{identity}<{stringJoinTypes(value.arguments, \", \", currentModule)}>\" }\n    }\n    case \"rigid\" => value.name\n    case \"template\" => \"template\"\n    case \"file\" => \"File\"\n    case \"json-value\" => \"JSONValue\"\n    case \"bytes\" => \"Bytes\"\n    case \"byte-buffer\" => \"ByteBuffer\"\n    case \"path\" => \"Path\"\n    case \"regex\" => \"Regex\"\n    case \"match\" => \"Match\"\n    case \"toml-value\" => \"TOMLValue\"\n    case \"url\" => \"URL\"\n    case \"date\" => \"Date\"\n    case \"big-int\" => \"BigInt\"\n    case \"decimal\" => \"Decimal\"\n    case \"rounding-mode\" => \"RoundingMode\"\n    case \"inference-variable\" => \"?{value.value}\"\n    case _ => \"?\"\n  }\n}\n\nexport function typeListText(values: Array<TypeValue>) -> string {\n  stringJoinTypes(values, \", \", \"\")\n}\n\nfunction stringJoinTypes(values: Array<TypeValue>, separator: string, currentModule: string) -> string {\n  let mut output = \"\"\n  let mut index = 0\n  for value in values {\n    if index > 0 {\n      output = \"{output}{separator}\"\n    }\n    output = \"{output}{typeTextInModule(value, currentModule)}\"\n    index += 1\n  }\n  output\n}\n\nexport function stringJoin(values: Array<string>, separator: string) -> string {\n  let mut output = \"\"\n  let mut index = 0\n  for value in values {\n    if index > 0 {\n      output = \"{output}{separator}\"\n    }\n    output = \"{output}{value}\"\n    index += 1\n  }\n  output\n}\n\nfunction typeArraysEqual(left: Array<TypeValue>, right: Array<TypeValue>) -> bool {\n  if left.length != right.length {\n    return false\n  }\n  let mut index = 0\n  while index < left.length {\n    match [left.get(index), right.get(index)] {\n      case [Some(a), Some(b)] => if !typeEqual(a, b) { return false }\n      case _ => return false\n    }\n    index += 1\n  }\n  true\n}\n\nfunction stringArraysEqual(left: Array<string>, right: Array<string>) -> bool {\n  if left.length != right.length {\n    return false\n  }\n  let mut index = 0\n  while index < left.length {\n    match [left.get(index), right.get(index)] {\n      case [Some(a), Some(b)] => if a != b { return false }\n      case _ => return false\n    }\n    index += 1\n  }\n  true\n}\n\nexport function typeEqual(left: TypeValue, right: TypeValue) -> bool {\n  left.kind == right.kind &&\n    left.name == right.name &&\n    left.value == right.value &&\n    left.identity == right.identity &&\n    left.origin == right.origin &&\n    typeArraysEqual(left.arguments, right.arguments) &&\n    typeArraysEqual(left.members, right.members) &&\n    stringArraysEqual(left.fieldNames, right.fieldNames) &&\n    typeArraysEqual(left.fields, right.fields) &&\n    typeArraysEqual(left.parameters, right.parameters) &&\n    typeArraysEqual(left.variadic, right.variadic) &&\n    typeArraysEqual(left.result, right.result)\n}\n\nexport function typeContains(\n  value: TypeValue,\n  predicate: (TypeValue) -> bool,\n) -> bool {\n  if predicate(value) {\n    return true\n  }\n  for item in value.arguments {\n    if typeContains(item, predicate) { return true }\n  }\n  for item in value.members {\n    if typeContains(item, predicate) { return true }\n  }\n  for field in value.fields {\n    if typeContains(field, predicate) { return true }\n  }\n  for item in value.parameters {\n    if typeContains(item, predicate) { return true }\n  }\n  for item in value.variadic {\n    if typeContains(item, predicate) { return true }\n  }\n  for item in value.result {\n    if typeContains(item, predicate) { return true }\n  }\n  false\n}\n\nfunction holeTypeComponent(value: TypeValue) -> bool {\n  value.kind == \"unknown\" || value.kind == \"inference-variable\"\n}\n\nexport function hasHole(value: TypeValue) -> bool {\n  typeContains(value, holeTypeComponent)\n}\n\nfunction covariantArgumentsAssignable(\n  expected: Array<TypeValue>,\n  actual: Array<TypeValue>,\n) -> bool {\n  if expected.length != actual.length {\n    return false\n  }\n  let mut index = 0\n  while index < expected.length {\n    match [expected.get(index), actual.get(index)] {\n      case [Some(expectedValue), Some(actualValue)] => if !assignable(\n        expectedValue,\n        actualValue,\n      ) {\n        return false\n      }\n      case _ => return false\n    }\n    index += 1\n  }\n  true\n}\n\nfunction functionAssignable(expected: TypeValue, actual: TypeValue) -> bool {\n  if expected.parameters.length != actual.parameters.length ||\n    expected.variadic.length != actual.variadic.length {\n    return false\n  }\n  let mut index = 0\n  while index < expected.parameters.length {\n    match [expected.parameters.get(index), actual.parameters.get(index)] {\n      case [Some(expectedParameter), Some(actualParameter)] => if !assignable(\n        actualParameter,\n        expectedParameter,\n      ) {\n        return false\n      }\n      case _ => return false\n    }\n    index += 1\n  }\n  if expected.variadic.length == 1 {\n    match [expected.variadic.get(0), actual.variadic.get(0)] {\n      case [Some(expectedVariadic), Some(actualVariadic)] => if !assignable(\n        actualVariadic,\n        expectedVariadic,\n      ) {\n        return false\n      }\n      case _ => return false\n    }\n  }\n  match [expected.result.get(0), actual.result.get(0)] {\n    case [Some(expectedResult), Some(actualResult)] => assignable(\n      expectedResult,\n      actualResult,\n    )\n    case _ => false\n  }\n}\n\nexport function assignable(expected: TypeValue, actual: TypeValue) -> bool {\n  if hasHole(expected) || hasHole(actual) {\n    return true\n  }\n  if actual.kind == \"union\" {\n    for member in actual.members {\n      if !assignable(expected, member) {\n        return false\n      }\n    }\n    return true\n  }\n  let widened = widen(actual)\n  if expected.kind == \"primitive\" && widened.kind == \"primitive\" {\n    return expected.name == widened.name\n  }\n  if typeEqual(expected, actual) || typeEqual(expected, widened) {\n    return true\n  }\n  if expected.kind == \"constructor\" && actual.kind == \"constructor\" &&\n    expected.name == actual.name &&\n    expected.arguments.length == actual.arguments.length {\n    if expected.name == \"Option\" || expected.name == \"Result\" {\n      return covariantArgumentsAssignable(expected.arguments, actual.arguments)\n    }\n    return typeArraysEqual(expected.arguments, actual.arguments)\n  }\n  if expected.kind == \"function\" && actual.kind == \"function\" {\n    return functionAssignable(expected, actual)\n  }\n  if expected.kind == \"record\" && actual.kind == \"record\" &&\n    expected.fieldNames.length == actual.fieldNames.length {\n    let mut index = 0\n    while index < expected.fieldNames.length {\n      match [expected.fieldNames.get(index), actual.fieldNames.get(index)] {\n        case [Some(expectedName), Some(actualName)] => if expectedName !=\n          actualName { return false }\n        case _ => return false\n      }\n      match [expected.fields.get(index), actual.fields.get(index)] {\n        case [Some(expectedField), Some(actualField)] => if !assignable(\n          expectedField,\n          actualField,\n        ) { return false }\n        case _ => return false\n      }\n      index += 1\n    }\n    return true\n  }\n  if expected.kind == \"union\" {\n    for member in expected.members {\n      if assignable(member, actual) {\n        return true\n      }\n    }\n  }\n  false\n}\n\nfunction flattenTypeInto(\n  output: Array<PreviewTypeAtom>,\n  value: TypeValue,\n  parent: int,\n  field: string,\n  index: int,\n  edgeName: string,\n) -> () {\n  let mut target = output\n  let ordinal = target.length\n  target.push(PreviewTypeAtom {\n    parent: parent,\n    field: field,\n    index: index,\n    edgeName: edgeName,\n    kind: value.kind,\n    name: value.name,\n    value: value.value,\n    identity: value.identity,\n    origin: value.origin,\n  })\n  let mut childIndex = 0\n  for item in value.arguments {\n    flattenTypeInto(target, item, ordinal, \"arguments\", childIndex, \"\")\n    childIndex += 1\n  }\n  childIndex = 0\n  for item in value.members {\n    flattenTypeInto(target, item, ordinal, \"members\", childIndex, \"\")\n    childIndex += 1\n  }\n  childIndex = 0\n  for item in value.fields {\n    let fieldName = match value.fieldNames.get(childIndex) {\n      case Some(found) => found\n      case None => \"\"\n    }\n    flattenTypeInto(target, item, ordinal, \"fields\", childIndex, fieldName)\n    childIndex += 1\n  }\n  childIndex = 0\n  for item in value.parameters {\n    flattenTypeInto(target, item, ordinal, \"parameters\", childIndex, \"\")\n    childIndex += 1\n  }\n  childIndex = 0\n  for item in value.variadic {\n    flattenTypeInto(target, item, ordinal, \"variadic\", childIndex, \"\")\n    childIndex += 1\n  }\n  childIndex = 0\n  for item in value.result {\n    flattenTypeInto(target, item, ordinal, \"result\", childIndex, \"\")\n    childIndex += 1\n  }\n  ()\n}\n\nexport function flattenType(value: TypeValue) -> Array<PreviewTypeAtom> {\n  let mut output: Array<PreviewTypeAtom> = []\n  flattenTypeInto(output, value, -1, \"root\", 0, \"\")\n  output\n}\n\nexport function flattenedHasHole(value: Array<PreviewTypeAtom>) -> bool {\n  for atom in value {\n    if atom.kind == \"unknown\" || atom.kind == \"inference-variable\" {\n      return true\n    }\n  }\n  false\n}\n\nexport function resolvedFlatType(\n  value: Array<PreviewTypeAtom>,\n  solutions: Map<string, TypeValue>,\n) -> Array<PreviewTypeAtom> {\n  let mut output: Array<PreviewTypeAtom> = []\n  let mut remappedIndexes: Array<int> = []\n  for atom in value {\n    let remappedParent = if atom.parent < 0 {\n      -1\n    } else {\n      match remappedIndexes.get(atom.parent) {\n        case Some(found) => found\n        case None => -1\n      }\n    }\n    let replacement = if atom.kind == \"inference-variable\" ||\n      schemeInferenceHole(atom.kind, atom.origin, atom.value) {\n      solutions.get(\"inference:{atom.value}\")\n    } else {\n      None\n    }\n    match replacement {\n      case Some(solution) => {\n        let flattened = flattenType(solution)\n        let replacementRoot = output.length\n        for replacementAtom in flattened {\n          if replacementAtom.parent < 0 {\n            output.push(PreviewTypeAtom {\n              ...replacementAtom,\n              parent: remappedParent,\n              field: atom.field,\n              index: atom.index,\n              edgeName: atom.edgeName,\n            })\n          } else {\n            output.push(PreviewTypeAtom {\n              ...replacementAtom,\n              parent: replacementRoot + replacementAtom.parent,\n            })\n          }\n        }\n        remappedIndexes.push(replacementRoot)\n      }\n      case None => {\n        remappedIndexes.push(output.length)\n        output.push(PreviewTypeAtom { ...atom, parent: remappedParent })\n      }\n    }\n  }\n  output\n}\n\nexport function widen(value: TypeValue) -> TypeValue {\n  if value.kind != \"literal\" {\n    return value\n  }\n  match value.name {\n    case \"int\" => primitive(\"int\")\n    case \"float\" => primitive(\"float\")\n    case \"string\" => primitive(\"string\")\n    case \"bool\" => primitive(\"bool\")\n    case _ => value\n  }\n}\n\nfunction compareText(left: string, right: string) -> int {\n  if left < right {\n    -1\n  } else if right < left {\n    1\n  } else {\n    0\n  }\n}\n\nfunction compareInt(left: int, right: int) -> int {\n  if left < right {\n    -1\n  } else if right < left {\n    1\n  } else {\n    0\n  }\n}\n\nfunction typeKindOrder(kind: string) -> int {\n  match kind {\n    case \"primitive\" => 0\n    case \"literal\" => 1\n    case \"union\" => 2\n    case \"record\" => 3\n    case \"constructor\" => 4\n    case \"function\" => 5\n    case \"foreign\" => 6\n    case \"rigid\" => 7\n    case \"template\" => 8\n    case \"file\" => 9\n    case \"json-value\" => 10\n    case \"bytes\" => 11\n    case \"byte-buffer\" => 12\n    case \"path\" => 13\n    case \"regex\" => 14\n    case \"match\" => 15\n    case \"toml-value\" => 16\n    case \"url\" => 17\n    case \"date\" => 18\n    case \"big-int\" => 19\n    case \"decimal\" => 20\n    case \"rounding-mode\" => 21\n    case \"enum\" => 22\n    case \"nominal-record\" => 23\n    case \"newtype\" => 24\n    case \"unknown\" => 25\n    case \"inference-variable\" => 26\n    case _ => 27\n  }\n}\n\nfunction primitiveOrder(name: string) -> int {\n  match name {\n    case \"int\" => 0\n    case \"float\" => 1\n    case \"string\" => 2\n    case \"bool\" => 3\n    case \"unit\" => 4\n    case _ => 5\n  }\n}\n\nfunction literalOrder(name: string) -> int {\n  match name {\n    case \"string\" => 0\n    case \"int\" => 1\n    case \"float\" => 2\n    case \"bool\" => 3\n    case \"null\" => 4\n    case _ => 5\n  }\n}\n\nfunction constructorOrder(name: string) -> int {\n  match name {\n    case \"Array\" => 0\n    case \"Map\" => 1\n    case \"Set\" => 2\n    case \"Option\" => 3\n    case \"Result\" => 4\n    case \"Range\" => 5\n    case _ => 6\n  }\n}\n\nfunction parsedTypeInt(value: string) -> int {\n  match value.toInt() {\n    case Some(found) => found\n    case None => 0\n  }\n}\n\nfunction compareTypeLists(\n  left: Array<TypeValue>,\n  right: Array<TypeValue>,\n) -> int {\n  let mut index = 0\n  while index < left.length && index < right.length {\n    let leftValue = match left.get(index) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n    let rightValue = match right.get(index) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n    let compared = compareTypeValues(leftValue, rightValue)\n    if compared != 0 {\n      return compared\n    }\n    index += 1\n  }\n  compareInt(left.length, right.length)\n}\n\nfunction compareRecordTypes(left: TypeValue, right: TypeValue) -> int {\n  let mut index = 0\n  while index < left.fieldNames.length && index < right.fieldNames.length {\n    let leftName = match left.fieldNames.get(index) {\n      case Some(found) => found\n      case None => \"\"\n    }\n    let rightName = match right.fieldNames.get(index) {\n      case Some(found) => found\n      case None => \"\"\n    }\n    let nameCompared = compareText(leftName, rightName)\n    if nameCompared != 0 {\n      return nameCompared\n    }\n    let leftType = match left.fields.get(index) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n    let rightType = match right.fields.get(index) {\n      case Some(found) => found\n      case None => emptyType(\"unknown\")\n    }\n    let typeCompared = compareTypeValues(leftType, rightType)\n    if typeCompared != 0 {\n      return typeCompared\n    }\n    index += 1\n  }\n  compareInt(left.fieldNames.length, right.fieldNames.length)\n}\n\nfunction compareTypeValues(left: TypeValue, right: TypeValue) -> int {\n  let kindCompared = compareInt(\n    typeKindOrder(left.kind),\n    typeKindOrder(right.kind),\n  )\n  if kindCompared != 0 {\n    return kindCompared\n  }\n  match left.kind {\n    case \"primitive\" => compareInt(\n      primitiveOrder(left.name),\n      primitiveOrder(right.name),\n    )\n    case \"literal\" => {\n      let literalCompared = compareInt(\n        literalOrder(left.name),\n        literalOrder(right.name),\n      )\n      if literalCompared != 0 {\n        return literalCompared\n      }\n      if left.name == \"int\" {\n        compareInt(parsedTypeInt(left.value), parsedTypeInt(right.value))\n      } else {\n        compareText(left.value, right.value)\n      }\n    }\n    case \"union\" => compareTypeLists(left.members, right.members)\n    case \"record\" => compareRecordTypes(left, right)\n    case \"constructor\" => {\n      let constructorCompared = compareInt(\n        constructorOrder(left.name),\n        constructorOrder(right.name),\n      )\n      if constructorCompared != 0 {\n        return constructorCompared\n      }\n      compareTypeLists(left.arguments, right.arguments)\n    }\n    case \"function\" => {\n      let parametersCompared = compareTypeLists(\n        left.parameters,\n        right.parameters,\n      )\n      if parametersCompared != 0 {\n        return parametersCompared\n      }\n      let variadicCompared = compareTypeLists(left.variadic, right.variadic)\n      if variadicCompared != 0 {\n        return variadicCompared\n      }\n      compareTypeLists(left.result, right.result)\n    }\n    case \"foreign\" | \"enum\" | \"nominal-record\" | \"newtype\" => {\n      let identityCompared = compareText(left.identity, right.identity)\n      if identityCompared != 0 {\n        return identityCompared\n      }\n      let originCompared = compareText(left.origin, right.origin)\n      if originCompared != 0 {\n        return originCompared\n      }\n      compareTypeLists(left.arguments, right.arguments)\n    }\n    case \"rigid\" => {\n      let nameCompared = compareText(left.name, right.name)\n      if nameCompared != 0 {\n        return nameCompared\n      }\n      compareText(left.origin, right.origin)\n    }\n    case \"inference-variable\" => compareInt(\n      parsedTypeInt(left.value),\n      parsedTypeInt(right.value),\n    )\n    case _ => 0\n  }\n}\n\nexport function unionType(values: Array<TypeValue>) -> TypeValue {\n  let mut flat: Array<TypeValue> = []\n  for value in values {\n    if value.kind == \"union\" {\n      for member in value.members {\n        flat.push(member)\n      }\n    } else {\n      flat.push(value)\n    }\n  }\n  let mut ordered: Array<TypeValue> = []\n  for value in flat {\n    let mut duplicate = false\n    for existing in ordered {\n      if typeEqual(existing, value) {\n        duplicate = true\n      }\n    }\n    if !duplicate {\n      let mut inserted = false\n      let mut index = 0\n      while index < ordered.length {\n        let existing = match ordered.get(index) {\n          case Some(item) => item\n          case None => value\n        }\n        if compareTypeValues(value, existing) < 0 {\n          ordered.insert(index, value)\n          inserted = true\n          break\n        }\n        index += 1\n      }\n      if !inserted {\n        ordered.push(value)\n      }\n    }\n  }\n  match ordered.get(0) {\n    case Some(first) => if ordered.length == 1 {\n      first\n    } else {\n      TypeValue {\n        kind: \"union\",\n        name: \"\",\n        value: \"\",\n        identity: \"\",\n        origin: \"\",\n        arguments: [],\n        members: ordered,\n        fieldNames: [],\n        fields: [],\n        parameters: [],\n        variadic: [],\n        result: [],\n      }\n    }\n    case None => emptyType(\"unknown\")\n  }\n}\n\nexport function widenedUnion(values: Array<TypeValue>) -> TypeValue {\n  let mut widened: Array<TypeValue> = []\n  for value in values {\n    widened.push(widen(value))\n  }\n  unionType(widened)\n}\n\nfunction projectionOrigin(origin: string) -> bool {\n  origin.startsWith(\"projection:\") ||\n    origin == \"builtin::record-pattern\" ||\n    origin == \"builtin::constructor-pattern\" ||\n    origin == \"builtin::list-pattern\" ||\n    origin == \"builtin::iterable\" ||\n    origin == \"builtin::array-spread\"\n}\n\nfunction projectionTypeComponent(value: TypeValue) -> bool {\n  value.kind == \"rigid\" && projectionOrigin(value.origin)\n}\n\nexport function projectionType(value: TypeValue) -> bool {\n  typeContains(value, projectionTypeComponent)\n}\n\nexport function transformTypeComponents(\n  value: TypeValue,\n  replacement: (TypeValue) -> Option<TypeValue>,\n) -> TypeValue {\n  match replacement(value) {\n    case Some(transformed) => return transformed\n    case None => ()\n  }\n  let mut transformed: Array<TypeValue> = []\n  for item in value.arguments {\n    transformed.push(transformTypeComponents(item, replacement))\n  }\n  let transformedArguments = transformed\n  transformed = []\n  for item in value.members {\n    transformed.push(transformTypeComponents(item, replacement))\n  }\n  let transformedMembers = transformed\n  transformed = []\n  for item in value.fields {\n    transformed.push(transformTypeComponents(item, replacement))\n  }\n  let transformedFields = transformed\n  transformed = []\n  for item in value.parameters {\n    transformed.push(transformTypeComponents(item, replacement))\n  }\n  let transformedParameters = transformed\n  transformed = []\n  for item in value.variadic {\n    transformed.push(transformTypeComponents(item, replacement))\n  }\n  let transformedVariadic = transformed\n  transformed = []\n  for item in value.result {\n    transformed.push(transformTypeComponents(item, replacement))\n  }\n  TypeValue {\n    kind: value.kind,\n    name: value.name,\n    value: value.value,\n    identity: value.identity,\n    origin: value.origin,\n    arguments: transformedArguments,\n    members: transformedMembers,\n    fieldNames: value.fieldNames,\n    fields: transformedFields,\n    parameters: transformedParameters,\n    variadic: transformedVariadic,\n    result: transformed,\n  }\n}\n\nfunction stripProjectionTypeComponent(value: TypeValue) -> Option<TypeValue> {\n  if value.kind == \"rigid\" && projectionOrigin(value.origin) {\n    Some(emptyType(\"unknown\"))\n  } else {\n    None\n  }\n}\n\nexport function stripProjectionTypes(value: TypeValue) -> TypeValue {\n  transformTypeComponents(value, stripProjectionTypeComponent)\n}\n\n// Scheme holes carry no checking constraint until solved, but unlike an\n// unknown input they can be completed by another branch (stage0 Type::Var).\nfunction schemeInferenceHole(kind: string, origin: string, value: string) -> bool {\n  kind == \"unknown\" && value != \"\" &&\n    (origin == \"generic-call-expectation\" || origin == \"generic-call-result\")\n}\n\nfunction partialHoleKey(value: TypeValue) -> string {\n  if value.kind == \"inference-variable\" ||\n    schemeInferenceHole(value.kind, value.origin, value.value) {\n    return \"inference:{value.value}\"\n  }\n  if value.kind == \"rigid\" && value.origin.startsWith(\"builtin::\") &&\n    !projectionOrigin(value.origin) {\n    return \"rigid:{value.origin}:{value.name}\"\n  }\n  \"\"\n}\n\nfunction trueUnknownTypeComponent(value: TypeValue) -> bool {\n  value.kind == \"unknown\" && partialHoleKey(value) == \"\"\n}\n\nfunction hasTrueUnknown(value: TypeValue) -> bool {\n  typeContains(value, trueUnknownTypeComponent)\n}\n\nfunction partialHoleTypeComponent(value: TypeValue) -> bool {\n  partialHoleKey(value) != \"\"\n}\n\nexport function hasPartialHole(value: TypeValue) -> bool {\n  typeContains(value, partialHoleTypeComponent)\n}\n\nfunction partialBindingIndex(bindings: Array<TypeBinding>, key: string) -> int {\n  let mut index = 0\n  for binding in bindings {\n    if binding.name == key {\n      return index\n    }\n    index += 1\n  }\n  -1\n}\n\nfunction bindPartialType(\n  bindings: Array<TypeBinding>,\n  key: string,\n  candidate: TypeValue,\n) -> () {\n  let candidateKey = partialHoleKey(candidate)\n  if candidateKey == key {\n    return ()\n  }\n  let mut target = bindings\n  let index = partialBindingIndex(target, key)\n  if index >= 0 {\n    match target.get(index) {\n      case Some(existing) => unifyPartialTypes(\n        existing.typeValue,\n        candidate,\n        target,\n      )\n      case None => ()\n    }\n  } else {\n    target.push(TypeBinding { name: key, typeValue: candidate })\n  }\n  ()\n}\n\nfunction unifyPartialLists(\n  left: Array<TypeValue>,\n  right: Array<TypeValue>,\n  bindings: Array<TypeBinding>,\n) -> () {\n  if left.length != right.length {\n    return ()\n  }\n  let mut index = 0\n  while index < left.length {\n    match [left.get(index), right.get(index)] {\n      case [Some(a), Some(b)] => unifyPartialTypes(a, b, bindings)\n      case _ => ()\n    }\n    index += 1\n  }\n  ()\n}\n\nfunction unifyPartialTypes(\n  left: TypeValue,\n  right: TypeValue,\n  bindings: Array<TypeBinding>,\n) -> () {\n  let leftKey = partialHoleKey(left)\n  let rightKey = partialHoleKey(right)\n  if leftKey != \"\" && rightKey != \"\" {\n    if leftKey == rightKey {\n      return ()\n    }\n    if leftKey < rightKey {\n      let mut target = bindings\n      if partialBindingIndex(target, rightKey) < 0 {\n        target.push(TypeBinding { name: rightKey, typeValue: left })\n      }\n    } else {\n      let mut target = bindings\n      if partialBindingIndex(target, leftKey) < 0 {\n        target.push(TypeBinding { name: leftKey, typeValue: right })\n      }\n    }\n    return ()\n  }\n  if leftKey != \"\" {\n    bindPartialType(bindings, leftKey, right)\n    return ()\n  }\n  if rightKey != \"\" {\n    bindPartialType(bindings, rightKey, left)\n    return ()\n  }\n  if left.kind != right.kind || left.name != right.name ||\n    left.identity != right.identity {\n    return ()\n  }\n  unifyPartialLists(left.arguments, right.arguments, bindings)\n  unifyPartialLists(left.members, right.members, bindings)\n  if left.kind == \"record\" && left.fields.length == right.fields.length {\n    let mut index = 0\n    while index < left.fields.length {\n      match [left.fieldNames.get(index), right.fieldNames.get(index)] {\n        case [Some(leftName), Some(rightName)] => if leftName == rightName {\n          match [left.fields.get(index), right.fields.get(index)] {\n            case [Some(leftField), Some(rightField)] =>\n              unifyPartialTypes(leftField, rightField, bindings)\n            case _ => ()\n          }\n        }\n        case _ => ()\n      }\n      index += 1\n    }\n  }\n  unifyPartialLists(left.parameters, right.parameters, bindings)\n  unifyPartialLists(left.variadic, right.variadic, bindings)\n  unifyPartialLists(left.result, right.result, bindings)\n  ()\n}\n\nfunction partialTypeComponentReplacement(\n  value: TypeValue,\n  bindings: Array<TypeBinding>,\n) -> Option<TypeValue> {\n  let key = partialHoleKey(value)\n  if key == \"\" {\n    return None\n  }\n  let index = partialBindingIndex(bindings, key)\n  if index >= 0 {\n    return match bindings.get(index) {\n      case Some(found) => Some(substitutePartialTypes(found.typeValue, bindings))\n      case None => Some(value)\n    }\n  }\n  Some(value)\n}\n\nfunction substitutePartialTypes(\n  value: TypeValue,\n  bindings: Array<TypeBinding>,\n) -> TypeValue {\n  transformTypeComponents(\n    value,\n    (component: TypeValue) => partialTypeComponentReplacement(\n      component,\n      bindings,\n    ),\n  )\n}\n\nfunction flattenJoinTypes(values: Array<TypeValue>) -> Array<TypeValue> {\n  let mut flat: Array<TypeValue> = []\n  for value in values {\n    if value.kind == \"union\" {\n      for member in value.members {\n        flat.push(member)\n      }\n    } else {\n      flat.push(value)\n    }\n  }\n  flat\n}\n\nfunction retainInferenceSolutions(\n  state: CheckerState,\n  bindings: Array<TypeBinding>,\n) -> () {\n  let mut solutions = state.inferenceSolutions\n  for binding in bindings {\n    if binding.name.startsWith(\"inference:\") {\n      let completed = substitutePartialTypes(binding.typeValue, bindings)\n      if !hasPartialHole(completed) {\n        solutions.insert(binding.name, completed)\n      }\n    }\n  }\n  ()\n}\n\nexport function joinedTypes(\n  state: CheckerState,\n  values: Array<TypeValue>,\n  widenResult: bool,\n) -> TypeValue {\n  let flat = flattenJoinTypes(values)\n  for value in flat {\n    if hasTrueUnknown(value) {\n      return emptyType(\"unknown\")\n    }\n  }\n  let mut bindings: Array<TypeBinding> = []\n  let mut leftIndex = 0\n  while leftIndex < flat.length {\n    let mut rightIndex = 0\n    while rightIndex < flat.length {\n      if leftIndex != rightIndex {\n        match [flat.get(leftIndex), flat.get(rightIndex)] {\n          case [Some(left), Some(right)] =>\n            unifyPartialTypes(left, right, bindings)\n          case _ => ()\n        }\n      }\n      rightIndex += 1\n    }\n    leftIndex += 1\n  }\n  let mut solved: Array<TypeValue> = []\n  // Flatten only for solving holes. Preserve each input's typed union when\n  // widening: fresh scalar branches widen, existing payload domains do not.\n  for value in values {\n    let completed = substitutePartialTypes(value, bindings)\n    // Keep unresolved structure until its expected-type owner finishes. Erasing\n    // it to Unknown here hides missing Result arguments inside record joins.\n    solved.push(completed)\n  }\n  retainInferenceSolutions(state, bindings)\n  if widenResult { widenedUnion(solved) } else { unionType(solved) }\n}\n\nexport function solvePartialTypeAgainst(\n  state: CheckerState,\n  partial: TypeValue,\n  concrete: TypeValue,\n) -> TypeValue {\n  let mut bindings: Array<TypeBinding> = []\n  unifyPartialTypes(partial, concrete, bindings)\n  let completed = substitutePartialTypes(partial, bindings)\n  if hasPartialHole(completed) {\n    partial\n  } else {\n    retainInferenceSolutions(state, bindings)\n    completed\n  }\n}\n",
      "sourceSha256": "0ba8f90b57dfad8dd8552ac730fe99de8a5f6bf4910e97db3870410fb4740862"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/checker_types.tpz",
      "language": "topaz",
      "bytes": 322,
      "sha256": "6e710e4116cd6b71342d0444d587f335c4c720d4649ab66444eeeb1be34fc171",
      "content": "export record TypeValue {\n  kind: string,\n  name: string,\n  value: string,\n  identity: string,\n  origin: string,\n  arguments: Array<TypeValue>,\n  members: Array<TypeValue>,\n  fieldNames: Array<string>,\n  fields: Array<TypeValue>,\n  parameters: Array<TypeValue>,\n  variadic: Array<TypeValue>,\n  result: Array<TypeValue>,\n}\n",
      "sourceSha256": "6e710e4116cd6b71342d0444d587f335c4c720d4649ab66444eeeb1be34fc171"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/common/standard_migration.tpz",
      "language": "topaz",
      "bytes": 5164,
      "sha256": "727fda6521bb765dd9e94eb50bc297ea554583c068b0f4d0e0681860f9d07440",
      "content": "// Advice for removed spellings. The checker and resolver own binding and edition checks.\nexport function removedStaticHint(namespace: string, member: string) -> string {\n  match \"{namespace}.{member}\" {\n    case \"Array.of\" => \"use [a, b]\"\n    case \"Set.of\" => \"use set \\{ a, b \\}\"\n    case \"Map.new\" => \"use map \\{\\}\"\n    case \"Bytes.encodeUtf8\" => \"use s.encodeUtf8()\"\n    case \"Bytes.concat\" => \"use a.concat(b)\"\n    case \"BigInt.fromInt\" => \"use n.toBigInt()\"\n    case \"Decimal.fromInt\" => \"use n.toDecimal()\"\n    case \"Math.sqrt\" => \"use x.sqrt()\"\n    case \"Math.abs\" => \"use x.abs()\"\n    case \"Math.floor\" => \"use x.floor() for int, or x.floor().toFloat() for float\"\n    case \"Math.ceil\" => \"use x.ceil() for int, or x.ceil().toFloat() for float\"\n    case \"Math.round\" => \"use x.round() for int, or x.round().toFloat() for float\"\n    case \"Math.sin\" => \"use x.sin()\"\n    case \"Math.cos\" => \"use x.cos()\"\n    case \"Math.tan\" => \"use x.tan()\"\n    case \"Math.isNaN\" => \"use x.isNaN()\"\n    case \"Math.isFinite\" => \"use x.isFinite()\"\n    case \"Math.parseFloat\" => \"use s.parseFloat()\"\n    case \"Math.min\" => \"use a.atMost(b)\"\n    case \"Math.max\" => \"use a.atLeast(b)\"\n    case \"JSON.parse\" => \"import std.json and use json.parse(s)\"\n    case \"JSON.stringify\" => \"import std.json and use json.stringify(v)\"\n    case \"JSON.parseAs\" => \"import std.json and use json.parseAs<T>(s)\"\n    case \"JSON.decode\" => \"use v.decode<T>()\"\n    case \"TOML.toJson\" => \"use t.toJson()\"\n    case \"Encoding.utf8Encode\" => \"use s.encodeUtf8()\"\n    case \"Encoding.utf8Decode\" => \"use b.decodeUtf8()\"\n    case \"Encoding.hexEncode\" => \"use b.toHex()\"\n    case \"Encoding.hexDecode\" => \"use Bytes.fromHex(s)\"\n    case \"Encoding.base64Encode\" => \"use b.toBase64()\"\n    case \"Encoding.base64Decode\" => \"use Bytes.fromBase64(s)\"\n    case \"Hash.sha256\" => \"use b.sha256()\"\n    case \"Hash.sha512\" => \"use b.sha512()\"\n    case \"Hash.hmacSha256\" => \"use key.hmacSha256(data)\"\n    case \"Hash.crc32\" => \"use b.crc32()\"\n    case \"Cli.hasFlag\" => \"use args.hasFlag(name)\"\n    case \"Cli.option\" => \"use args.option(name)\"\n    case \"Cli.options\" => \"use args.options(name)\"\n    case \"Cli.positionals\" => \"use args.positionals()\"\n    case \"Codec.gzipCompress\" => \"use b.gzipCompress()\"\n    case \"Codec.gzipDecompress\" => \"use b.gzipDecompress()\"\n    case \"Codec.deflateCompress\" => \"use b.deflateCompress()\"\n    case \"Codec.deflateFixedCompress\" => \"use b.deflateFixedCompress()\"\n    case \"Codec.zlibFixedCompress\" => \"use b.zlibFixedCompress()\"\n    case \"Codec.reedSolomon255223Protect\" => \"use b.reedSolomon255223Protect()\"\n    case \"Codec.deflateDecompress\" => \"use b.deflateDecompress()\"\n    case \"Codec.zstdDecompress\" => \"use b.zstdDecompress()\"\n    case \"Codec.zstdCompress\" => \"use b.zstdCompress(level)\"\n    case \"FS.readText\" => \"import std.fs and use fs.readText(p)\"\n    case \"FS.writeText\" => \"import std.fs and use fs.writeText(p, text)\"\n    case \"FS.readBytes\" => \"import std.fs and use fs.readBytes(p)\"\n    case \"FS.writeBytes\" => \"import std.fs and use fs.writeBytes(p, bytes)\"\n    case \"FS.list\" => \"import std.fs and use fs.list(p)\"\n    case \"CSV.parse\" => \"import std.csv and use csv.parse(s)\"\n    case \"CSV.parseWithHeader\" => \"import std.csv and use csv.parseWithHeader(s)\"\n    case \"CSV.stringify\" => \"import std.csv and use csv.stringify(rows)\"\n    case \"CSV.stringifyWithHeader\" => \"import std.csv and use csv.stringifyWithHeader(rows, columns)\"\n    case \"TOML.parse\" => \"import std.toml and use toml.parse(s)\"\n    case \"TOML.stringify\" => \"import std.toml and use toml.stringify(v)\"\n    case \"TOML.fromJson\" => \"import std.toml and use toml.fromJson(v)\"\n    case \"Test.assert\" => \"import std.test and use test.assert(condition)\"\n    case \"Test.assertEq\" => \"import std.test and use test.assertEq(a, b)\"\n    case \"Test.assertNe\" => \"import std.test and use test.assertNe(a, b)\"\n    case \"Test.assertContains\" => \"import std.test and use test.assertContains(text, part)\"\n    case \"Test.assertOk\" => \"import std.test and use test.assertOk(result)\"\n    case \"Test.assertErr\" => \"import std.test and use test.assertErr(result)\"\n    case \"Test.assertSome\" => \"import std.test and use test.assertSome(option)\"\n    case \"Test.assertNone\" => \"import std.test and use test.assertNone(option)\"\n    case \"Test.assertGolden\" => \"import std.test and use test.assertGolden(name, actual)\"\n    case _ => \"\"\n  }\n}\n\nexport function removedModuleHint(module: string) -> string {\n  match module {\n    case \"std.math\" => \"; use float receiver methods such as x.sqrt(), a.atMost(b), a.atLeast(b), and s.parseFloat() in 5.21\"\n    case \"std.encoding\" => \"; use s.encodeUtf8(), b.decodeUtf8(), b.toHex(), Bytes.fromHex(s), b.toBase64(), and Bytes.fromBase64(s) in 5.21\"\n    case \"std.hash\" => \"; use b.sha256(), b.sha512(), key.hmacSha256(data), and b.crc32() in 5.21\"\n    case \"std.codec\" => \"; use Bytes receiver methods such as b.gzipCompress() and b.zstdCompress(level) in 5.21\"\n    case \"std.cli\" => \"; use args.hasFlag(name), args.option(name), args.options(name), and args.positionals() in 5.21\"\n    case \"std.gen\" => \"; use [for x in lo..hi => x] and [false, true] in 5.21\"\n    case _ => \"\"\n  }\n}\n",
      "sourceSha256": "727fda6521bb765dd9e94eb50bc297ea554583c068b0f4d0e0681860f9d07440"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter.tpz",
      "language": "topaz",
      "bytes": 8713,
      "sha256": "573001c265ddb1ea99a9108ea43ae0a4df56d347593998717c2adf9618a6e105",
      "content": "import std.json as jsonBoundary\n\nimport emitter.module { emitProgram, emitProgramWithDatabase }\nimport query.database { Database }\nimport stage1_types {\n  LoweringOutput,\n  STAGE1_IR_SCHEMA,\n  Stage1Module,\n  Stage1Operation,\n  Stage1Provenance,\n  Stage1Response,\n  decodeStage1Response,\n}\n\nrecord EmitPayload derives JSON {\n  schema: string,\n  irSchema: string,\n  runtimeTemplate: string,\n  sourceSetId: string,\n  loweredModules: Array<Stage1Module>,\n  loweredOperations: Array<Stage1Operation>,\n}\n\nconst COMPILER_RUNTIME_REGISTRY_SCHEMA =\n  \"topaz.compiler.fixed-point-runtime-templates/v1\"\nconst COMPILER_RUNTIME_TEMPLATE = \"compiler-ir-table/v2\"\nconst COMPILER_PAYLOAD_SCHEMA =\n  \"topaz.compiler.fixed-point-ir-payload/v1\"\n// Closed folding bounds operands and traversal so preview generation stays finite and portable.\nconst CLOSED_INT_OPERAND_LIMIT = 1000000000\nconst CLOSED_INT_PRODUCT_OPERAND_LIMIT = 1000000\nconst CLOSED_INT_DEPTH_LIMIT = 256\nconst ENTRY_PREVIEW_OPERATION_LIMIT = 4096\n\nfunction rustRaw(value: string) -> string {\n  let mut hashes = \"\"\n  while value.contains(\"\\\"{hashes}\") {\n    hashes = \"{hashes}#\"\n  }\n  \"r{hashes}\\\"{value}\\\"{hashes}\"\n}\n\nfunction rustStringConstant(name: string, value: string) -> string {\n  \"pub const {name}: &str = {rustRaw(value)};\\n\"\n}\n\nrecord EmitterOperationCatalog {\n  values: Array<Stage1Operation>,\n  positions: Map<string, int>,\n  runtimeLeaves: Array<string>,\n}\n\nfunction emitterOperationCatalog(\n  operations: Array<Stage1Operation>,\n) -> EmitterOperationCatalog {\n  let mut positions: Map<string, int> = map {}\n  let mut leaves: Set<string> = set {}\n  let mut index = 0\n  for operation in operations {\n    if !positions.containsKey(operation.id) {\n      positions.insert(operation.id, index)\n    }\n    if operation.runtimeLeaf != \"\" {\n      leaves.add(operation.runtimeLeaf)\n    }\n    index += 1\n  }\n  let mut orderedLeaves = leaves.toArray()\n  orderedLeaves.sort()\n  EmitterOperationCatalog {\n    values: operations,\n    positions: positions,\n    runtimeLeaves: orderedLeaves,\n  }\n}\n\nfunction operation(\n  context: EmitterOperationCatalog,\n  wanted: string,\n) -> Option<Stage1Operation> {\n  match context.positions.get(wanted) {\n    case Some(index) => Some(context.values[index])\n    case None => None\n  }\n}\n\nfunction evaluateOperand(\n  context: EmitterOperationCatalog,\n  found: Stage1Operation,\n  index: int,\n  depth: int,\n) -> Option<int> {\n  match found.operands.get(index) {\n    case Some(id) => evaluateClosedInt(context, id, depth + 1)\n    case None => None\n  }\n}\n\nfunction evaluateUnaryClosedInt(\n  context: EmitterOperationCatalog,\n  found: Stage1Operation,\n  depth: int,\n) -> Option<int> {\n  if found.operands.length != 1 {\n    return None\n  }\n  match evaluateOperand(context, found, 0, depth) {\n    case Some(number) => if found.detail == \"neg\" &&\n      number >= -CLOSED_INT_OPERAND_LIMIT && number <= CLOSED_INT_OPERAND_LIMIT {\n      Some(-number)\n    } else if found.detail == \"pos\" {\n      Some(number)\n    } else {\n      None\n    }\n    case None => None\n  }\n}\n\nfunction evaluateBinaryClosedInt(\n  context: EmitterOperationCatalog,\n  found: Stage1Operation,\n  depth: int,\n) -> Option<int> {\n  if found.operands.length != 2 {\n    return None\n  }\n  match [\n    evaluateOperand(context, found, 0, depth),\n    evaluateOperand(context, found, 1, depth),\n  ] {\n    case [Some(lhs), Some(rhs)] => match found.detail {\n      case \"add\" => if lhs >= -CLOSED_INT_OPERAND_LIMIT && lhs <= CLOSED_INT_OPERAND_LIMIT &&\n        rhs >= -CLOSED_INT_OPERAND_LIMIT && rhs <= CLOSED_INT_OPERAND_LIMIT {\n        Some(lhs + rhs)\n      } else {\n        None\n      }\n      case \"sub\" => if lhs >= -CLOSED_INT_OPERAND_LIMIT && lhs <= CLOSED_INT_OPERAND_LIMIT &&\n        rhs >= -CLOSED_INT_OPERAND_LIMIT && rhs <= CLOSED_INT_OPERAND_LIMIT {\n        Some(lhs - rhs)\n      } else {\n        None\n      }\n      case \"mul\" => if lhs >= -CLOSED_INT_PRODUCT_OPERAND_LIMIT &&\n        lhs <= CLOSED_INT_PRODUCT_OPERAND_LIMIT &&\n        rhs >= -CLOSED_INT_PRODUCT_OPERAND_LIMIT &&\n        rhs <= CLOSED_INT_PRODUCT_OPERAND_LIMIT {\n        Some(lhs * rhs)\n      } else {\n        None\n      }\n      case _ => None\n    }\n    case _ => None\n  }\n}\n\nfunction evaluateSequenceClosedInt(\n  context: EmitterOperationCatalog,\n  found: Stage1Operation,\n  depth: int,\n) -> Option<int> {\n  let mut result: Option<int> = None\n  for id in found.operands {\n    match evaluateClosedInt(context, id, depth + 1) {\n      case Some(value) => { result = Some(value) }\n      case None => ()\n    }\n  }\n  result\n}\n\nfunction evaluateClosedInt(\n  context: EmitterOperationCatalog,\n  wanted: string,\n  depth: int,\n) -> Option<int> {\n  if depth > CLOSED_INT_DEPTH_LIMIT {\n    return None\n  }\n  match operation(context, wanted) {\n    case None => None\n    case Some(found) => {\n      if found.kind == \"expression/integer\" {\n        return found.detail.toInt()\n      }\n      if found.kind == \"expression/unary\" {\n        return evaluateUnaryClosedInt(context, found, depth)\n      }\n      if found.kind == \"expression/binary\" {\n        return evaluateBinaryClosedInt(context, found, depth)\n      }\n      if found.kind == \"let\" ||\n        found.kind == \"constant\" ||\n        found.kind == \"expression/parenthesized\" ||\n        found.kind == \"expression/block\" ||\n        found.kind == \"module\" {\n        return evaluateSequenceClosedInt(context, found, depth)\n      }\n      None\n    }\n  }\n}\n\nfunction entryPreview(\n  modules: Array<Stage1Module>,\n  catalog: EmitterOperationCatalog,\n) -> Option<int> {\n  if catalog.values.length > ENTRY_PREVIEW_OPERATION_LIMIT {\n    return None\n  }\n  for module in modules {\n    if module.entry {\n      for id in module.operationIds {\n        match operation(catalog, id) {\n          case Some(found) => if found.kind == \"module\" {\n            return evaluateClosedInt(catalog, id, 0)\n          }\n          case None => ()\n        }\n      }\n    }\n  }\n  None\n}\n\nfunction renderRuntimeLeaves(leaves: Array<string>) -> string {\n  let mut rendered: Array<string> = []\n  for leaf in leaves {\n    rendered.push(\"{rustRaw(leaf)},\")\n  }\n  \"&[{rendered.join(\"\")}]\"\n}\n\nfunction render(response: Stage1Response) -> Result<string, string> {\n  let ir = jsonBoundary.stringify(EmitPayload {\n    schema: COMPILER_PAYLOAD_SCHEMA,\n    irSchema: STAGE1_IR_SCHEMA,\n    runtimeTemplate: COMPILER_RUNTIME_TEMPLATE,\n    sourceSetId: response.provenance.sourceSetId,\n    loweredModules: response.loweredModules,\n    loweredOperations: response.loweredOperations,\n  })?\n  let catalog = emitterOperationCatalog(response.loweredOperations)\n  let preview = match entryPreview(response.loweredModules, catalog) {\n    case Some(value) => \"Some({value}i64)\"\n    case None => \"None\"\n  }\n  let leaves = renderRuntimeLeaves(catalog.runtimeLeaves)\n  Ok(\n    \"// @generated by the Topaz compiler kernel; do not edit.\\n\" +\n    rustStringConstant(\n      \"TOPAZ_COMPILER_RUNTIME_REGISTRY_SCHEMA\",\n      COMPILER_RUNTIME_REGISTRY_SCHEMA,\n    ) +\n    rustStringConstant(\n      \"TOPAZ_COMPILER_RUNTIME_TEMPLATE\",\n      COMPILER_RUNTIME_TEMPLATE,\n    ) +\n    rustStringConstant(\"TOPAZ_COMPILER_IR_SCHEMA\", STAGE1_IR_SCHEMA) +\n    rustStringConstant(\n      \"TOPAZ_COMPILER_IR_PAYLOAD_SCHEMA\",\n      COMPILER_PAYLOAD_SCHEMA,\n    ) +\n    rustStringConstant(\n      \"TOPAZ_COMPILER_SOURCE_SET\",\n      response.provenance.sourceSetId,\n    ) +\n    rustStringConstant(\"TOPAZ_COMPILER_IR_JSON\", ir) +\n    \"pub const TOPAZ_COMPILER_RUNTIME_LEAVES: &[&str] = {leaves};\\n\" +\n    \"pub fn compiler_preview_i64() -> Option<i64> \\{ {preview} \\}\\n\",\n  )\n}\n\nexport function emitStep(\n  loweredBytes: Bytes,\n  maxGeneratedRustBytes: int,\n) -> Result<Bytes, string> {\n  let lowered = decodeStage1Response(loweredBytes.decodeUtf8()?)?\n  if lowered.status != \"completed\" {\n    return Ok(loweredBytes)\n  }\n  if lowered.generatedRust != \"\" {\n    return Err(\"Stage 1 emitter received pre-existing generated Rust\")\n  }\n  let generated = render(lowered)?\n  if generated.byteLength() > maxGeneratedRustBytes {\n    return Err(\n      \"Stage 1 generated Rust exceeds {maxGeneratedRustBytes} bytes\",\n    )\n  }\n  let response = Stage1Response {\n    ...lowered,\n    generatedRust: generated,\n  }\n  Ok((jsonBoundary.stringify(response)?).encodeUtf8())\n}\n\n// Real Rust source has a separate value boundary from emitStep's table carrier.\nexport function emitRust(output: LoweringOutput) -> Result<string, string> {\n  if output.unsupported.length > 0 {\n    return Err(output.unsupported.join(\"\\n\"))\n  }\n  emitProgram(output)\n}\n\nexport function emitRustWithDatabase(output: LoweringOutput, db: Database) -> Result<string, string> {\n  if output.unsupported.length > 0 { return Err(output.unsupported.join(\"\\n\")) }\n  emitProgramWithDatabase(output, db)\n}\n",
      "sourceSha256": "573001c265ddb1ea99a9108ea43ae0a4df56d347593998717c2adf9618a6e105"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/builtins.tpz",
      "language": "topaz",
      "bytes": 22086,
      "sha256": "1919c68bf5f07c5c7e88f1a2b83b448e230168b657b0ac7ef3ffa3bcd5be3575",
      "content": "// Runtime-callable static namespace members. Generic schema calls belong to\n// the type-directed surface and never enter this catalog.\nexport function staticBuiltin(namespace: string, member: string) -> string {\n  match staticSpec(namespace, member) {\n    case Some(spec) => spec.tag\n    case None => \"\"\n  }\n}\n\nexport function freeBuiltin(name: string) -> string {\n  match name {\n    case \"print\" => \"Print\"\n    case \"toInt\" => \"ToInt\"\n    case \"toIntRadix\" => \"ToIntRadix\"\n    case \"fromCodePoint\" => \"FromCodePoint\"\n    case \"toFloat\" => \"ToFloat\"\n    case \"input\" => \"Input\"\n    case \"map\" => \"MapFn\"\n    case \"filter\" => \"FilterFn\"\n    case \"reduce\" => \"ReduceFn\"\n    case \"open\" => \"Open\"\n    case \"assert\" => \"TestAssert\"\n    case _ => \"\"\n  }\n}\n\n// Runtime operations a generated std.lispex module names directly: the same\n// module and name pairs as the Rust emitter's `lispex_intrinsic_kind`.\nexport function lispexIntrinsic(module: string, name: string) -> string {\n  match \"{module}::{name}\" {\n    case \"std.fs::__stdReadText\" => \"FsReadText\"\n    case \"std.fs::__stdWriteText\" => \"FsWriteText\"\n    case \"std.fs::__stdReadBytes\" => \"FsReadBytes\"\n    case \"std.fs::__stdWriteBytes\" => \"FsWriteBytes\"\n    case \"std.fs::__stdList\" => \"FsList\"\n    case \"std.io::__stdWriteLine\" => \"Print\"\n    case \"std.io::__stdReadStdin\" => \"Input\"\n    case \"std.io::__stdOpen\" => \"Open\"\n    case \"std.json::__stdJsonParse\" => \"JsonParse\"\n    case \"std.json::__stdJsonStringify\" => \"JsonStringify\"\n    case \"std.json::__stdJsonParseAs\" => \"JsonParseAs\"\n    case \"std.csv::__stdCsvParse\" => \"CsvParse\"\n    case \"std.csv::__stdCsvParseWithHeader\" => \"CsvParseWithHeader\"\n    case \"std.csv::__stdCsvStringify\" => \"CsvStringify\"\n    case \"std.csv::__stdCsvStringifyWithHeader\" => \"CsvStringifyWithHeader\"\n    case \"std.toml::__stdTomlParse\" => \"TomlParse\"\n    case \"std.toml::__stdTomlStringify\" => \"TomlStringify\"\n    case \"std.toml::__stdTomlFromJson\" => \"TomlFromJson\"\n    case \"std.test::__stdAssert\" => \"TestAssert\"\n    case \"std.test::__stdAssertEq\" => \"TestAssertEq\"\n    case \"std.test::__stdAssertNe\" => \"TestAssertNe\"\n    case \"std.test::__stdAssertContains\" => \"TestAssertContains\"\n    case \"std.test::__stdAssertOk\" => \"TestAssertOk\"\n    case \"std.test::__stdAssertErr\" => \"TestAssertErr\"\n    case \"std.test::__stdAssertSome\" => \"TestAssertSome\"\n    case \"std.test::__stdAssertNone\" => \"TestAssertNone\"\n    case \"std.test::__stdAssertGolden\" => \"TestAssertGolden\"\n    case \"std.typeset::__lengthFromScaledPoints\" => \"LengthFromScaledPoints\"\n    case \"std.typeset::__lengthFromMilliPoints\" => \"LengthFromMilliPoints\"\n    case \"std.lispex.rules::__lispexRule\" => \"LispexRule\"\n    case \"std.lispex::__lispexValueFromCanonical\" => \"LispexValueFromCanonical\"\n    case \"std.lispex::__lispexCanonicalBytes\" => \"LispexCanonicalBytes\"\n    case \"std.lispex::__lispexDefaultLimits\" => \"LispexDefaultLimits\"\n    case \"std.lispex::__lispexInspectRule\" => \"LispexInspectRule\"\n    case \"std.lispex::__lispexEvaluate\" => \"LispexEvaluate\"\n    case \"std.lispex::__lispexEvaluateWithEvidence\" => \"LispexEvaluateWithEvidence\"\n    case \"std.lispex::__lispexConsumerArtifactFromBytes\" => \"LispexConsumerArtifactFromBytes\"\n    case \"std.lispex::__lispexConsumerArtifactBytes\" => \"LispexConsumerArtifactBytes\"\n    case \"std.lispex::__lispexPortableCoreBytes\" => \"LispexPortableCoreBytes\"\n    case \"std.lispex::__lispexInspectConsumerArtifact\" => \"LispexInspectConsumerArtifact\"\n    case \"std.lispex::__lispexVerifyConsumerArtifact\" => \"LispexVerifyConsumerArtifact\"\n    case \"std.lispex::__lispexFreshReplay\" => \"LispexFreshReplay\"\n    case _ => \"\"\n  }\n}\n\nexport record BuiltinSpec { tag: string, leaf: string, params: Array<string>, style: string, defaults: Array<string> }\n\nexport function staticSpec(namespace: string, member: string) -> Option<BuiltinSpec> {\n  match \"{namespace}.{member}\" {\n    case \"Math.sqrt\" => Some(BuiltinSpec { tag: \"MathSqrt\", leaf: \"builtin_math_sqrt\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.abs\" => Some(BuiltinSpec { tag: \"MathAbs\", leaf: \"builtin_math_abs\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.floor\" => Some(BuiltinSpec { tag: \"MathFloor\", leaf: \"builtin_math_floor\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.ceil\" => Some(BuiltinSpec { tag: \"MathCeil\", leaf: \"builtin_math_ceil\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.round\" => Some(BuiltinSpec { tag: \"MathRound\", leaf: \"builtin_math_round\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.sin\" => Some(BuiltinSpec { tag: \"MathSin\", leaf: \"builtin_math_sin\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.cos\" => Some(BuiltinSpec { tag: \"MathCos\", leaf: \"builtin_math_cos\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.tan\" => Some(BuiltinSpec { tag: \"MathTan\", leaf: \"builtin_math_tan\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.isNaN\" => Some(BuiltinSpec { tag: \"MathIsNaN\", leaf: \"builtin_math_is_nan\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.isFinite\" => Some(BuiltinSpec { tag: \"MathIsFinite\", leaf: \"builtin_math_is_finite\", params: [\"x\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.parseFloat\" => Some(BuiltinSpec { tag: \"MathParseFloat\", leaf: \"builtin_math_parse_float\", params: [\"s\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Math.min\" => Some(BuiltinSpec { tag: \"MathMin\", leaf: \"builtin_math_min\", params: [\"a\", \"b\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Math.max\" => Some(BuiltinSpec { tag: \"MathMax\", leaf: \"builtin_math_max\", params: [\"a\", \"b\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Bytes.empty\" => Some(BuiltinSpec { tag: \"BytesEmpty\", leaf: \"builtin_bytes_empty\", params: [], style: \"fallible\", defaults: [] })\n    case \"Bytes.encodeUtf8\" => Some(BuiltinSpec { tag: \"BytesEncodeUtf8\", leaf: \"builtin_bytes_encode_utf8\", params: [\"s\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Bytes.fromArray\" => Some(BuiltinSpec { tag: \"BytesFromArray\", leaf: \"builtin_bytes_from_array\", params: [\"values\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Bytes.fromHex\" => Some(BuiltinSpec { tag: \"BytesFromHex\", leaf: \"builtin_bytes_from_hex\", params: [\"s\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Bytes.fromBase64\" => Some(BuiltinSpec { tag: \"BytesFromBase64\", leaf: \"builtin_bytes_from_base64\", params: [\"s\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Bytes.concat\" => Some(BuiltinSpec { tag: \"BytesConcat\", leaf: \"builtin_bytes_concat\", params: [\"a\", \"b\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Encoding.utf8Encode\" => Some(BuiltinSpec { tag: \"EncodingUtf8Encode\", leaf: \"builtin_bytes_encode_utf8\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Encoding.utf8Decode\" => Some(BuiltinSpec { tag: \"EncodingUtf8Decode\", leaf: \"builtin_bytes_decode_utf8\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Encoding.hexEncode\" => Some(BuiltinSpec { tag: \"EncodingHexEncode\", leaf: \"builtin_bytes_to_hex\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Encoding.hexDecode\" => Some(BuiltinSpec { tag: \"EncodingHexDecode\", leaf: \"builtin_bytes_from_hex\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Encoding.base64Encode\" => Some(BuiltinSpec { tag: \"EncodingBase64Encode\", leaf: \"builtin_bytes_to_base64\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Encoding.base64Decode\" => Some(BuiltinSpec { tag: \"EncodingBase64Decode\", leaf: \"builtin_bytes_from_base64\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.gzipCompress\" => Some(BuiltinSpec { tag: \"CodecGzipCompress\", leaf: \"builtin_codec_gzip_compress\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.gzipDecompress\" => Some(BuiltinSpec { tag: \"CodecGzipDecompress\", leaf: \"builtin_codec_gzip_decompress\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.deflateCompress\" => Some(BuiltinSpec { tag: \"CodecDeflateCompress\", leaf: \"builtin_codec_deflate_compress\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.deflateFixedCompress\" => Some(BuiltinSpec { tag: \"CodecDeflateFixedCompress\", leaf: \"builtin_codec_deflate_fixed_compress\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.zlibFixedCompress\" => Some(BuiltinSpec { tag: \"CodecZlibFixedCompress\", leaf: \"builtin_codec_zlib_fixed_compress\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.reedSolomon255223Protect\" => Some(BuiltinSpec { tag: \"CodecReedSolomon255223Protect\", leaf: \"builtin_codec_reed_solomon_255_223_protect\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.deflateDecompress\" => Some(BuiltinSpec { tag: \"CodecDeflateDecompress\", leaf: \"builtin_codec_deflate_decompress\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.zstdDecompress\" => Some(BuiltinSpec { tag: \"CodecZstdDecompress\", leaf: \"builtin_codec_zstd_decompress\", params: [\"bytes\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Codec.zstdCompress\" => Some(BuiltinSpec { tag: \"CodecZstdCompress\", leaf: \"builtin_codec_zstd_compress\", params: [\"bytes\", \"level\"], style: \"fallible\", defaults: [\"\", \"Value::Int(3)\"] })\n    case \"Hash.sha256\" => Some(BuiltinSpec { tag: \"HashSha256\", leaf: \"builtin_hash_sha256\", params: [\"data\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Hash.sha512\" => Some(BuiltinSpec { tag: \"HashSha512\", leaf: \"builtin_hash_sha512\", params: [\"data\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Hash.hmacSha256\" => Some(BuiltinSpec { tag: \"HashHmacSha256\", leaf: \"builtin_hash_hmac_sha256\", params: [\"key\", \"message\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Hash.crc32\" => Some(BuiltinSpec { tag: \"HashCrc32\", leaf: \"builtin_hash_crc32\", params: [\"data\"], style: \"fallible\", defaults: [\"\"] })\n    case \"FS.readText\" => Some(BuiltinSpec { tag: \"FsReadText\", leaf: \"builtin_fs_read_text\", params: [\"path\"], style: \"sync-host\", defaults: [\"\"] })\n    case \"FS.writeText\" => Some(BuiltinSpec { tag: \"FsWriteText\", leaf: \"builtin_fs_write_text\", params: [\"path\", \"text\"], style: \"sync-host\", defaults: [\"\", \"\"] })\n    case \"FS.readBytes\" => Some(BuiltinSpec { tag: \"FsReadBytes\", leaf: \"builtin_fs_read_bytes\", params: [\"path\"], style: \"sync-host\", defaults: [\"\"] })\n    case \"FS.writeBytes\" => Some(BuiltinSpec { tag: \"FsWriteBytes\", leaf: \"builtin_fs_write_bytes\", params: [\"path\", \"bytes\"], style: \"sync-host\", defaults: [\"\", \"\"] })\n    case \"FS.list\" => Some(BuiltinSpec { tag: \"FsList\", leaf: \"builtin_fs_list\", params: [\"path\"], style: \"sync-host\", defaults: [\"\"] })\n    case \"Cli.hasFlag\" => Some(BuiltinSpec { tag: \"CliHasFlag\", leaf: \"builtin_cli_has_flag\", params: [\"args\", \"name\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Cli.option\" => Some(BuiltinSpec { tag: \"CliOption\", leaf: \"builtin_cli_option\", params: [\"args\", \"name\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Cli.options\" => Some(BuiltinSpec { tag: \"CliOptions\", leaf: \"builtin_cli_options\", params: [\"args\", \"name\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Cli.positionals\" => Some(BuiltinSpec { tag: \"CliPositionals\", leaf: \"builtin_cli_positionals\", params: [\"args\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Path.from\" => Some(BuiltinSpec { tag: \"PathFrom\", leaf: \"builtin_path_from\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Path.cwdRelative\" => Some(BuiltinSpec { tag: \"PathCwdRelative\", leaf: \"builtin_path_cwd_relative\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Path.project\" => Some(BuiltinSpec { tag: \"PathProject\", leaf: \"builtin_path_project\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Regex.compile\" => Some(BuiltinSpec { tag: \"RegexCompile\", leaf: \"builtin_regex_compile\", params: [\"pattern\"], style: \"fallible\", defaults: [\"\"] })\n    case \"CSV.parse\" => Some(BuiltinSpec { tag: \"CsvParse\", leaf: \"builtin_csv_parse\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"CSV.parseWithHeader\" => Some(BuiltinSpec { tag: \"CsvParseWithHeader\", leaf: \"builtin_csv_parse_with_header\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"CSV.stringify\" => Some(BuiltinSpec { tag: \"CsvStringify\", leaf: \"builtin_csv_stringify\", params: [\"rows\"], style: \"fallible\", defaults: [\"\"] })\n    case \"CSV.stringifyWithHeader\" => Some(BuiltinSpec { tag: \"CsvStringifyWithHeader\", leaf: \"builtin_csv_stringify_with_header\", params: [\"rows\", \"columns\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"TOML.parse\" => Some(BuiltinSpec { tag: \"TomlParse\", leaf: \"builtin_toml_parse\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"TOML.stringify\" => Some(BuiltinSpec { tag: \"TomlStringify\", leaf: \"builtin_toml_stringify\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"TOML.toJson\" => Some(BuiltinSpec { tag: \"TomlToJson\", leaf: \"builtin_toml_to_json\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"TOML.fromJson\" => Some(BuiltinSpec { tag: \"TomlFromJson\", leaf: \"builtin_toml_from_json\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"URL.parse\" => Some(BuiltinSpec { tag: \"UrlParse\", leaf: \"builtin_url_parse\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Date.fromYmd\" => Some(BuiltinSpec { tag: \"DateFromYmd\", leaf: \"builtin_date_from_ymd\", params: [\"year\", \"month\", \"day\"], style: \"fallible\", defaults: [\"\", \"\", \"\"] })\n    case \"Date.parseIso\" => Some(BuiltinSpec { tag: \"DateParseIso\", leaf: \"builtin_date_parse_iso\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"BigInt.fromInt\" => Some(BuiltinSpec { tag: \"BigIntFromInt\", leaf: \"builtin_bigint_from_int\", params: [\"n\"], style: \"fallible\", defaults: [\"\"] })\n    case \"BigInt.parse\" => Some(BuiltinSpec { tag: \"BigIntParse\", leaf: \"builtin_bigint_parse\", params: [\"text\", \"radix\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Decimal.fromInt\" => Some(BuiltinSpec { tag: \"DecimalFromInt\", leaf: \"builtin_decimal_from_int\", params: [\"n\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Decimal.parse\" => Some(BuiltinSpec { tag: \"DecimalParse\", leaf: \"builtin_decimal_parse\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Array.of\" => Some(BuiltinSpec { tag: \"ArrayOf\", leaf: \"Value::array\", params: [], style: \"variadic\", defaults: [] })\n    case \"Set.of\" => Some(BuiltinSpec { tag: \"SetOf\", leaf: \"builtin_set_of\", params: [], style: \"variadic-fallible\", defaults: [] })\n    case \"Map.new\" => Some(BuiltinSpec { tag: \"MapNew\", leaf: \"builtin_map_new\", params: [], style: \"raw\", defaults: [] })\n    case \"Map.ofEntries\" => Some(BuiltinSpec { tag: \"MapOfEntries\", leaf: \"builtin_map_of_entries\", params: [\"entries\"], style: \"fallible\", defaults: [\"\"] })\n    case \"JSON.stringify\" => Some(BuiltinSpec { tag: \"JsonStringify\", leaf: \"builtin_json_stringify\", params: [\"value\"], style: \"raw\", defaults: [\"\"] })\n    case \"JSON.parse\" => Some(BuiltinSpec { tag: \"JsonParse\", leaf: \"builtin_json_parse\", params: [\"text\"], style: \"fallible\", defaults: [\"\"] })\n    case \"ByteBuffer.allocate\" => Some(BuiltinSpec { tag: \"ByteBufferAllocate\", leaf: \"builtin_byte_buffer_allocate\", params: [\"length\", \"value\"], style: \"optional-second\", defaults: [\"\", \"Value::Int(0)\"] })\n    case \"ByteBuffer.fromBytes\" => Some(BuiltinSpec { tag: \"ByteBufferFromBytes\", leaf: \"builtin_byte_buffer_from_bytes\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Test.assert\" => Some(BuiltinSpec { tag: \"TestAssert\", leaf: \"builtin_test_assert\", params: [\"condition\", \"message\"], style: \"fallible\", defaults: [\"\", \"Value::str(\\\"assertion failed\\\")\"] })\n    case \"Test.assertEq\" => Some(BuiltinSpec { tag: \"TestAssertEq\", leaf: \"builtin_test_assert_eq\", params: [\"actual\", \"expected\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Test.assertNe\" => Some(BuiltinSpec { tag: \"TestAssertNe\", leaf: \"builtin_test_assert_ne\", params: [\"actual\", \"expected\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Test.assertContains\" => Some(BuiltinSpec { tag: \"TestAssertContains\", leaf: \"builtin_test_assert_contains\", params: [\"text\", \"needle\"], style: \"fallible\", defaults: [\"\", \"\"] })\n    case \"Test.assertOk\" => Some(BuiltinSpec { tag: \"TestAssertOk\", leaf: \"builtin_test_assert_ok\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Test.assertErr\" => Some(BuiltinSpec { tag: \"TestAssertErr\", leaf: \"builtin_test_assert_err\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Test.assertSome\" => Some(BuiltinSpec { tag: \"TestAssertSome\", leaf: \"builtin_test_assert_some\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Test.assertNone\" => Some(BuiltinSpec { tag: \"TestAssertNone\", leaf: \"builtin_test_assert_none\", params: [\"value\"], style: \"fallible\", defaults: [\"\"] })\n    case \"Test.assertGolden\" => Some(BuiltinSpec { tag: \"TestAssertGolden\", leaf: \"builtin_test_assert_golden\", params: [\"path\", \"actual\"], style: \"sync-host\", defaults: [\"\", \"\"] })\n    case _ => None\n  }\n}\n\n// Free scalar/host leaves retain their direct ABI. Callback builtins use\n// the existing callable runtime dispatch.\nexport function freeSpec(name: string) -> Option<BuiltinSpec> {\n  if name == \"assert\" { return staticSpec(\"Test\", \"assert\") }\n  let leaf = match name {\n    case \"print\" => \"builtin_print\"\n    case \"input\" => \"builtin_input\"\n    case \"open\" => \"builtin_open\"\n    case \"toInt\" => \"builtin_to_int\"\n    case \"toIntRadix\" => \"builtin_to_int_radix\"\n    case \"fromCodePoint\" => \"builtin_from_code_point\"\n    case \"toFloat\" => \"builtin_to_float\"\n    case _ => \"\"\n  }\n  if leaf == \"\" { return None }\n  let params = match name {\n    case \"print\" => [\"value\"]\n    case \"input\" => []\n    case \"open\" => [\"path\"]\n    case \"toInt\" => [\"text\"]\n    case \"toIntRadix\" => [\"text\", \"radix\"]\n    case _ => [\"n\"]\n  }\n  let style = if name == \"input\" { \"sync-host-raw\" } else if name == \"print\" || name == \"open\" { \"sync-host\" } else { \"fallible\" }\n  let mut defaults: Array<string> = []\n  for parameter in params { defaults.push(\"\") }\n  Some(BuiltinSpec { tag: freeBuiltin(name), leaf: leaf, params: params, style: style, defaults: defaults })\n}\n\n// Generated standard modules name the same leaves by their intrinsic tag.\n// The tag describes the operation, not a suspension effect: Host methods and\n// every operation in this catalog finish synchronously. JsonParseAs remains\n// on the type-directed schema path, which supplies its extra schema argument.\nexport function intrinsicSpec(tag: string) -> Option<BuiltinSpec> {\n  match tag {\n    case \"Print\" => return freeSpec(\"print\")\n    case \"Input\" => return freeSpec(\"input\")\n    case \"Open\" => return freeSpec(\"open\")\n    case \"FsReadText\" => return staticSpec(\"FS\", \"readText\")\n    case \"FsWriteText\" => return staticSpec(\"FS\", \"writeText\")\n    case \"FsReadBytes\" => return staticSpec(\"FS\", \"readBytes\")\n    case \"FsWriteBytes\" => return staticSpec(\"FS\", \"writeBytes\")\n    case \"FsList\" => return staticSpec(\"FS\", \"list\")\n    case \"JsonParse\" => return staticSpec(\"JSON\", \"parse\")\n    case \"JsonStringify\" => return staticSpec(\"JSON\", \"stringify\")\n    case \"CsvParse\" => return staticSpec(\"CSV\", \"parse\")\n    case \"CsvParseWithHeader\" => return staticSpec(\"CSV\", \"parseWithHeader\")\n    case \"CsvStringify\" => return staticSpec(\"CSV\", \"stringify\")\n    case \"CsvStringifyWithHeader\" => return staticSpec(\"CSV\", \"stringifyWithHeader\")\n    case \"TomlParse\" => return staticSpec(\"TOML\", \"parse\")\n    case \"TomlStringify\" => return staticSpec(\"TOML\", \"stringify\")\n    case \"TomlFromJson\" => return staticSpec(\"TOML\", \"fromJson\")\n    case \"TestAssert\" => return staticSpec(\"Test\", \"assert\")\n    case \"TestAssertEq\" => return staticSpec(\"Test\", \"assertEq\")\n    case \"TestAssertNe\" => return staticSpec(\"Test\", \"assertNe\")\n    case \"TestAssertContains\" => return staticSpec(\"Test\", \"assertContains\")\n    case \"TestAssertOk\" => return staticSpec(\"Test\", \"assertOk\")\n    case \"TestAssertErr\" => return staticSpec(\"Test\", \"assertErr\")\n    case \"TestAssertSome\" => return staticSpec(\"Test\", \"assertSome\")\n    case \"TestAssertNone\" => return staticSpec(\"Test\", \"assertNone\")\n    case \"TestAssertGolden\" => return staticSpec(\"Test\", \"assertGolden\")\n    case _ => ()\n  }\n  if tag == \"LengthFromScaledPoints\" || tag == \"LengthFromMilliPoints\" {\n    return Some(BuiltinSpec { tag: tag, leaf: \"length_constructor\", params: [\"value\"], style: \"length\", defaults: [\"\"] })\n  }\n  let operation = match tag {\n    case \"LispexRule\" => \"Rule\"\n    case \"LispexValueFromCanonical\" => \"ValueFromCanonical\"\n    case \"LispexCanonicalBytes\" => \"CanonicalBytes\"\n    case \"LispexDefaultLimits\" => \"DefaultLimits\"\n    case \"LispexInspectRule\" => \"InspectRule\"\n    case \"LispexEvaluate\" => \"Evaluate\"\n    case \"LispexEvaluateWithEvidence\" => \"EvaluateWithEvidence\"\n    case \"LispexConsumerArtifactFromBytes\" => \"ConsumerArtifactFromBytes\"\n    case \"LispexConsumerArtifactBytes\" => \"ConsumerArtifactBytes\"\n    case \"LispexPortableCoreBytes\" => \"PortableCoreBytes\"\n    case \"LispexInspectConsumerArtifact\" => \"InspectConsumerArtifact\"\n    case \"LispexVerifyConsumerArtifact\" => \"VerifyConsumerArtifact\"\n    case \"LispexFreshReplay\" => \"FreshReplay\"\n    case _ => \"\"\n  }\n  if operation == \"\" { return None }\n  let params = match operation {\n    case \"Rule\" => [\"name\"]\n    case \"ValueFromCanonical\" => [\"bytes\"]\n    case \"CanonicalBytes\" => [\"value\"]\n    case \"DefaultLimits\" => [\"rule\"]\n    case \"InspectRule\" => [\"rule\"]\n    case \"Evaluate\" => [\"rule\", \"input\", \"limits\"]\n    case \"EvaluateWithEvidence\" => [\"rule\", \"input\", \"limits\"]\n    case \"ConsumerArtifactFromBytes\" => [\"bytes\"]\n    case \"FreshReplay\" => [\"rule\", \"input\", \"artifact\"]\n    case _ => [\"artifact\"]\n  }\n  let mut defaults: Array<string> = []\n  for parameter in params { defaults.push(\"\") };\n  Some(BuiltinSpec { tag: tag, leaf: \"cx.lispex_application\", params: params, style: \"lispex:{operation}\", defaults: defaults })\n}\n",
      "sourceSha256": "1919c68bf5f07c5c7e88f1a2b83b448e230168b657b0ac7ef3ffa3bcd5be3575"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/emit.tpz",
      "language": "topaz",
      "bytes": 172795,
      "sha256": "4049685e410361675826d2a288370b23581e2466b2dfef14845997c16fd01ffc",
      "content": "import ir.model { SignatureId, EdgeRole }\nimport emitter.provenance { Provenance, rootFact }\nimport emitter.effects { FunctionEffect, newEffect, suspend, call, builtinMethodSuspension }\nimport std.json as jsonBoundary\n\nimport emitter.rust_text { rustStr }\nimport emitter.type_test { typeTest, childTypes, subtree, substitute, nominalIdentity }\nimport checker.members_capabilities { removedStandardStatic }\nimport emitter.builtins { BuiltinSpec, staticSpec, staticBuiltin, freeBuiltin, freeSpec, lispexIntrinsic, intrinsicSpec }\nimport emitter.ir { typeDeclaration,\n  hasProtocol,\n  hasImplementation,\n  qualifiedTypeDeclarations,\n  moduleDefaultContext,\n  Table, signatureOf,\n  opAt,\n  capturesOf,\n  fieldOf,\n  labelName,\n  children,\n  child,\n  optionalChild,\n  refusal,\n  spanOf,\n  declarationSpan,\n  rustName,\n}\nimport emitter.repr { Repr, operationReprOfCached, reprName, reprIdentity, isArray, isOption, isResult, isRecord, isEnum, isNewtype, isShape, isUntyped, isNever, elementRepr, reprAtCached, slotReprCached, rustType, isCopyRepr, boxed, unboxed, coerce, bare, sharedInit, sharedRead, sharedWrite, parameterGuard, variadicRepr, nominalRustName, resultParts, resultRepr }\nimport emitter.native_layout { layoutRepr }\nimport emitter.layout_plan { declarationLayout, layoutForAtoms, recordLayout, enumLayout, variantLayout }\nimport emitter.plan { LayoutPlan, LayoutVariant, CallAbi, Suspension, Storage, Ownership, directArguments, callPlanForOperation, planPosition, plannedSemanticRepr }\nimport emitter.match_plan { patternNominals, matchLayout, matchesVariant, exhaustiveSum }\nimport emitter.native_text { nativeTextMethod }\nimport emitter.native_newtype { newtypeBase }\nimport emitter.native_builtin { nativeBuiltinMethod }\nimport stage1_types { Stage1Operation }\nimport types { PreviewTypeAtom }\n\n// A name visible to the code being emitted.\n//   local     -> a Rust local `rust` of representation `repr`\n//   shared    -> a typed or boxed cell retained by closures and deferred actions\n//   localfn   -> a missing-aware local function cell, filled at its declaration\n//   global    -> a module-level cell `g.<rust>` (typed `Cell` or boxed `TopCell`)\n//   fn        -> a module-level function; `rust` keys `Ctx.fns`\n//   namespace -> an imported module; `rust` is its identity\nexport record Bind {\n  name: string,\n  kind: string,\n  rust: string,\n  repr: Repr,\n  mutable: bool,\n}\n\nexport record FnInfo {\n  id: string,\n  name: string,\n  body: string,\n  adapter: string,\n  cell: string,\n  paramNames: Array<string>,\n  paramReprs: Array<Repr>,\n  paramSpans: Array<string>,\n  defaultIds: Array<string>,\n  variadic: bool,\n  retRepr: Repr,\n  synchronous: bool,\n  boxed: bool = true,\n  abi: CallAbi = CallAbi.BoxedFuture,\n  recursive: bool = false,\n  fatFrame: bool = false,\n  cooperative: bool = false,\n  cooperativeAbi: CallAbi = CallAbi.ConcreteFuture,\n}\n\nexport record ModInfo {\n  identity: string,\n  cell: string,\n  binds: Array<Bind>,\n  exports: Array<string>,\n  generatedStd: bool,\n  root: string = \"\",\n  ordinal: int = -1,\n  functionsReady: bool = false,\n}\n\nexport record Ctx {\n  table: Table,\n  provenance: Provenance,\n  exitMoves: Map<string,bool>,\n  effect: FunctionEffect,\n  effects: Map<string,FunctionEffect>,\n  scope: Array<Bind>,\n  fns: Map<string, FnInfo>,\n  mods: Map<string, ModInfo>,\n  cellDecls: Array<string>,\n  items: Array<string>,\n  fnRet: Repr,\n  inConst: bool,\n  atModuleTop: bool,\n  loops: Array<LoopFrame>,\n  defers: Array<string>,\n  // The scheduler flavor is independent of a compatibility future boundary.\n  cooperative: bool = false,\n  asynchronous: bool = false,\n  initialized: Map<string,bool> = map {},\n}\n\nexport record LoopFrame {\n  id: string,\n  label: string,\n  repr: Repr,\n  cleanup: int,\n}\n\nexport record Code {\n  rs: string,\n  repr: Repr,\n}\n\n// Legacy callable values keep their future ABI. Ordinary functions drive\n// that boundary locally; only a scheduler flavor propagates suspension.\nexport function drive(ctx: Ctx, future: string) -> string {\n  if ctx.asynchronous { \"{future}.await\" } else { \"block_on({future})\" }\n}\n\nfunction loopCheckpoint(ctx: Ctx) -> string {\n  if ctx.cooperative { \"if cx.is_cooperative() \\{ checkpoint().await; \\}\" } else { \"\" }\n}\n\n// --- scope ---------------------------------------------------------------\n\nexport function has(list: Array<string>, value: string) -> bool {\n  for item in list {\n    if item == value {\n      return true\n    }\n  }\n  false\n}\n\nexport function pushBind(ctx: Ctx, bind: Bind) -> () {\n  let mut scope = ctx.scope\n  scope.push(bind)\n}\n\nexport function restoreScope(ctx: Ctx, mark: int) -> () {\n  let mut scope = ctx.scope\n  while scope.length > mark {\n    let _ = scope.pop()\n  }\n  ()\n}\n\nexport function lookup(ctx: Ctx, name: string) -> Option<Bind> {\n  let mut position = ctx.scope.length - 1\n  while position >= 0 {\n    let candidate = ctx.scope[position]\n    if candidate.name == name {\n      return Some(candidate)\n    }\n    position -= 1\n  }\n  None\n}\n\n// A fresh module-level cell `_c<n>` of the given representation.\nexport function newCell(ctx: Ctx, repr: Repr) -> string {\n  let name = \"_c{ctx.cellDecls.length}\"\n  let mut decls = ctx.cellDecls\n  if isCopyRepr(repr) {\n    decls.push(\"{name}: std::cell::Cell<Option<{rustType(repr)}>>|std::cell::Cell::new(None)\")\n  } else {\n    decls.push(\"{name}: TopCell|top_cell()\")\n  }\n  name\n}\n\nfunction fnInfo(ctx: Ctx, key: string, op: Stage1Operation) -> Result<FnInfo, string> {\n  match ctx.fns.get(key) {\n    case Some(info) => Ok(info)\n    case None => Err(refusal(\"ir function {key}\", op))\n  }\n}\n\nfunction modInfo(ctx: Ctx, identity: string, op: Stage1Operation) -> Result<ModInfo, string> {\n  match ctx.mods.get(identity) {\n    case Some(info) => Ok(info)\n    case None => Err(refusal(\"module {identity}\", op))\n  }\n}\n\nexport function modBind(info: ModInfo, name: string) -> Option<Bind> {\n  for bind in info.binds {\n    if bind.name == name {\n      return Some(bind)\n    }\n  }\n  None\n}\n\n// --- reads and writes of bindings ----------------------------------------\n\nexport function readBind(ctx: Ctx, bind: Bind, span: string, op: Stage1Operation) -> Result<Code, string> {\n  let planned = ctx.table.plan.values.get(planPosition(ctx.table.plan,op))\n  let exitMove = match planned {\n    case Some(value) => value.ownership == Ownership.ExitMove\n    case None => ctx.exitMoves.containsKey(op.id)\n  }\n  if bind.kind == \"builtin\" { return Ok(builtinCode(bind.rust)) }\n  if bind.kind == \"global\" && ctx.initialized.containsKey(bind.rust) {\n    // Initialization dominates this lexical read and no operation unbinds a\n    // cell. Keep a Rust invariant assertion, without a language fault/Span.\n    if isCopyRepr(bind.repr) {\n      return Ok(Code { rs:\"g.{bind.rust}.get().expect(\\\"dominating module initializer\\\")\", repr:bind.repr })\n    }\n    return Ok(Code { rs:\"\\{ let __value = g.{bind.rust}.borrow().as_ref().expect(\\\"dominating module initializer\\\").clone(); __value \\}\", repr:Repr.Value })\n  }\n  match bind.kind {\n    case \"localfn\" => Ok(Code { rs: \"top_cell_get(&{bind.rust}, {rustStr(bind.name)}, {span})?\", repr: Repr.Value })\n    case \"shared\" => Ok(Code { rs: sharedRead(bind.rust, bind.repr), repr: bind.repr })\n    case \"local\" => if isCopyRepr(bind.repr) || (exitMove && op.referenceDeclarationIdentity != \"\" && !ctx.table.capturedBindings.containsKey(op.referenceDeclarationIdentity)) {\n      Ok(Code { rs: bind.rust, repr: bind.repr })\n    } else {\n      Ok(Code { rs: \"{bind.rust}.clone()\", repr: bind.repr })\n    }\n    case \"global\" => if isCopyRepr(bind.repr) {\n      Ok(Code {\n        rs: \"__cell_get(&g.{bind.rust}, {rustStr(bind.name)}, {span})?\",\n        repr: bind.repr,\n      })\n    } else {\n      Ok(Code {\n        rs: \"top_cell_get(&g.{bind.rust}, {rustStr(bind.name)}, {span})?\",\n        repr: Repr.Value,\n      })\n    }\n    case \"fn\" => {\n      let info = fnInfo(ctx, bind.rust, op)?\n      Ok(Code {\n        rs: \"top_cell_get(&g.{info.cell}, {rustStr(bind.name)}, {span})?\",\n        repr: Repr.Value,\n      })\n    }\n    case \"namespace\" => {\n      let info = modInfo(ctx, bind.rust, op)?\n      Ok(Code {\n        rs: \"top_cell_get(&g.{info.cell}, {rustStr(bind.name)}, {span})?\",\n        repr: Repr.Value,\n      })\n    }\n    case _ => Err(refusal(\"binding {bind.kind}\", op))\n  }\n}\n\nexport function writeBind(bind: Bind, code: string, op: Stage1Operation) -> Result<string, string> {\n  match bind.kind {\n    case \"shared\" => Ok(sharedWrite(bind.rust, code, bind.repr))\n    case \"local\" => Ok(\"{bind.rust} = {bare(code)};\")\n    case \"global\" => if isCopyRepr(bind.repr) {\n      Ok(\"g.{bind.rust}.set(Some({bare(code)}));\")\n    } else {\n      Ok(\"top_cell_set(&g.{bind.rust}, {bare(boxed(code,bind.repr))});\")\n    }\n    case _ => Err(refusal(\"assignment to {bind.kind} binding\", op))\n  }\n}\n\n// The code in the operation's own representation when it carries a type.\nfunction finish(ctx: Ctx, code: Code, op: Stage1Operation) -> Result<Code, string> {\n  let target = plannedSemanticRepr(ctx.table.plan,op)\n  if isUntyped(target) || target == code.repr || isNever(code.repr) {\n    Ok(code)\n  } else {\n    Ok(Code { rs: into(code, target, op)?, repr: target })\n  }\n}\n\n// The code converted to `target` (explicit box/unbox boundary).\nexport function into(code: Code, target: Repr, op: Stage1Operation) -> Result<string, string> {\n  if isNever(code.repr) {\n    return Ok(code.rs)\n  }\n  match coerce(code.rs, code.repr, target, spanOf(op)) {\n    case Ok(converted) => Ok(converted)\n    case Err(message) => Err(\"{message} at {op.module}:{op.lo}-{op.hi}\")\n  }\n}\n\nfunction boxCode(code: Code) -> string {\n  if isNever(code.repr) || isUntyped(code.repr) {\n    bare(code.rs)\n  } else {\n    bare(boxed(code.rs, code.repr))\n  }\n}\n\n// --- expressions ----------------------------------------------------------\n\nexport function emitExpr(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  match op.kind {\n    case \"expression/integer\" => match op.detail.toInt() {\n      case Some(value) => finish(ctx, Code { rs: \"{value}i64\", repr: Repr.I64 }, op)\n      case None => Err(refusal(\"literal integer {op.detail}\", op))\n    }\n    case \"expression/float\" => finish(ctx, Code { rs: floatLiteral(ctx,op)?, repr: Repr.F64 }, op)\n    case \"expression/length\" => {\n      let parts=op.detail.split(\":\")\n      if parts.length != 2 || !has([\"Pt\",\"Mm\",\"Cm\",\"In\",\"Em\"],parts[0]) {return Err(refusal(\"invalid checked Length payload\",op))}\n      let ticks=match parts[1].toInt() {case Some(v)=>v;case None=>return Err(refusal(\"invalid checked Length ticks\",op))}\n      finish(ctx, Code {rs:\"length_value(Length \\{ unit: LengthUnit::{parts[0]}, ticks: {ticks}i64 \\})\",repr: Repr.Value},op)\n    }\n    case \"expression/boolean\" => if op.detail == \"true\" || op.detail == \"false\" {\n      finish(ctx, Code { rs: op.detail, repr: Repr.Bool }, op)\n    } else {\n      Err(refusal(\"literal boolean {op.detail}\", op))\n    }\n    case \"expression/unit\" => finish(ctx, Code { rs: \"()\", repr: Repr.Unit }, op)\n    case \"expression/null\" => finish(ctx, Code { rs: \"Value::Null\", repr: Repr.Value }, op)\n    case \"expression/string\" => finish(ctx, emitString(ctx, op)?, op)\n    case \"expression/identifier\" => emitIdentifier(ctx, op)\n    case \"expression/placeholder\" => match lookup(ctx, \"_\") {\n      case Some(bind) => readBind(ctx, bind, spanOf(op), op)\n      case None => Err(refusal(\"unbound pipe placeholder\", op))\n    }\n    case \"expression/parenthesized\" => finish(ctx, emitExpr(ctx, child(ctx.table, op, \"operand\")?)?, op)\n    case \"expression/binary\" => finish(ctx, emitBinary(ctx, op)?, op)\n    case \"expression/unary\" => finish(ctx, emitUnary(ctx, op)?, op)\n    case \"expression/array\" => finish(ctx, emitArray(ctx, op)?, op)\n    case \"expression/map\" => finish(ctx, emitMap(ctx, op)?, op)\n    case \"expression/set\" => {\n      let mut values: Array<string> = []\n      for element in children(ctx.table, op, \"elements\")? {\n        values.push(boxCode(emitExpr(ctx, element)?))\n      }\n      finish(ctx, Code { rs: \"builtin_set_of(vec![{values.join(\", \")}], {spanOf(op)})?\", repr: Repr.Value }, op)\n    }\n    case \"expression/record-literal\" => finish(ctx, emitRecord(ctx, op)?, op)\n    case \"expression/record-update\" => finish(ctx, emitRecordUpdate(ctx, op)?, op)\n    case \"expression/member\" => finish(ctx, emitMember(ctx, op)?, op)\n    case \"expression/index\" => finish(ctx, emitIndex(ctx, op)?, op)\n    case \"expression/optional-member\" => finish(ctx, emitOptionalMember(ctx, op)?, op)\n    case \"expression/call\" => finish(ctx, emitCall(ctx, op)?, op)\n    case \"expression/pipeline\" => finish(ctx, emitPipe(ctx, op)?, op)\n    case \"expression/concurrent\" => finish(ctx, emitConcurrent(ctx, op)?, op)\n    case \"expression/lambda\" => finish(ctx, emitLambda(ctx, op)?, op)\n    case \"expression/compose\" => {\n      let lhs = boxCode(emitExpr(ctx, child(ctx.table, op, \"left\")?)?)\n      let rhs = boxCode(emitExpr(ctx, child(ctx.table, op, \"right\")?)?)\n      finish(ctx, Code { rs: \"Value::Composed(Rc::new(({lhs}, {rhs})))\", repr: Repr.Value }, op)\n    }\n    case \"expression/if\" => emitIf(ctx, op)\n    case \"expression/match\" => emitMatch(ctx, op)\n    case \"expression/loop\" => emitLoop(ctx, op)\n    case \"expression/for\" => emitFor(ctx, op, true)\n    case \"expression/range\" => emitRange(ctx, op)\n    case \"expression/comprehension\" => emitComprehension(ctx, op)\n    case \"expression/result-propagation\" => finish(ctx, emitTry(ctx, op)?, op)\n    case \"expression/block\" => finish(ctx, emitBlock(ctx, op)?, op)\n    case \"expression/block-expression\" => finish(ctx, emitBlock(ctx, op)?, op)\n    case _ => Err(refusal(\"kind {op.kind}\", op))\n  }\n}\n\nfunction floatLiteral(ctx:Ctx,op: Stage1Operation) -> Result<string, string> {\n  if op.literalEncoding != \"checked-values/v1\" { return Err(refusal(\"float literal encoding\", op)) }\n  let bits = op.detail\n  if bits.encodeUtf8().length() != 16 { return Err(refusal(\"checked float bits\", op)) }\n  for scalar in bits.scalars() {\n    if !\"0123456789abcdef\".contains(scalar) { return Err(refusal(\"checked float bits\", op)) }\n  }\n  Ok(\"f64::from_bits(0x{bits}u64)\")\n}\n\nfunction emitIdentifier(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  if op.referenceIdentity.startsWith(\"builtin::\") {\n    if op.referenceIdentity == \"builtin::None\" {\n      let repr = operationReprOfCached(ctx.table.reprs, op, false)\n      if isOption(repr) { return finish(ctx, Code { rs:\"<{rustType(repr)}>::None\",repr:repr },op) }\n      return finish(ctx, Code { rs: \"Value::None\", repr: Repr.Value }, op)\n    }\n    let tag = if ctx.table.languageMode == \"topaz-5.21\" && (op.detail == \"toFloat\" || op.detail == \"toInt\" || op.detail == \"toIntRadix\" || op.detail == \"fromCodePoint\" || op.detail == \"map\" || op.detail == \"filter\" || op.detail == \"reduce\" || op.detail == \"print\" || op.detail == \"input\" || op.detail == \"open\" || op.detail == \"assert\") { \"\" } else { freeBuiltin(op.detail) }\n    if tag != \"\" { return finish(ctx, builtinCode(tag), op) }\n    let intrinsic = generatedIntrinsic(ctx, op)\n    if intrinsic != \"\" { return finish(ctx, builtinCode(intrinsic), op) }\n    return Err(refusal(\"builtin value {op.detail}\", op))\n  }\n  match lookup(ctx, op.detail) {\n    case Some(bind) => finish(ctx, readBind(ctx, bind, spanOf(op), op)?, op)\n    case None => Err(refusal(\"unresolved identifier {op.detail}\", op))\n  }\n}\n\n// A borrow is safe only for a local whose binding cannot be replaced by the\n// following operand. Shared/captured and mutable locals keep owned snapshots.\nfunction borrowCode(ctx: Ctx, op: Stage1Operation, code: Code) -> string {\n  if op.kind == \"expression/identifier\" {\n    match lookup(ctx,op.detail) {\n      case Some(bind) => if bind.kind == \"local\" && !bind.mutable && bind.repr == Repr.Value && code.repr == Repr.Value { return \"&{bind.rust}\" }\n      case None => ()\n    }\n  }\n  \"&({boxCode(code)})\"\n}\n\nfunction stringLiteral(ctx: Ctx, op: Stage1Operation) -> Result<Option<string>,string> {\n  if op.kind != \"expression/string\" { return Ok(None) }\n  let parts = op.detail.split(\"|\")\n  if parts.length == 2 && parts[0] != \"\" { return Ok(None) }\n  let mut text = \"\"\n  for id in op.operands {\n    let part = opAt(ctx.table,id)?\n    if part.kind != \"expression/string-text\" || part.literalEncoding != \"checked-values/v1\" { return Ok(None) }\n    text = text + part.detail\n  }\n  Ok(Some(text))\n}\n\nfunction emitString(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let pieces = op.detail.split(\"|\")\n  let tag = if pieces.length == 2 {\n    pieces[0]\n  } else {\n    \"\"\n  }\n  let mut texts: Array<string> = []\n  let mut current = \"\"\n  let mut values: Array<string> = []\n  let mut steps: Array<string> = []\n  let mut position = 0\n  let mut capacity = 0\n  for id in op.operands {\n    let part = opAt(ctx.table, id)?\n    let field = fieldOf(op.operandLabels[position])\n    if field == \"parts\" && part.kind == \"expression/string-text\" {\n      if part.literalEncoding != \"checked-values/v1\" { return Err(refusal(\"string literal encoding\", part)) }\n      let text = part.detail\n      current = current + text\n      capacity += text.encodeUtf8().length()\n      steps.push(\"__s.push_str({rustStr(text)});\")\n    } else if field == \"value\" {\n      let code = emitExpr(ctx, part)?\n      let value = boxCode(code)\n      texts.push(current)\n      current = \"\"\n      values.push(value)\n      if code.repr == Repr.Text {\n        steps.push(\"({code.rs}).render_append(&mut __s);\")\n      } else { steps.push(\"render_append({borrowCode(ctx,part,code)}, &mut __s);\") }\n    } else {\n      return Err(refusal(\"shape string part {field}\", op))\n    }\n    position += 1\n  }\n  texts.push(current)\n  if tag != \"\" {\n    let mut parts: Array<string> = []\n    for text in texts {\n      parts.push(\"{rustStr(text)}.to_string()\")\n    }\n    return Ok(Code {\n      rs: \"make_template({rustStr(tag)}.to_string(), vec![{parts.join(\", \")}], vec![{values.join(\", \")}])\",\n      repr: Repr.Value,\n    })\n  }\n  if values.length == 0 {\n    Ok(Code { rs: \"NativeText::Shared(Rc::from({rustStr(texts.join(\"\"))}))\", repr: Repr.Text })\n  } else {\n    Ok(Code {\n      rs: \"\\{ let mut __s = String::with_capacity({capacity}); {steps.join(\" \")} NativeText::owned(__s) \\}\",\n      repr: Repr.Text,\n    })\n  }\n}\n\nfunction binaryName(detail: string) -> string {\n  match detail {\n    case \"add\" => \"Add\"\n    case \"subtract\" => \"Sub\"\n    case \"multiply\" => \"Mul\"\n    case \"divide\" => \"Div\"\n    case \"remainder\" => \"Rem\"\n    case \"power\" => \"Pow\"\n    case \"less-than\" => \"Lt\"\n    case \"less-or-equal\" => \"Le\"\n    case \"greater-than\" => \"Gt\"\n    case \"greater-or-equal\" => \"Ge\"\n    case \"equal\" => \"Eq\"\n    case \"not-equal\" => \"Ne\"\n    case \"in\" => \"In\"\n    case \"and\" => \"And\"\n    case \"or\" => \"Or\"\n    case \"coalesce\" => \"Coalesce\"\n    case _ => \"\"\n  }\n}\n\nfunction intLeaf(detail: string) -> string {\n  match detail {\n    case \"add\" => \"int_add\"\n    case \"subtract\" => \"int_sub\"\n    case \"multiply\" => \"int_mul\"\n    case \"divide\" => \"int_div\"\n    case \"remainder\" => \"int_rem\"\n    case \"power\" => \"int_pow\"\n    case _ => \"\"\n  }\n}\n\nfunction isOrdering(detail: string) -> bool {\n  detail == \"less-than\" || detail == \"less-or-equal\" || detail == \"greater-than\" ||\n    detail == \"greater-or-equal\"\n}\n\n// A faulting leaf; inside a top-level `const` the fault is reframed as the\n// constant-expression error the interpreter's const pass reports.\nfunction checked(ctx: Ctx, leaf: string, span: string) -> string {\n  if ctx.inConst {\n    \"__cg({leaf}, {span})?\"\n  } else {\n    \"{leaf}?\"\n  }\n}\n\n// The arithmetic/comparison core shared by binary expressions and compound\n// assignment. Typed rows of the representation table use the checked scalar\n// leaves of `topaz_value`; every other pairing goes through the boxed leaf.\nfunction arithmetic(\n  ctx: Ctx,\n  detail: string,\n  left: Code,\n  right: Code,\n  span: string,\n  op: Stage1Operation,\n) -> Result<Code, string> {\n  let name = binaryName(detail)\n  if name == \"\" || name == \"And\" || name == \"Or\" || name == \"Coalesce\" {\n    return Err(refusal(\"operator {detail}\", op))\n  }\n  if detail == \"add\" && left.repr == Repr.Text && right.repr == Repr.Text {\n    return Ok(Code { rs:checked(ctx,\"({left.rs}).added({right.rs}, {span})\",span), repr: Repr.Text })\n  }\n  if isOrdering(detail) && left.repr == Repr.Text && right.repr == Repr.Text {\n    let operator = match detail { case \"less-than\" => \"<\"; case \"less-or-equal\" => \"<=\"; case \"greater-than\" => \">\"; case _ => \">=\" }\n    let fallback = unboxed(checked(ctx,\"binary_value(BinaryOp::{name}, NativeValue::into_value(__left), NativeValue::into_value(__right), {span})\",span),Repr.Bool,span)\n    return Ok(Code { rs:\"\\{ let __left = {left.rs}; let __right = {right.rs}; match __left.with_str(|__a| __right.with_str(|__b| __a {operator} __b)).flatten() \\{ Some(__ordered) => __ordered, None => \\{ {fallback} \\} \\} \\}\",repr:Repr.Bool })\n  }\n  if left.repr == Repr.BigInt && right.repr == Repr.BigInt {\n    if has([\"add\",\"subtract\",\"multiply\"],detail) {\n      return Ok(Code { rs:checked(ctx,\"({left.rs}).arithmetic({right.rs}, BinaryOp::{name}, {span})\",span),repr: Repr.BigInt })\n    }\n    if isOrdering(detail) || detail == \"equal\" || detail == \"not-equal\" {\n      return Ok(Code { rs:checked(ctx,\"({left.rs}).compare({right.rs}, BinaryOp::{name}, {span})\",span),repr: Repr.Bool })\n    }\n  }\n  if left.repr == Repr.I64 && right.repr == Repr.I64 {\n    let leaf = intLeaf(detail)\n    if leaf != \"\" {\n      return Ok(Code { rs: checked(ctx, \"{leaf}({left.rs}, {right.rs}, {span})\", span), repr: Repr.I64 })\n    }\n    if isOrdering(detail) {\n      return Ok(Code { rs: \"int_cmp(BinaryOp::{name}, {left.rs}, {right.rs})\", repr: Repr.Bool })\n    }\n  }\n  if left.repr == Repr.F64 && right.repr == Repr.F64 {\n    if detail == \"add\" || detail == \"subtract\" || detail == \"multiply\" || detail == \"divide\" ||\n      detail == \"power\" {\n      return Ok(Code { rs: \"float_arith(BinaryOp::{name}, {left.rs}, {right.rs})\", repr: Repr.F64 })\n    }\n    if isOrdering(detail) {\n      return Ok(Code { rs: \"float_cmp(BinaryOp::{name}, {left.rs}, {right.rs})\", repr: Repr.Bool })\n    }\n  }\n  if left.repr == right.repr && (left.repr == Repr.I64 || left.repr == Repr.F64 || left.repr == Repr.Bool) {\n    if detail == \"equal\" {\n      return Ok(Code { rs: \"(({left.rs}) == ({right.rs}))\", repr: Repr.Bool })\n    }\n    if detail == \"not-equal\" {\n      return Ok(Code { rs: \"(({left.rs}) != ({right.rs}))\", repr: Repr.Bool })\n    }\n  }\n  Ok(Code {\n    rs: checked(ctx, \"binary_value(BinaryOp::{name}, {boxCode(left)}, {boxCode(right)}, {span})\", span),\n    repr: Repr.Value,\n  })\n}\n\nfunction emitBinary(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let leftOp = child(ctx.table, op, \"left\")?\n  let rightOp = child(ctx.table, op, \"right\")?\n  let left = emitExpr(ctx, leftOp)?\n  if (op.detail == \"and\" || op.detail == \"or\") && left.repr == Repr.Bool {\n    let fact=rootFact(ctx.provenance,leftOp.id)\n    if (op.detail == \"and\" && fact == \"bool:false\") || (op.detail == \"or\" && fact == \"bool:true\") {\n      return Ok(Code { rs:left.rs,repr: Repr.Bool })\n    }\n    if (op.detail == \"and\" && fact == \"bool:true\") || (op.detail == \"or\" && fact == \"bool:false\") {\n      let right=emitExpr(ctx,rightOp)?\n      if right.repr == Repr.Bool { return Ok(Code { rs:\"\\{ let _ = {left.rs}; {right.rs} \\}\",repr: Repr.Bool }) }\n    }\n  }\n  let right = emitExpr(ctx, rightOp)?\n  let span = spanOf(op)\n  if (op.detail == \"equal\" || op.detail == \"not-equal\") && !(isCopyRepr(left.repr) && left.repr == right.repr) {\n    if left.repr == Repr.Text && right.repr == Repr.Text {\n      let mut call = \"({left.rs}).equal(&({right.rs}), {span})\"\n      match stringLiteral(ctx,rightOp)? {\n        case Some(text) => { call = \"({left.rs}).equal_literal({rustStr(text)}, {span})\" }\n        case None => ()\n      }\n      let result = checked(ctx,call,span)\n      return Ok(Code { rs:if op.detail == \"not-equal\" { \"(!({result}))\" } else { result }, repr: Repr.Bool })\n    }\n    if left.repr == right.repr && (isEnum(left.repr) || isNewtype(left.repr) || isOption(left.repr) || isResult(left.repr) || left.repr == Repr.BigInt) {\n      let call = if left.repr == Repr.BigInt {\n        \"({left.rs}).compare({right.rs}, BinaryOp::Eq, {span})\"\n      } else { \"({left.rs}).equal(&({right.rs}), {span})\" }\n      let result = checked(ctx,call,span)\n      return Ok(Code { rs:if op.detail == \"not-equal\" { \"(!({result}))\" } else { result },repr: Repr.Bool })\n    }\n    let mut call = \"native_equal({borrowCode(ctx,leftOp,left)}, {borrowCode(ctx,rightOp,right)}, {span})\"\n    match stringLiteral(ctx,rightOp)? {\n      case Some(text) => { call = \"native_string_equal({borrowCode(ctx,leftOp,left)}, {rustStr(text)}, {span})\" }\n      case None => match stringLiteral(ctx,leftOp)? {\n        case Some(text) => { call = \"native_string_equal({borrowCode(ctx,rightOp,right)}, {rustStr(text)}, {span})\" }\n        case None => ()\n      }\n    }\n    let result = checked(ctx,call,span)\n    return Ok(Code { rs: if op.detail == \"not-equal\" { \"(!({result}))\" } else { result }, repr: Repr.Bool })\n  }\n  if op.detail == \"and\" || op.detail == \"or\" {\n    if left.repr == Repr.Bool && right.repr == Repr.Bool {\n      if op.detail == \"and\" {\n        return Ok(Code { rs: \"(if {bare(left.rs)} \\{ {bare(right.rs)} \\} else \\{ false \\})\", repr: Repr.Bool })\n      }\n      return Ok(Code { rs: \"(if {bare(left.rs)} \\{ true \\} else \\{ {bare(right.rs)} \\})\", repr: Repr.Bool })\n    }\n  }\n  if op.detail == \"coalesce\" && isOption(left.repr) {\n    let repr = operationReprOfCached(ctx.table.reprs, op, false)\n    let target = if repr == Repr.Untyped { Repr.Value } else { repr }\n    let element = sumPayloadRepr(ctx,leftOp,left.repr,\"Some\",elementRepr(left.repr))\n    let payload = into(Code { rs:\"__payload\",repr:element },target,op)?\n    let dynamic = into(Code { rs:\"__value\",repr: Repr.Value },target,op)?\n    let fallback = into(right,target,op)?\n    return Ok(Code { rs:\"match {left.rs} \\{ NativeOption::Some(__payload) => {payload}, NativeOption::None => {fallback}, NativeOption::Dynamic(__dynamic) => match short_circuit_lhs(__dynamic, BinaryOp::Coalesce, {span})? \\{ Some(__value) => {dynamic}, None => {fallback} \\} \\}\",repr:target })\n  }\n  if op.detail == \"and\" || op.detail == \"or\" || op.detail == \"coalesce\" {\n    let name = binaryName(op.detail)\n    return Ok(Code {\n      rs: \"(match short_circuit_lhs({boxCode(left)}, BinaryOp::{name}, {span})? \\{ Some(__v) => __v, None => {boxCode(right)} \\})\",\n      repr: Repr.Value,\n    })\n  }\n  arithmetic(ctx, op.detail, left, right, span, op)\n}\n\nfunction emitUnary(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let operand = emitExpr(ctx, child(ctx.table, op, \"operand\")?)?\n  let span = spanOf(op)\n  match op.detail {\n    case \"minus\" => if operand.repr == Repr.I64 {\n      Ok(Code { rs: checked(ctx, \"int_neg({operand.rs}, {span})\", span), repr: Repr.I64 })\n    } else if operand.repr == Repr.F64 {\n      Ok(Code { rs: \"(-{operand.rs})\", repr: Repr.F64 })\n    } else {\n      Ok(Code {\n        rs: checked(ctx, \"unary_value(UnaryOp::Minus, {boxCode(operand)}, {span})\", span),\n        repr: Repr.Value,\n      })\n    }\n    case \"not\" => if operand.repr == Repr.Bool {\n      Ok(Code { rs: \"(!{operand.rs})\", repr: Repr.Bool })\n    } else {\n      Ok(Code {\n        rs: checked(ctx, \"unary_value(UnaryOp::Not, {boxCode(operand)}, {span})\", span),\n        repr: Repr.Value,\n      })\n    }\n    case \"plus\" => if operand.repr == Repr.I64 || operand.repr == Repr.F64 {\n      Ok(operand)\n    } else {\n      Ok(Code {\n        rs: checked(ctx, \"unary_value(UnaryOp::Plus, {boxCode(operand)}, {span})\", span),\n        repr: Repr.Value,\n      })\n    }\n    case _ => Err(refusal(\"operator unary {op.detail}\", op))\n  }\n}\n\nfunction emitArray(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let repr = operationReprOfCached(ctx.table.reprs, op, false)\n  let mut simple = isArray(repr)\n  for label in op.operandLabels { if label.contains(\"/spread[\") { simple = false } }\n  if simple {\n    let mut typed:Array<string> = []\n    let element = elementRepr(repr)\n    let mut reusable=ctx.provenance.readonlyLiterals.containsKey(op.id)\n    for id in op.operands {\n      let value=opAt(ctx.table,id)?\n      if !has([\"expression/integer\",\"expression/boolean\",\"expression/float\"],value.kind) {\n        if stringLiteral(ctx,value)? == None { reusable=false }\n      }\n      typed.push(into(emitExpr(ctx,value)?,element,op)?)\n    }\n    let value=\"NativeArray::<{rustType(element)}>::new(vec![{typed.join(\", \")}])\"\n    return Ok(Code { rs:if reusable { \"\\{ thread_local! \\{ static __LITERAL: NativeArray<{rustType(element)}> = {value}; \\} __LITERAL.with(Clone::clone) \\}\" } else { value },repr:repr })\n  }\n  let mut values: Array<string> = []\n  let mut steps: Array<string> = []\n  let mut spread = false\n  let mut position = 0\n  for id in op.operands {\n    let element = opAt(ctx.table, id)?\n    let label = op.operandLabels[position]\n    let value = boxCode(emitExpr(ctx, element)?)\n    if label.contains(\"/spread[\") {\n      spread = true\n      steps.push(\"array_spread_extend(&mut __acc, {value}, {spanOf(op)})?;\")\n    } else if fieldOf(label) == \"elements\" {\n      values.push(value)\n      steps.push(\"__acc.push({value});\")\n    } else {\n      return Err(refusal(\"shape array element {label}\", op))\n    }\n    position += 1\n  }\n  if spread {\n    Ok(Code {\n      rs: \"\\{ let mut __acc = Vec::new(); {steps.join(\" \")} Value::array(__acc) \\}\",\n      repr: Repr.Value,\n    })\n  } else {\n    Ok(Code { rs: \"Value::array(vec![{values.join(\", \")}])\", repr: Repr.Value })\n  }\n}\n\nfunction emitMap(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let mut pairs: Array<string> = []\n  let mut key = \"\"\n  let mut position = 0\n  for id in op.operands {\n    let part = opAt(ctx.table, id)?\n    let field = fieldOf(op.operandLabels[position])\n    let value = boxCode(emitExpr(ctx, part)?)\n    if field == \"key\" {\n      key = value\n    } else if field == \"value\" {\n      pairs.push(\"({key}, {value})\")\n    } else {\n      return Err(refusal(\"shape map entry {field}\", op))\n    }\n    position += 1\n  }\n  Ok(Code { rs: \"builtin_map_of(vec![{pairs.join(\", \")}], {spanOf(op)})?\", repr: Repr.Value })\n}\n\nexport function nominalHead(ctx: Ctx, op: Stage1Operation) -> Result<Option<Stage1Operation>, string> {\n  if op.kind == \"expression/member\" {\n    let object = child(ctx.table, op, \"object\")?\n    let namespace = match namespaceOf(ctx, object) {\n      case Some(found) => found\n      case None => return Ok(None)\n    }\n    for declaration in qualifiedTypeDeclarations(ctx.table,namespace.rust,op.detail) {\n      let parent = opAt(ctx.table, declaration.parentId)?\n      if parent.kind == \"export\" { return Ok(Some(declaration)) }\n    }\n    return Ok(None)\n  }\n  if op.kind != \"expression/identifier\" { return Ok(None) }\n  match lookup(ctx, op.detail) {\n    case Some(_) => return Ok(None)\n    case None => ()\n  }\n  typeDeclaration(ctx.table, op.id, op.detail)\n}\n\nfunction methodIdentity(ctx: Ctx, decl: Stage1Operation) -> string {\n  if hasImplementation(ctx.table,decl.module,decl.typeDefinition[0].name) {\n    return \"Some({rustStr(decl.typeDefinition[0].identity)})\"\n  }\n  \"None::<&str>\"\n}\n\nfunction emitEnum(ctx: Ctx, op: Stage1Operation, decl: Stage1Operation, name: string, args: Array<Stage1Operation>) -> Result<Code, string> {\n  let root = decl.typeDefinition[0]\n  let layout = declarationLayout(ctx.table,decl)\n  if isEnum(layout.repr) {\n    for variant in layout.variants {\n      if variant.name != name { continue }\n      if variant.payloads.length != args.length { return Err(refusal(\"enum payload arity\", op)) }\n      let mut values:Array<string> = []\n      let mut position = 0\n      for payload in variant.payloads {\n        values.push(into(emitExpr(ctx,args[position])?,payload.value.repr,op)?)\n        position += 1\n      }\n      let suffix = if values.length == 0 { \"\" } else { \"({values.join(\", \")})\" }\n      let native = layout.repr\n      return Ok(Code { rs:\"<{rustType(native)}>::new({nominalRustName(native)}::V{variant.variantIndex}{suffix})\", repr:native })\n    }\n    return Err(refusal(\"enum variant {name}\", op))\n  }\n  for index in childTypes(decl.typeDefinition, 0) {\n    let variant = decl.typeDefinition[index]\n    if variant.field != \"variants\" || variant.name != name { continue }\n    if childTypes(decl.typeDefinition, index).length != args.length { return Err(refusal(\"enum payload arity\", op)) }\n    let mut values: Array<string> = []\n    for arg in args { values.push(boxCode(emitExpr(ctx, arg)?)) }\n    let method = methodIdentity(ctx, decl)\n    return Ok(Code { rs: \"Value::Enum \\{ enum_id: Rc::from({rustStr(root.name)}), declaration_identity: Some(Rc::from({rustStr(root.identity)})), method_identity: ({method}).map(Rc::from), variant: Rc::from({rustStr(name)}), variant_index: {variant.index}, payloads: Rc::from(vec![{values.join(\", \")}]) \\}\", repr: Repr.Value })\n  }\n  Err(refusal(\"enum variant {name}\", op))\n}\n\n// Option/Result construction and consumption use the same typed payload\n// plan as match/layout. Historical wire input without a checked atom tree\n// retains the existing Repr projection; neither path admits an external value.\nexport function sumPayloadRepr(ctx: Ctx, op: Stage1Operation, repr: Repr, name: string, fallback: Repr) -> Repr {\n  let layout = match matchLayout(ctx.table,op,repr) { case Some(found) => found; case None => return fallback }\n  let variant = match variantLayout(layout,name) { case Some(found) => found; case None => return fallback }\n  if variant.payloads.length == 1 { variant.payloads[0].value.repr } else { fallback }\n}\n\n// Defaults belong to their declaration environment, even when the construction\n// occurs in a function that shadows a module binding.\nexport function defaultContext(ctx: Ctx, decl: Stage1Operation) -> Ctx {\n  if !moduleDefaultContext(ctx.table,decl.parentId) { return ctx }\n  match ctx.mods.get(decl.module) {\n    case Some(info) => Ctx { ...ctx, scope: info.binds }\n    case None => ctx\n  }\n}\n\nexport function recordDefault(ctx: Ctx, decl: Stage1Operation, ordinal: int) -> Result<Option<Stage1Operation>, string> {\n  let mut index = 0\n  for label in decl.operandLabels {\n    if fieldOf(label) == \"default\" && label.contains(\"/fields:{ordinal}/\") {\n      return Ok(Some(opAt(ctx.table, decl.operands[index])?))\n    }\n    index += 1\n  }\n  Ok(None)\n}\n\nfunction emitRecordUpdate(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let base = child(ctx.table, op, \"base\")?\n  let declaration = nominalHead(ctx, base)?\n  match declaration {\n    case Some(decl) => if decl.kind == \"record\" && layoutRepr(decl.typeDefinition) != Repr.Untyped {\n      match optionalChild(ctx.table,op,\"spread\")? {\n        case None => return emitNativeRecord(ctx,op,decl)\n        case Some(seed) => if operationReprOfCached(ctx.table.reprs,seed,false) == layoutRepr(decl.typeDefinition) {\n          return emitNativeRecordSpread(ctx,op,decl,seed)\n        }\n      }\n    }\n    case None => {\n      let repr = operationReprOfCached(ctx.table.reprs,base,false)\n      if isShape(repr) && operationReprOfCached(ctx.table.reprs,op,false) == repr {\n        match recordLayout(ctx.table,repr) {\n          case Some(layout) => return emitNativeShapeUpdate(ctx,op,base,layout)\n          case None => ()\n        }\n      }\n    }\n  }\n  let mut lines: Array<string> = []\n  let mut names: Array<string> = []\n  let mut fields: Array<string> = []\n  let mut spread = false\n  match declaration {\n    case Some(decl) => if decl.kind == \"record\" {\n      match optionalChild(ctx.table, op, \"spread\")? {\n        case Some(seed) => {\n          let mut required: Array<string> = []\n          for atom in decl.typeDefinition { if atom.parent == 0 && atom.field == \"fields\" { required.push(rustStr(atom.edgeName)) } }\n          let root = decl.typeDefinition[0]\n          lines.push(\"let __seed = nominal_spread_base_required({boxCode(emitExpr(ctx, seed)?)}, {rustStr(root.name)}, Some({rustStr(root.identity)}), &[{required.join(\", \")}], {spanOf(op)})?;\")\n          spread = true\n        }\n        case None => ()\n      }\n    }\n    case None => lines.push(\"let __base = record_update_base({boxCode(emitExpr(ctx, base)?)}, {spanOf(op)})?;\")\n  }\n  let mut index = 0\n  for label in op.operandLabels {\n    if fieldOf(label) == \"value\" && label.startsWith(\"field-initializer[\") {\n      let name = labelName(label)\n      let slot = \"__field{names.length}\"\n      lines.push(\"let {slot} = {boxCode(emitExpr(ctx, opAt(ctx.table, op.operands[index])?)?)};\")\n      names.push(name)\n      fields.push(slot)\n    }\n    index += 1\n  }\n  let mut pairs: Array<string> = []\n  match declaration {\n    case Some(decl) => {\n      let root = decl.typeDefinition[0]\n      for atom in decl.typeDefinition {\n        if atom.parent != 0 || atom.field != \"fields\" { continue }\n        let mut value = \"\"\n        let mut slot = 0\n        for name in names {\n          if name == atom.edgeName { value = \"{fields[slot]}.clone()\" }\n          slot += 1\n        }\n        if value == \"\" && spread {\n          value = \"nominal_record_field_required(&__seed, {rustStr(root.name)}, {rustStr(atom.edgeName)}, {spanOf(op)})?\"\n        }\n        if value == \"\" {\n          match recordDefault(ctx, decl, atom.index)? {\n            case Some(default) => {\n              value = \"__default{atom.index}\"\n              lines.push(\"let {value} = {boxCode(emitExpr(defaultContext(ctx, decl), default)?) };\")\n            }\n            case None => return Err(refusal(\"missing record field {root.name}.{atom.edgeName}\", op))\n          }\n        }\n        pairs.push(\"(Rc::from({rustStr(atom.edgeName)}), {value})\")\n      }\n      lines.push(\"Value::nominal_record_with_identities({rustStr(root.name)}, {rustStr(root.identity)}, {methodIdentity(ctx, decl)}, vec![{pairs.join(\", \")}])\")\n    }\n    case None => {\n      let mut slot = 0\n      for name in names { pairs.push(\"({rustStr(name)}.to_string(), {fields[slot]})\"); slot += 1 }\n      lines.push(\"record_update_merge(__base, vec![{pairs.join(\", \")}], {spanOf(op)})?\")\n    }\n  }\n  Ok(Code { rs: \"\\{ {lines.join(\" \")} \\}\", repr: Repr.Value })\n}\n\n// Emit replacement expressions once and in source order. Reuse only their\n// local names in the concrete/dynamic branches; discovery does not allocate\n// another set of cells/scopes or evaluate a replacement twice.\nrecord RecordUpdates { lines:Array<string>, names:Array<string>, values:Array<Code> }\n\nfunction recordUpdates(ctx:Ctx,op:Stage1Operation) -> Result<RecordUpdates,string> {\n  let mut lines:Array<string> = []\n  let mut names:Array<string> = []\n  let mut values:Array<Code> = []\n  let mut position = 0\n  for label in op.operandLabels {\n    if fieldOf(label) == \"value\" && label.startsWith(\"field-initializer[\") {\n      let code = emitExpr(ctx,opAt(ctx.table,op.operands[position])?)?\n      let local = \"__field{names.length}\"\n      lines.push(\"let {local} = {bare(code.rs)};\")\n      names.push(labelName(label))\n      values.push(Code { rs:local, repr:code.repr })\n    }\n    position += 1\n  }\n  Ok(RecordUpdates { lines:lines, names:names, values:values })\n}\n\nfunction replacement(updates:RecordUpdates,name:string) -> Option<Code> {\n  let mut found:Option<Code> = None\n  let mut index = 0\n  for candidate in updates.names {\n    if candidate == name { found = Some(updates.values[index]) }\n    index += 1\n  }\n  found\n}\n\n// Repacking must not introduce an eager scalar/type check for a replacement\n// which the old Value record would retain until consumption.\nfunction updatesFit(layout:LayoutPlan,updates:RecordUpdates) -> bool {\n  let mut index = 0\n  for name in updates.names {\n    let mut found = false\n    for field in layout.fields {\n      if field.name == name {\n        found = true\n        if field.repr != updates.values[index].repr { return false }\n      }\n    }\n    if !found { return false }\n    index += 1\n  }\n  true\n}\n\nfunction updatedNativeFields(layout:LayoutPlan,updates:RecordUpdates) -> string {\n  let mut fields:Array<string> = []\n  for field in layout.fields {\n    let value = match replacement(updates,field.name) {\n      case Some(code) => \"{code.rs}.clone()\"\n      case None => \"__record.f{field.fieldIndex}.clone()\"\n    }\n    fields.push(\"f{field.fieldIndex}:{value}\")\n  }\n  \"<{rustType(layout.repr)}>::new({nominalRustName(layout.repr)} \\{ {fields.join(\", \")} \\})\"\n}\n\nfunction emitNativeRecordSpread(ctx:Ctx,op:Stage1Operation,decl:Stage1Operation,seed:Stage1Operation) -> Result<Code,string> {\n  let layout = declarationLayout(ctx.table,decl)\n  let source = emitExpr(ctx,seed)?\n  let updates = recordUpdates(ctx,op)?\n  let root = decl.typeDefinition[0]\n  let mut required:Array<string> = []\n  let mut pairs:Array<string> = []\n  for field in layout.fields {\n    required.push(rustStr(field.name))\n    let value = match replacement(updates,field.name) {\n      case Some(code) => boxed(\"{code.rs}.clone()\",code.repr)\n      case None => \"nominal_record_field_required(&__seed,{rustStr(root.name)},{rustStr(field.name)},{spanOf(op)})?\"\n    }\n    pairs.push(\"(Rc::from({rustStr(field.name)}), {value})\")\n  }\n  let dynamic = \"Value::nominal_record_with_identities({rustStr(root.name)},{rustStr(root.identity)},{methodIdentity(ctx,decl)},vec![{pairs.join(\", \")}])\"\n  let guard = \"nominal_spread_base_required(NativeValue::into_value(__source.clone()),{rustStr(root.name)},Some({rustStr(root.identity)}),&[{required.join(\", \")}],{spanOf(op)})?\"\n  let value = into(source,layout.repr,op)?\n  if !updatesFit(layout,updates) {\n    return Ok(Code { rs:\"\\{ let __source: {rustType(layout.repr)} = {value}; let __seed = {guard}; {updates.lines.join(\" \")} {dynamic} \\}\", repr:Repr.Value })\n  }\n  // The owned source keeps the old alias even if a replacement rebinds it.\n  // Dynamic admission still precedes replacement evaluation. It never unboxes\n  // retained fields, including unused malformed payloads from a host.\n  let admission = \"let __seed = if let Some(__record) = __source.concrete() \\{ Ok(__record) \\} else \\{ Err({guard}) \\};\"\n  let result = \"match __seed \\{ Ok(__record) => {updatedNativeFields(layout,updates)}, Err(__seed) => {unboxed(dynamic,layout.repr,spanOf(op))} \\}\"\n  Ok(Code { rs:\"\\{ let __source: {rustType(layout.repr)} = {value}; {admission} {updates.lines.join(\" \")} {result} \\}\", repr:layout.repr })\n}\n\nfunction emitNativeShapeUpdate(ctx:Ctx,op:Stage1Operation,base:Stage1Operation,layout:LayoutPlan) -> Result<Code,string> {\n  let source = emitExpr(ctx,base)?\n  let updates = recordUpdates(ctx,op)?\n  let mut pairs:Array<string> = []\n  let mut index = 0\n  for name in updates.names {\n    let code = updates.values[index]\n    pairs.push(\"({rustStr(name)}.to_string(),{boxed(\"{code.rs}.clone()\",code.repr)})\")\n    index += 1\n  }\n  let guard = \"record_update_base(NativeValue::into_value(__source.clone()),{spanOf(op)})?\"\n  let dynamic = \"record_update_merge(__base,vec![{pairs.join(\", \")}],{spanOf(op)})?\"\n  let value = into(source,layout.repr,op)?\n  if !updatesFit(layout,updates) {\n    return Ok(Code { rs:\"\\{ let __source: {rustType(layout.repr)} = {value}; let __base = {guard}; {updates.lines.join(\" \")} {dynamic} \\}\", repr:Repr.Value })\n  }\n  let admission = \"let __base = if let Some(__record) = __source.concrete() \\{ Ok(__record) \\} else \\{ Err({guard}) \\};\"\n  let result = \"match __base \\{ Ok(__record) => {updatedNativeFields(layout,updates)}, Err(__base) => {unboxed(dynamic,layout.repr,spanOf(op))} \\}\"\n  Ok(Code { rs:\"\\{ let __source: {rustType(layout.repr)} = {value}; {admission} {updates.lines.join(\" \")} {result} \\}\", repr:layout.repr })\n}\n\nfunction emitNativeRecord(ctx:Ctx,op:Stage1Operation,decl:Stage1Operation) -> Result<Code,string> {\n  let layout = declarationLayout(ctx.table,decl)\n  let native = layout.repr\n  let mut lines:Array<string> = []\n  let mut names:Array<string> = []\n  let mut values:Array<Code> = []\n  let mut position = 0\n  for label in op.operandLabels {\n    if fieldOf(label) == \"value\" && label.startsWith(\"field-initializer[\") {\n      let code = emitExpr(ctx,opAt(ctx.table,op.operands[position])?)?\n      let local = \"__field{names.length}\"\n      lines.push(\"let {local} = {bare(code.rs)};\")\n      names.push(labelName(label))\n      values.push(Code { rs:local, repr:code.repr })\n    }\n    position += 1\n  }\n  let mut fields:Array<string> = []\n  for field in layout.fields {\n      let mut value:Option<Code> = None\n      let mut index = 0\n      for name in names { if name == field.name { value = Some(values[index]) }; index += 1 }\n      let code = match value {\n        case Some(code) => code\n        case None => match recordDefault(ctx,decl,field.fieldIndex)? {\n          case Some(default) => {\n            let code = emitExpr(defaultContext(ctx,decl),default)?\n            let local = \"__default{field.fieldIndex}\"\n            lines.push(\"let {local} = {bare(code.rs)};\")\n            Code { rs:local, repr:code.repr }\n          }\n          case None => return Err(refusal(\"missing record field {decl.typeDefinition[0].name}.{field.name}\",op))\n        }\n      }\n      fields.push(\"f{field.fieldIndex}:{into(code,field.repr,op)?}\")\n  }\n  lines.push(\"<{rustType(native)}>::new({nominalRustName(native)} \\{ {fields.join(\", \")} \\})\")\n  Ok(Code { rs:\"\\{ {lines.join(\" \")} \\}\", repr:native })\n}\n\nfunction jsonSchema(ctx: Ctx, origin: Stage1Operation, atoms: Array<PreviewTypeAtom>, index: int, active: Array<string>) -> Result<string, string> {\n  let atom = atoms[index]\n  let subs = childTypes(atoms, index)\n  if atom.kind == \"primitive\" {\n    let name = match atom.name {\n      case \"int\" => \"Int\"\n      case \"string\" => \"Str\"\n      case \"bool\" => \"Bool\"\n      case \"unit\" => \"Unit\"\n      case \"null\" => \"Null\"\n      case _ => return Err(refusal(\"JSON schema {atom.name}\", origin))\n    }\n    return Ok(\"Schema::{name}\")\n  }\n  if atom.kind == \"json-value\" { return Ok(\"Schema::Json\") }\n  if atom.kind == \"constructor\" && has([\"Array\", \"Option\", \"Map\"], atom.name) {\n    let slot = if atom.name == \"Map\" { 1 } else { 0 }\n    if subs.length <= slot { return Err(refusal(\"JSON schema argument\", origin)) }\n    return Ok(\"Schema::{atom.name}(Rc::new({jsonSchema(ctx, origin, atoms, subs[slot], active)?}))\")\n  }\n  if atom.kind == \"record\" {\n    let mut fields: Array<string> = []\n    for sub in subs { fields.push(\"(Rc::from({rustStr(atoms[sub].edgeName)}), {jsonSchema(ctx, origin, atoms, sub, active)?}, None)\") }\n    return Ok(\"Schema::StructRecord \\{ fields: Rc::from(vec![{fields.join(\", \")}]) \\}\")\n  }\n  if has([\"enum\", \"newtype\", \"nominal-record\"], atom.kind) {\n    let identity = nominalIdentity(atom)\n    let schemaKey = jsonBoundary.stringify(subtree(atoms, index))?\n    if has(active, schemaKey) { return Err(refusal(\"recursive JSON schema {identity}\", origin)) }\n    let mut next: Array<string> = []\n    for key in active { next.push(key) }\n    next.push(schemaKey)\n    let declaration = match ctx.table.nominals.get(identity) {\n      case Some(found) => found\n      case None => return Err(refusal(\"JSON nominal {identity}\", origin))\n    }\n    let mut params: Map<string, Array<PreviewTypeAtom>> = map {}\n    let mut ordinal = 0\n    for param in declaration {\n      if param.parent == 0 && param.field == \"typeParameters\" {\n        if ordinal >= subs.length { return Err(refusal(\"JSON nominal arity\", origin)) }\n        params.insert(param.name, subtree(atoms, subs[ordinal]))\n        ordinal += 1\n      }\n    }\n    let definition = substitute(declaration, params)\n    let mut fields: Array<string> = []\n    for sub in childTypes(definition, 0) {\n      let member = definition[sub]\n      if member.field == \"base\" {\n        return Ok(\"Schema::Newtype \\{ newtype_id: Rc::from({rustStr(declaration[0].name)}), declaration_identity: Some(Rc::from({rustStr(identity)})), base: Rc::new({jsonSchema(ctx, origin, definition, sub, next)?}) \\}\")\n      }\n      if member.field == \"fields\" {\n        let mut default = \"None\"\n        for decl in ctx.table.nominalDeclarations.get(identity) ?? [] {\n          match recordDefault(ctx, decl, member.index)? {\n            case Some(value) => if schemaConstant(ctx, value)? { default = \"Some({boxCode(emitExpr(defaultContext(ctx, decl), value)?)})\" }\n            case None => ()\n          }\n        }\n        fields.push(\"(Rc::from({rustStr(member.edgeName)}), {jsonSchema(ctx, origin, definition, sub, next)?}, {default})\")\n      }\n      if member.field == \"variants\" {\n        let mut payloads: Array<string> = []\n        for payload in childTypes(definition, sub) { payloads.push(jsonSchema(ctx, origin, definition, payload, next)?) }\n        fields.push(\"(Rc::from({rustStr(member.name)}), {member.index}u32, Rc::from(vec![{payloads.join(\", \")}]))\")\n      }\n    }\n    if atom.kind == \"enum\" {\n      return Ok(\"Schema::Enum \\{ enum_id: Rc::from({rustStr(declaration[0].name)}), declaration_identity: Some(Rc::from({rustStr(identity)})), variants: Rc::from(vec![{fields.join(\", \")}]) \\}\")\n    }\n    return Ok(\"Schema::Record \\{ record_id: Rc::from({rustStr(declaration[0].name)}), declaration_identity: Some(Rc::from({rustStr(identity)})), fields: Rc::from(vec![{fields.join(\", \")}]) \\}\")\n  }\n  Err(refusal(\"JSON schema {atom.kind}/{atom.name}\", origin))\n}\n\nfunction schemaConstant(ctx: Ctx, op: Stage1Operation) -> Result<bool, string> {\n  if !has([\"expression/integer\", \"expression/length\", \"expression/float\", \"expression/boolean\", \"expression/unit\", \"expression/null\", \"expression/string\", \"expression/string-text\", \"expression/unary\", \"expression/binary\", \"expression/parenthesized\"], op.kind) { return Ok(false) }\n  for id in op.operands { if !schemaConstant(ctx, opAt(ctx.table, id)?)? { return Ok(false) } }\n  Ok(true)\n}\n\nfunction emitRecord(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let repr = operationReprOfCached(ctx.table.reprs, op, false)\n  let layoutFields = if isShape(repr) { layoutForAtoms(ctx.table.plan,op.semanticTypeAtoms,0,None,repr).fields } else { [] }\n  let mut steps:Array<string> = []\n  let mut fields:Array<string> = []\n  let mut pairs:Array<string> = []\n  let mut position = 0\n  for id in op.operands {\n    let label = op.operandLabels[position]\n    let name = labelName(label)\n    if fieldOf(label) != \"value\" || !label.startsWith(\"field-initializer[\") || name == \"\" {\n      return Err(refusal(\"shape record field {label}\", op))\n    }\n    let code = emitExpr(ctx,opAt(ctx.table,id)?)?\n    let local = \"__field{position}\"\n    steps.push(\"let {local} = {code.rs};\")\n    let value = Code { rs:local, repr:code.repr }\n    pairs.push(\"({rustStr(name)}.to_string(), {boxCode(value)})\")\n    for field in layoutFields {\n      if field.name == name {\n        fields.push(\"f{field.fieldIndex}:{into(value,field.repr,op)?}\")\n      }\n    }\n    position += 1\n  }\n  let value = if isShape(repr) {\n    \"<{rustType(repr)}>::new({nominalRustName(repr)} \\{ {fields.join(\", \")} \\})\"\n  } else { \"Value::record([{pairs.join(\", \")}])\" }\n  Ok(Code { rs:\"\\{ {steps.join(\" \")} {value} \\}\", repr:if isShape(repr) { repr } else { Repr.Value } })\n}\n\n// The namespace binding an operation names, if it is an identifier bound to\n// an imported module.\nexport function namespaceOf(ctx: Ctx, op: Stage1Operation) -> Option<Bind> {\n  if op.kind != \"expression/identifier\" {\n    return None\n  }\n  match lookup(ctx, op.detail) {\n    case Some(bind) => if bind.kind == \"namespace\" {\n      Some(bind)\n    } else {\n      None\n    }\n    case None => None\n  }\n}\n\n// A builtin static member call follows the checker's builtin target unless its\n// object names an imported module namespace, whose members resolve through\n// that module. An imported type such as `Bytes` from std.bytes is not a\n// namespace binding and keeps the builtin static route.\nexport function builtinStaticObject(ctx: Ctx, object: Stage1Operation) -> bool {\n  if object.referenceIdentity.startsWith(\"builtin::\") { return true }\n  match namespaceOf(ctx, object) {\n    case Some(_) => false\n    case None => true\n  }\n}\n\n// A schema-directed immutable import can bypass its callable value boundary.\nfunction staticImport(ctx: Ctx, op: Stage1Operation) -> Option<Bind> {\n  if op.kind == \"expression/parenthesized\" {\n    match child(ctx.table,op,\"operand\") { case Ok(inner) => return staticImport(ctx,inner); case Err(_) => return None }\n  }\n  if op.kind == \"expression/identifier\" {\n    match lookup(ctx,op.detail) { case Some(bind) => if bind.kind == \"builtin\" { return Some(bind) }; case None => () }\n  }\n  if op.kind == \"expression/member\" {\n    match child(ctx.table,op,\"object\") {\n      case Ok(object) => match namespaceOf(ctx,object) {\n        case Some(namespace) => match ctx.mods.get(namespace.rust) {\n          case Some(module) => return modBind(module,op.detail)\n          case None => ()\n        }\n        case None => ()\n      }\n      case Err(_) => ()\n    }\n  }\n  None\n}\n\n// A runtime operation named by a generated standard module, or \"\".\nfunction generatedIntrinsic(ctx: Ctx, op: Stage1Operation) -> string {\n  match ctx.mods.get(op.module) {\n    case Some(info) => if info.generatedStd { lispexIntrinsic(op.module, op.detail) } else { \"\" }\n    case None => \"\"\n  }\n}\n\nfunction builtinCode(tag: string) -> Code {\n  Code { rs: \"Value::Builtin \\{ kind: Builtin::{tag}, recv: None \\}\", repr: Repr.Value }\n}\n\n// A fallback is unreachable only when value provenance proves the actual\n// receiver kind. Collection payloads can still be changed by dynamic aliases;\n// callback methods retain their dynamic storage and suspension paths.\nfunction provenCarrier(ctx:Ctx, object:Stage1Operation, carrier:Repr) -> bool {\n  let fact=rootFact(ctx.provenance,object.id)\n  (fact == \"array\" && isArray(carrier)) || (fact == \"text\" && carrier == Repr.Text) ||\n    (fact == \"json\" && carrier == Repr.Json) || (fact == \"bigint\" && carrier == Repr.BigInt) ||\n    (fact == \"bytes\" && carrier == Repr.Value)\n}\n\nfunction receiverFallback(ctx:Ctx, op:Stage1Operation, object:Stage1Operation, carrier:Repr, callee:string, args:Array<Stage1Operation>) -> Result<string,string> {\n  let member=child(ctx.table,op,\"callee\")?\n  if provenCarrier(ctx,object,carrier) {\n    if !has([\"map\",\"mapErr\",\"filter\",\"reduce\",\"sortBy\",\"sortedBy\",\"forEach\"],member.detail) {\n      return Ok(\"\\{ let __value: Value = unreachable!(\\\"receiver kind follows checked value provenance\\\"); __value \\}\")\n    }\n  }\n  // Sparse wire metadata can put a proved builtin into a different Dynamic\n  // carrier. Keep its member lookup and argument faults on the synchronous\n  // builtin path instead of treating a failed native guard as unreachable.\n  if builtinMethodSuspension(rootFact(ctx.provenance,object.id),member.detail) == Suspension.Never {\n    let mut steps:Array<string> = [\"let __callee = {callee};\"]\n    let mut values:Array<string> = []\n    let mut index = 0\n    for arg in args {\n      steps.push(\"let __a{index} = {boxCode(emitExpr(ctx,arg)?)};\")\n      values.push(\"__a{index}\")\n      index += 1\n    }\n    return Ok(\"\\{ {steps.join(\" \")} let mut __args = vec![{values.join(\", \")}]; call_value_sync(&__callee,&mut __args,{spanOf(op)}).expect(\\\"proven pure receiver builtin\\\")? \\}\")\n  }\n  valueCall(ctx,op,callee,args)\n}\n\nfunction emitIndex(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let object = child(ctx.table,op,\"object\")?\n  let index = child(ctx.table,op,\"index\")?\n  let receiver = emitExpr(ctx,object)?\n  let position = emitExpr(ctx,index)?\n  if isArray(receiver.repr) {\n    return Ok(Code { rs:if position.repr == Repr.I64 { \"({receiver.rs}).index_int({position.rs}, {spanOf(op)})?\" } else { \"({receiver.rs}).index({boxCode(position)}, {spanOf(op)})?\" }, repr:elementRepr(receiver.repr) })\n  }\n  Ok(Code { rs: \"index_value_ref({borrowCode(ctx,object,receiver)}, {borrowCode(ctx,index,position)}, {spanOf(op)})?\", repr: Repr.Value })\n}\n\nfunction memberImmutable(ctx:Ctx, object:Stage1Operation) -> Result<string,string> {\n  let mut cursor = object\n  while cursor.kind == \"expression/member\" || cursor.kind == \"expression/index\" || cursor.kind == \"expression/optional-member\" {\n    cursor = child(ctx.table,cursor,\"object\")?\n  }\n  if cursor.kind == \"expression/identifier\" {\n    match lookup(ctx,cursor.detail) {\n      case Some(bind) => if !bind.mutable { return Ok(\"Some({rustStr(cursor.detail)})\") }\n      case None => ()\n    }\n  }\n  Ok(\"None\")\n}\n\nfunction memberVersion(ctx:Ctx) -> string {\n  \"LangVersion::{ctx.table.languageMode.replace(\"topaz-\", \"V\").replace(\".\", \"_\")}\"\n}\n\nfunction memberBody(ctx:Ctx, op:Stage1Operation, object:Stage1Operation, span:string) -> Result<string,string> {\n  Ok(\"native_member_value(&__recv, {rustStr(op.detail)}, {span}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\")\n}\n\n// Match the public scalars call shape; the runtime value still decides whether\n// it is the string builtin or a user-supplied field/method.\nfunction scalarReceiver(ctx:Ctx, op:Stage1Operation) -> Result<Option<Stage1Operation>,string> {\n  if op.kind != \"expression/call\" || op.callOptional || op.callArguments.length != 0 { return Ok(None) }\n  let method = child(ctx.table,op,\"callee\")?\n  if method.kind != \"expression/member\" || method.detail != \"scalars\" { return Ok(None) }\n  Ok(Some(child(ctx.table,method,\"object\")?))\n}\n\nfunction scalarFallback(ctx:Ctx, op:Stage1Operation, receiver:Stage1Operation) -> Result<string,string> {\n  if rootFact(ctx.provenance,receiver.id) == \"text\" && !hasReceiverMethod(ctx,\"scalars\") { return Ok(\"\\{ let __value: Value = unreachable!(\\\"text receiver follows checked value provenance\\\"); __value \\}\") }\n  let method = child(ctx.table,op,\"callee\")?\n  let fallback = valueCall(ctx,op,memberBody(ctx,method,receiver,spanOf(method))?,[])?\n  if hasReceiverMethod(ctx,\"scalars\") {\n    let direct = valueCallPrefix(ctx,op,\"__method\",[],[\"__recv\"])?\n    return Ok(\"\\{ let __method = __recv.method_dispatch_id().and_then(|id| g.methods.borrow().get(id).and_then(|methods| methods.get(&{methodId(ctx,\"scalars\")})).cloned()); match __method \\{ Some(__method) => {direct}, None => {fallback} \\} \\}\")\n  }\n  Ok(fallback)\n}\n\nfunction emitMember(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let object = child(ctx.table, op, \"object\")?\n  if op.detail == \"length\" {\n    match scalarReceiver(ctx,object)? {\n      case Some(receiver) => {\n        let source = emitExpr(ctx,receiver)?\n        let fallback = scalarFallback(ctx,object,receiver)?\n        let length = memberBody(ctx,op,object,spanOf(op))?\n        if source.repr == Repr.Text {\n          let dynamic = unboxed(\"\\{ let __recv = NativeValue::into_value(__text); let __recv = {fallback}; {length} \\}\",Repr.I64,spanOf(op))\n          return Ok(Code { rs:\"\\{ let __text = {source.rs}; match __text.with_str(|__s| __s.chars().count() as i64) \\{ Some(__length) => __length, None => \\{ {dynamic} \\} \\} \\}\",repr:Repr.I64 })\n        }\n        return Ok(Code { rs:\"\\{ let __recv = {boxCode(source)}; match __recv \\{ Value::Str(__text) => Value::Int(__text.chars().count() as i64), __recv => \\{ let __recv = {fallback}; {length} \\} \\} \\}\",repr: Repr.Value })\n      }\n      case None => ()\n    }\n  }\n  match nominalHead(ctx, object)? {\n    case Some(decl) => if decl.kind == \"enum\" { return emitEnum(ctx, op, decl, op.detail, []) }\n    case None => ()\n  }\n  if object.referenceIdentity.startsWith(\"builtin::\") {\n    if object.detail == \"RoundingMode\" {\n      for variant in [\"Down\", \"Up\", \"TowardZero\", \"AwayFromZero\", \"HalfUp\", \"HalfEven\"] {\n        if op.detail == variant { return Ok(Code { rs: \"rounding_mode_value(RoundingMode::{variant})\", repr: Repr.Value }) }\n      }\n    }\n    let tag = if ctx.table.languageMode == \"topaz-5.21\" && removedStandardStatic(object.detail, op.detail) { \"\" } else { staticBuiltin(object.detail, op.detail) }\n    if tag != \"\" { return Ok(builtinCode(tag)) }\n    return Err(refusal(\"type-directed member {object.detail}.{op.detail}\", op))\n  }\n  let receiver = emitExpr(ctx,object)?\n  if isArray(receiver.repr) && op.detail == \"length\" {\n    let fallback = unboxed(\"native_member_value(&NativeValue::into_value(__array), \\\"length\\\", {spanOf(op)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\", Repr.I64,spanOf(op))\n    return Ok(Code { rs:\"\\{ let __array = {receiver.rs}; if __array.is_array() \\{ __array.length({spanOf(op)})? \\} else \\{ {fallback} \\} \\}\",repr: Repr.I64 })\n  }\n  match recordLayout(ctx.table,receiver.repr) {\n    case Some(layout) => {\n      for field in layout.fields {\n        if field.name == op.detail {\n          return emitFieldRead(ctx,object,receiver,op,field.repr,field.fieldIndex)\n        }\n      }\n      ()\n    }\n    case None => ()\n  }\n  let value = boxCode(receiver)\n  match namespaceOf(ctx, object) {\n    case Some(namespace) => return Ok(Code { rs: \"member_value_required(&({value}), {rustStr(op.detail)}, {spanOf(op)})?\", repr: Repr.Value })\n    case None => ()\n  }\n  Ok(Code { rs: \"native_member_value({borrowCode(ctx,object,receiver)}, {rustStr(op.detail)}, {spanOf(op)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\", repr: Repr.Value })\n}\n\n// This short borrow encloses a compiler-owned immutable projection only.\n// Evaluation of the array and index finishes before the borrow begins.\nfunction emitFieldRead(ctx: Ctx, object: Stage1Operation, receiver: Code, op: Stage1Operation, target: Repr, index: int) -> Result<Code,string> {\n  let fact=rootFact(ctx.provenance,op.id)\n  if isEnum(target) && fact.startsWith(\"enum:{reprName(target)}:\") {\n    let identity=reprIdentity(target)\n    for atom in ctx.table.nominals.get(identity) ?? [] {\n      if atom.parent == 0 && atom.field == \"variants\" && fact == \"enum:{reprName(target)}:{atom.name}\" {\n        return Ok(Code { rs:\"\\{ let _ = {receiver.rs}; <{rustType(target)}>::new({nominalRustName(target)}::V{atom.index}) \\}\",repr:target })\n      }\n    }\n  }\n  if (target == Repr.Bool && fact.startsWith(\"bool:\")) || (target == Repr.I64 && fact.startsWith(\"int:\")) {\n    let literal=if target == Repr.Bool { fact.slice(5,fact.scalars().length) } else { \"{fact.slice(4,fact.scalars().length)}i64\" }\n    return Ok(Code { rs:\"\\{ let _ = {receiver.rs}; {literal} \\}\",repr:target })\n  }\n  let fallback = unboxed(\"member_value_required(&NativeValue::into_value(__recv.clone()),{rustStr(op.detail)},{spanOf(op)})?\",target,spanOf(op))\n  let projection = \"if let Some(__record) = __recv.concrete() \\{ __record.f{index}.clone() \\} else \\{ {fallback} \\}\"\n  if object.kind == \"expression/index\" {\n    let array = emitExpr(ctx,child(ctx.table,object,\"object\")?)?\n    if array.repr == Repr.Array(receiver.repr) {\n      let indexCode = emitExpr(ctx,child(ctx.table,object,\"index\")?)?\n      let position = if indexCode.repr == Repr.I64 { indexCode.rs } else { boxCode(indexCode) }\n      let method=if indexCode.repr == Repr.I64 { \"read_int\" } else { \"read\" }\n      return Ok(Code { rs:\"({array.rs}).{method}({position},{spanOf(object)}, |__recv| -> Result<{rustType(target)},RtError> \\{ Ok({projection}) \\})?\",repr:target })\n    }\n  }\n  if object.kind == \"expression/identifier\" {\n    match lookup(ctx,object.detail) {\n      case Some(bind) => if bind.kind == \"local\" && !bind.mutable && bind.repr == receiver.repr {\n        return Ok(Code { rs:\"\\{ let __recv = &{bind.rust}; {projection} \\}\",repr:target })\n      }\n      case None => ()\n    }\n  }\n  Ok(Code { rs:\"\\{ let __recv = {receiver.rs}; {projection} \\}\",repr:target })\n}\n\nfunction optionalBody(value: string, body: string) -> string {\n  \"\\{ let __object = {value}; match __object \\{ Value::None => Value::None, Value::Null => Value::Null, Value::Some(__inner) => \\{ let __recv = (*__inner).clone(); wrap_optional({body}) \\}, __recv => \\{ {body} \\} \\} \\}\"\n}\n\nfunction emitOptionalMember(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let object = child(ctx.table, op, \"object\")?\n  let value = boxCode(emitExpr(ctx, object)?)\n  Ok(Code { rs: optionalBody(value, memberBody(ctx, op, object, spanOf(op))?), repr: Repr.Value })\n}\n\n// The plan retains argument order. Named and spread AST wrappers are encoded\n// in operand labels, so their leaves are not ordinary `arguments` children.\nfunction callArguments(ctx: Ctx, op: Stage1Operation) -> Result<Array<Stage1Operation>, string> {\n  let mut found: Array<Stage1Operation> = []\n  let mut position = 0\n  for id in op.operands {\n    let label = op.operandLabels[position]\n    if label.startsWith(\"arguments:\") || label.contains(\"/arguments:\") {\n      found.push(opAt(ctx.table, id)?)\n    }\n    position += 1\n  }\n  if found.length != op.callArguments.length { return Err(refusal(\"shape call arguments\", op)) }\n  Ok(found)\n}\n\nfunction valueCall(ctx: Ctx, op: Stage1Operation, callee: string, args: Array<Stage1Operation>) -> Result<string, string> {\n  valueCallPrefix(ctx, op, callee, args, [])\n}\n\nfunction valueCallPrefix(ctx: Ctx, op: Stage1Operation, callee: string, args: Array<Stage1Operation>, prefix: Array<string>) -> Result<string, string> {\n  suspend(ctx.effect)\n  let mut steps: Array<string> = [\"let __callee = {callee};\"]\n  let mut positional: Array<string> = prefix\n  let mut named: Array<string> = []\n  let mut hasSpread = false\n  for row in op.callArguments { if row.startsWith(\"spread|\") { hasSpread = true } }\n  if hasSpread { steps.push(\"let mut __tail = Vec::new();\") }\n  let mut spreadSpan = spanOf(op)\n  let mut spread = false\n  let mut sawNamed = false\n  let mut position = 0\n  for arg in args {\n    let row = op.callArguments[position].split(\"|\")\n    let value = boxCode(emitExpr(ctx, arg)?)\n    steps.push(\"let __a{position} = {value};\")\n    if row[0] == \"named\" {\n      named.push(\"({rustStr(row[1])}.to_string(), __a{position})\")\n      sawNamed = true\n    } else if sawNamed && row[0] == \"positional\" {\n      steps.push(\"return Err(fault(codes::GUARD_ARITY, \\\"positional arguments must precede named arguments (§5)\\\", {spanOf(op)}));\")\n    } else if row[0] == \"spread\" {\n      if !spread { spreadSpan = spanOf(arg) }\n      spread = true\n      steps.push(\"call_spread_extend(&mut __tail, __a{position}, {spanOf(arg)})?;\")\n    } else if spread {\n      steps.push(\"__tail.push(__a{position});\")\n    } else {\n      positional.push(\"__a{position}\")\n    }\n    position += 1\n  }\n  let span = spanOf(op)\n  let call = if spread {\n    \"{drive(ctx, \"call_value_spread_named(SpreadNamedCall::new(__callee, vec![{positional.join(\", \")}], Value::array(__tail), vec![{named.join(\", \")}], {span}, {spreadSpan}), cx.clone())\")}?\"\n  } else if named.length > 0 {\n    \"{drive(ctx, \"call_value_named(__callee, vec![{positional.join(\", \")}], vec![{named.join(\", \")}], cx.clone(), {span})\")}?\"\n  } else {\n    \"\\{ let mut __args = vec![{positional.join(\", \")}]; match call_value_sync(&__callee, &mut __args, {span}) \\{ Some(__result) => __result?, None => {drive(ctx, \"call_value(__callee, __args, cx.clone(), {span})\")}? \\} \\}\"\n  }\n  Ok(\"\\{ {steps.join(\" \")} {call} \\}\")\n}\n\nfunction emitStaticCall(ctx: Ctx, op: Stage1Operation, spec: BuiltinSpec, args: Array<Stage1Operation>) -> Result<Code, string> {\n  let mut steps: Array<string> = []\n  let mut slots: Array<string> = []\n  let mut index = 0\n  while index < spec.params.length { slots.push(\"\"); index += 1 }\n  let mut next = 0\n  let mut named = false\n  let mut fallback = false\n  let variadic = spec.style.startsWith(\"variadic\")\n  let mut values: Array<string> = []\n  index = 0\n  for arg in args {\n    let row = op.callArguments[index].split(\"|\")\n    let code = boxCode(emitExpr(ctx, arg)?)\n    if variadic {\n      if row[0] == \"named\" { fallback = true }\n      if row[0] == \"spread\" {\n        steps.push(\"call_spread_extend(&mut __values, {code}, {spanOf(arg)})?;\")\n      } else { steps.push(\"__values.push({code});\") }\n    } else {\n      steps.push(\"let __a{index} = {code};\")\n      let mut slot = next\n      if row[0] == \"named\" {\n        named = true\n        slot = -1\n        let mut position = 0\n        for name in spec.params {\n          if name == row[1] { slot = position }\n          position += 1\n        }\n      } else if row[0] == \"spread\" { fallback = true } else {\n        if named { fallback = true }\n        next += 1\n      }\n      if slot < 0 || slot >= slots.length { fallback = true } else if slots[slot] != \"\" { fallback = true } else { slots[slot] = \"__a{index}\" }\n    }\n    index += 1\n  }\n  if !variadic {\n    index = 0\n    for slot in slots {\n      if slot != \"\" { values.push(slot) } else if spec.defaults[index] != \"\" { values.push(spec.defaults[index]) } else { fallback = true }\n      index += 1\n    }\n  }\n  if fallback { return Ok(Code { rs: valueCall(ctx, op, builtinCode(spec.tag).rs, args)?, repr: Repr.Value }) }\n  if variadic {\n    let prefix = if steps.length == 0 { \"let __values = Vec::new();\" } else { \"let mut __values = Vec::new();\" }\n    steps.insert(0, prefix)\n    values.push(\"__values\")\n  }\n  if spec.style == \"optional-second\" { values[1] = \"Some({values[1]})\" }\n  if spec.style == \"sync-host\" || spec.style == \"sync-host-raw\" { values.insert(0, \"cx.host_ref()\") }\n  if spec.style == \"length\" { values.insert(0, \"Builtin::{spec.tag}\") }\n  if spec.style.startsWith(\"lispex:\") {\n    values = [\"LispexApplicationOperation::{spec.style.split(\":\")[1]}\", \"vec![{values.join(\", \")}]\"]\n  }\n  let fallible = !spec.style.endsWith(\"raw\") && spec.style != \"variadic\"\n  if fallible { values.push(spanOf(op)) }\n  let suffix = if fallible { \"?\" } else { \"\" }\n  Ok(Code { rs: \"\\{ {steps.join(\" \")} {spec.leaf}({values.join(\", \")}){suffix} \\}\", repr: Repr.Value })\n}\n\nfunction emitCall(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let callee = child(ctx.table, op, \"callee\")?\n  let args = callArguments(ctx, op)?\n  emitCallWith(ctx, op, callee, args)\n}\n\nfunction emitCallWith(ctx: Ctx, op: Stage1Operation, callee: Stage1Operation, args: Array<Stage1Operation>) -> Result<Code, string> {\n  if op.callTarget == \"builtin::JsonParseAs\" || op.callTarget == \"builtin::JsonDecode\" {\n    if op.callTypeArguments.length != 1 { return Err(refusal(\"typed JSON arguments\", op)) }\n    let schema = jsonSchema(ctx, op, op.callTypeArguments[0], 0, [])?\n    let callable = boxCode(emitExpr(ctx, callee)?)\n    let span = spanOf(op)\n    if op.callTarget == \"builtin::JsonParseAs\" {\n      if args.length != 1 { return Err(refusal(\"std.json.parseAs arity\", op)) }\n      let argument = boxCode(emitExpr(ctx, args[0])?)\n      match staticImport(ctx,callee) {\n        case Some(bind) => if bind.kind == \"builtin\" && bind.rust == \"JsonParseAs\" {\n          return Ok(Code { rs:\"builtin_json_parse_as({argument}, &({schema}), {span})?\", repr:Repr.Value })\n        }\n        case None => ()\n      }\n      suspend(ctx.effect)\n      return Ok(Code { rs: \"\\{ let __callee = {callable}; let __text = {argument}; match __callee \\{ Value::Builtin \\{ kind: Builtin::JsonParseAs, recv: None \\} => builtin_json_parse_as(__text, &({schema}), {span})?, __other => {drive(ctx, \"call_value(__other, vec![__text], cx.clone(), {span})\")}? \\} \\}\", repr: Repr.Value })\n    }\n    if args.length != 0 { return Err(refusal(\"JSONValue.decode arity\", op)) }\n    suspend(ctx.effect)\n    Ok(Code { rs: \"\\{ let __callee = {callable}; match __callee \\{ Value::Builtin \\{ kind: Builtin::JsonDecode, recv: Some(__value) \\} => builtin_json_decode((*__value).clone(), &({schema}), {span})?, __other => {drive(ctx, \"call_value(__other, vec![], cx.clone(), {span})\")}? \\} \\}\", repr: Repr.Value })\n  } else { emitOrdinaryCallWith(ctx, op, callee, args) }\n}\n\nfunction emitOrdinaryCallWith(ctx: Ctx, op: Stage1Operation, callee: Stage1Operation, args: Array<Stage1Operation>) -> Result<Code, string> {\n  match nominalHead(ctx, callee)? {\n    case Some(decl) => if decl.kind == \"newtype\" {\n      if args.length != 1 { return Err(refusal(\"newtype arity\", op)) }\n      let root = decl.typeDefinition[0]\n      let argument = emitExpr(ctx,args[0])?\n      let repr = operationReprOfCached(ctx.table.reprs,op,false)\n      // Packing a checked base is free. A different carrier keeps the old\n      // constructor boundary: do not validate an unused malformed payload.\n      if isNewtype(repr) && reprIdentity(repr) == nominalIdentity(root) && argument.repr == newtypeBase(ctx.table,repr) {\n        return Ok(Code { rs:\"<{rustType(repr)}>::new({nominalRustName(repr)} \\{ f0: {argument.rs} \\})\",repr:repr })\n      }\n      return Ok(Code { rs: \"Value::newtype_with_identities({rustStr(root.name)}, {rustStr(root.identity)}, {methodIdentity(ctx, decl)}, {boxCode(argument)})\", repr: Repr.Value })\n    }\n    case None => ()\n  }\n  if callee.kind == \"expression/identifier\" {\n    if callee.referenceIdentity.startsWith(\"builtin::\") {\n      if ctx.table.languageMode == \"topaz-5.21\" && (callee.detail == \"toFloat\" || callee.detail == \"toInt\" || callee.detail == \"toIntRadix\" || callee.detail == \"fromCodePoint\" || callee.detail == \"map\" || callee.detail == \"filter\" || callee.detail == \"reduce\" || callee.detail == \"print\" || callee.detail == \"input\" || callee.detail == \"open\" || callee.detail == \"assert\") { return Err(refusal(\"removed numeric free builtin\", op)) }\n      match freeSpec(callee.detail) {\n        case Some(spec) => return emitStaticCall(ctx, op, spec, args)\n        case None => ()\n      }\n      let intrinsic = generatedIntrinsic(ctx, callee)\n      if intrinsic != \"\" {\n        match intrinsicSpec(intrinsic) {\n          case Some(spec) => return emitStaticCall(ctx, op, spec, args)\n          case None => return Ok(Code { rs: valueCall(ctx, op, builtinCode(intrinsic).rs, args)?, repr: Repr.Value })\n        }\n      }\n      if callee.detail == \"Some\" || callee.detail == \"Ok\" || callee.detail == \"Err\" {\n        if args.length != 1 { return Err(refusal(\"builtin {callee.detail}/{args.length}\", op)) }\n        let repr = operationReprOfCached(ctx.table.reprs, op, false)\n        if callee.detail == \"Some\" && isOption(repr) {\n          let target = sumPayloadRepr(ctx,op,repr,\"Some\",elementRepr(repr))\n          let payload = into(emitExpr(ctx,args[0])?,target,args[0])?\n          return Ok(Code { rs:\"NativeOption::Some({payload})\",repr:repr })\n        }\n        if (callee.detail == \"Ok\" || callee.detail == \"Err\") && isResult(repr) {\n          let parts = resultParts(repr)\n          let target = sumPayloadRepr(ctx,op,repr,callee.detail,parts[if callee.detail == \"Ok\" { 0 } else { 1 }])\n          let payload = into(emitExpr(ctx,args[0])?,target,args[0])?\n          return Ok(Code { rs:\"NativeResult::{callee.detail}({payload})\",repr:repr })\n        }\n        return Ok(Code { rs: \"Value::{callee.detail}(Rc::new({boxCode(emitExpr(ctx, args[0])?)}))\", repr: Repr.Value })\n      }\n    } else {\n      match lookup(ctx, callee.detail) {\n        case Some(bind) => if bind.kind == \"fn\" {\n          return emitDirectCall(ctx, op, fnInfo(ctx, bind.rust, op)?, callee.detail, spanOf(callee), args)\n        } else if bind.kind == \"builtin\" {\n          match intrinsicSpec(bind.rust) { case Some(spec) => return emitStaticCall(ctx,op,spec,args); case None => () }\n        }\n        case None => return Err(refusal(\"unresolved identifier {callee.detail}\", callee))\n      }\n    }\n  } else if callee.kind == \"expression/member\" {\n    let object = child(ctx.table, callee, \"object\")?\n    match nominalHead(ctx, object)? {\n      case Some(decl) => if decl.kind == \"enum\" { return emitEnum(ctx, op, decl, callee.detail, args) }\n      case None => ()\n    }\n    if object.detail == \"JSON\" && has([\"parseAs\", \"decode\"], callee.detail) && object.referenceIdentity.startsWith(\"builtin::\") {\n      if args.length != 1 || op.callTypeArguments.length != 1 { return Err(refusal(\"typed JSON arguments\", op)) }\n      let schema = jsonSchema(ctx, op, op.callTypeArguments[0], 0, [])?\n      let leaf = if callee.detail == \"parseAs\" { \"builtin_json_parse_as\" } else { \"builtin_json_decode\" }\n      return Ok(Code { rs: \"{leaf}({boxCode(emitExpr(ctx, args[0])?)}, &({schema}), {spanOf(op)})?\", repr: Repr.Value })\n    }\n    let protocol = (has([\"Show\", \"Eq\", \"Order\"], object.detail) && object.referenceIdentity.startsWith(\"builtin::\")) || hasProtocol(ctx.table,op.module,object.detail)\n    if protocol {\n      let mut values: Array<string> = []\n      for arg in args { values.push(boxCode(emitExpr(ctx, arg)?)) }\n      let module = rustStr(op.module)\n      let name = rustStr(object.detail)\n      let method = rustStr(callee.detail)\n      suspend(ctx.effect)\n      return Ok(Code { rs: \"\\{ let __args = vec![{values.join(\", \")}]; let __method = __args.first().and_then(|v| v.nominal_id()).and_then(|id| g.protocols.borrow().get(&({module}.to_string(), {name}.to_string(), id.to_string(), {method}.to_string())).cloned()); match __method \\{ Some(f) => {drive(ctx, \"call_value(f, __args, cx.clone(), {spanOf(op)})\")}?, None => builtin_protocol_dispatch({name}, {method}, __args, {spanOf(op)})? \\} \\}\", repr: Repr.Value })\n    }\n    // JSON boundary targets identify callable values, not static namespaces.\n    // Keep callee evaluation and named/spread arguments on the value-call path.\n    let jsonCallable = op.callTarget == \"builtin::JsonParse\" || op.callTarget == \"builtin::JsonStringify\"\n    if builtinStaticObject(ctx, object) && op.callTarget.startsWith(\"builtin::\") && !jsonCallable {\n      let namespace = op.callTarget.split(\"::\")[1]\n      if ctx.table.languageMode == \"topaz-5.21\" && removedStandardStatic(namespace, op.callMethod) { return Err(refusal(\"use numeric receiver methods\", op)) }\n      match staticSpec(namespace, op.callMethod) {\n        case Some(spec) => return emitStaticCall(ctx, op, spec, args)\n        case None => {\n          // These language protocols dispatch on the argument value. Nominal\n          // declarations and their method registrations are a later surface.\n          if (namespace == \"Show\" && op.callMethod == \"show\") ||\n            (namespace == \"Eq\" && op.callMethod == \"equals\") ||\n            (namespace == \"Order\" && op.callMethod == \"compare\") {\n            let mut values: Array<string> = []\n            for arg in args { values.push(boxCode(emitExpr(ctx, arg)?)) }\n            return Ok(Code { rs: \"builtin_protocol_dispatch({rustStr(namespace)}, {rustStr(op.callMethod)}, vec![{values.join(\", \")}], {spanOf(op)})?\", repr: Repr.Value })\n          }\n          return Err(refusal(\"type-directed member {namespace}.{op.callMethod}\", op))\n        }\n      }\n    }\n    match namespaceOf(ctx, object) {\n      case Some(namespace) => {\n        let target = modInfo(ctx, namespace.rust, op)?\n        match modBind(target, callee.detail) {\n          case Some(bind) => if bind.kind == \"fn\" {\n            return emitDirectCall(ctx, op, fnInfo(ctx, bind.rust, op)?, callee.detail, spanOf(callee), args)\n          } else if bind.kind == \"builtin\" {\n            match intrinsicSpec(bind.rust) { case Some(spec) => return emitStaticCall(ctx,op,spec,args); case None => () }\n          }\n          case None => ()\n        }\n      }\n      case None => ()\n    }\n  }\n  if op.callOptional {\n    let object = child(ctx.table, callee, \"object\")?\n    let value = boxCode(emitExpr(ctx, object)?)\n    let body = valueCall(ctx, op, memberBody(ctx, callee, object, spanOf(op))?, args)?\n    return Ok(Code { rs: optionalBody(value, body), repr: Repr.Value })\n  }\n  if callee.kind == \"expression/member\" && hasReceiverMethod(ctx, callee.detail) {\n    let object = child(ctx.table, callee, \"object\")?\n    let recv = boxCode(emitExpr(ctx, object)?)\n    let direct = valueCallPrefix(ctx, op, \"__method\", args, [\"__recv\"])?\n    let fallback = valueCall(ctx, op, memberBody(ctx, callee, object, spanOf(callee))?, args)?\n    return Ok(Code { rs: \"\\{ let __recv = {recv}; let __method = __recv.method_dispatch_id().and_then(|id| g.methods.borrow().get(id).and_then(|methods| methods.get(&{methodId(ctx,callee.detail)})).cloned()); match __method \\{ Some(__method) => {direct}, None => {fallback} \\} \\}\", repr: Repr.Value })\n  }\n  if callee.kind == \"expression/member\" && !op.callOptional {\n    let mut positional = true\n    for row in op.callArguments { if !row.startsWith(\"positional|\") { positional = false } }\n    if positional {\n      let object = child(ctx.table,callee,\"object\")?\n      let receiverCode = emitExpr(ctx,object)?\n      if isNewtype(receiverCode.repr) && callee.detail == \"value\" && args.length == 0 {\n        let base = newtypeBase(ctx.table,receiverCode.repr)\n        let fallback = receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__newtype), \\\"value\\\", {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\",args)?\n        let dynamic = into(Code { rs:fallback,repr:Repr.Value },base,op)?\n        return Ok(Code { rs:\"\\{ let __newtype = {receiverCode.rs}; if let Some(__base) = __newtype.concrete() \\{ __base.f0.clone() \\} else \\{ {dynamic} \\} \\}\",repr:base })\n      }\n      if ((object.semanticTypeAtoms.length > 0 && object.semanticTypeAtoms[0].kind == \"bytes\") || isArray(receiverCode.repr)) &&\n        ((callee.detail == \"get\" && args.length == 1) || (callee.detail == \"length\" && args.length == 0)) {\n        let mut codes:Array<string> = []\n        let mut reprs: Array<Repr> = []\n        for arg in args { let code=emitExpr(ctx,arg)?; codes.push(code.rs); reprs.push(code.repr) }\n        let native=nativeBuiltinMethod(object.semanticTypeAtoms,receiverCode.repr,callee.detail,codes,reprs,spanOf(op))\n        if native.rs != \"\" {\n          let fallback=receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__builtin),{rustStr(callee.detail)},{spanOf(callee)},{memberVersion(ctx)},{memberImmutable(ctx,object)?})?\",args)?\n          let dynamic=into(Code { rs:fallback,repr: Repr.Value },native.repr,op)?\n          return Ok(Code { rs:\"\\{ let __builtin = {receiverCode.rs}; if {native.guard} \\{ {native.rs} \\} else \\{ {dynamic} \\} \\}\",repr:native.repr })\n        }\n      }\n      if receiverCode.repr == Repr.Text && has([\"trim\",\"trimStart\",\"trimEnd\",\"byteLength\",\"encodeUtf8\",\"scalars\",\"startsWith\",\"endsWith\",\"contains\",\"indexOf\",\"lastIndexOf\",\"split\",\"replace\",\"slice\"],callee.detail) {\n        let mut codes:Array<string> = []\n        let mut reprs: Array<Repr> = []\n        for arg in args {\n          let code = emitExpr(ctx,arg)?\n          codes.push(code.rs); reprs.push(code.repr)\n        }\n        let native = nativeTextMethod(callee.detail,codes,reprs,spanOf(op))?\n        if native.rs != \"\" {\n          let fallback = receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__text),{rustStr(callee.detail)},{spanOf(callee)},{memberVersion(ctx)},{memberImmutable(ctx,object)?})?\",args)?\n          let dynamic = into(Code { rs:fallback,repr: Repr.Value },native.repr,op)?\n          return Ok(Code { rs:\"\\{ let __text = {receiverCode.rs}; if __text.with_str(|_| ()).is_some() \\{ {native.rs} \\} else \\{ {dynamic} \\} \\}\",repr:native.repr })\n        }\n      }\n      if isArray(receiverCode.repr) && callee.detail == \"indexOf\" && args.length == 1 {\n        let argument = emitExpr(ctx,args[0])?\n        if argument.repr == elementRepr(receiverCode.repr) {\n          let fallback = receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__array), \\\"indexOf\\\", {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\",args)?\n          let dynamic = into(Code { rs:fallback,repr: Repr.Value },Repr.Option(Repr.I64),op)?\n          return Ok(Code { rs:\"\\{ let __array = {receiverCode.rs}; if __array.is_array() \\{ __array.index_of({argument.rs},{spanOf(op)})? \\} else \\{ {dynamic} \\} \\}\",repr: Repr.Option(Repr.I64) })\n        }\n      }\n      if args.length == 1 && ((isResult(receiverCode.repr) && has([\"map\",\"mapErr\"],callee.detail)) || (isArray(receiverCode.repr) && has([\"map\",\"filter\",\"sortBy\",\"sortedBy\"],callee.detail))) {\n        let resultReceiver = isResult(receiverCode.repr)\n        let source = if resultReceiver { resultParts(receiverCode.repr) } else { [elementRepr(receiverCode.repr)] }\n        let selected = if callee.detail == \"mapErr\" { 1 } else { 0 }\n        match emitNativeCallback(ctx,args[0],source[selected])? {\n          case Some(callback) => {\n            let target = operationReprOfCached(ctx.table.reprs, op, false)\n            let callbackRepr = callback.repr\n            let invoke = \"__callback(__item,{spanOf(op)}){if callback.asynchronous { \".await\" } else { \"\" }}?\"\n            let fallback = valueCall(ctx,op,\"native_member_value(&NativeValue::into_value(__native), {rustStr(callee.detail)}, {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\",args)?\n            let dynamic = into(Code { rs:fallback,repr: Repr.Value },target,op)?\n            if resultReceiver && isResult(target) {\n              let targets = resultParts(target)\n              let mapped = into(Code { rs:invoke,repr:callbackRepr },targets[selected],op)?\n              let other = 1-selected\n              let kept = into(Code { rs:\"__item\",repr:source[other] },targets[other],op)?\n              let ok = if selected == 0 { mapped } else { kept }\n              let error = if selected == 1 { mapped } else { kept }\n              return Ok(Code { rs:\"\\{ let __native = {receiverCode.rs}; let __callback = {callback.rs}; match __native \\{ NativeResult::Ok(__item) => NativeResult::Ok({ok}), NativeResult::Err(__item) => NativeResult::Err({error}), __native @ NativeResult::Dynamic(_) => \\{ {dynamic} \\} \\} \\}\",repr:target })\n            }\n            if !resultReceiver {\n              let guard = if callee.detail == \"sortBy\" { \"native_mutable_member({memberImmutable(ctx,object)?},{spanOf(callee)})?;\" } else { \"\" }\n              let mut direct = \"\"\n              if callee.detail == \"map\" && isArray(target) {\n                let mapped = into(Code { rs:invoke,repr:callbackRepr },elementRepr(target),op)?\n                direct = \"let mut __out = Vec::with_capacity(__items.len()); for __item in __items.iter().cloned() \\{ __out.push({mapped}); \\} NativeArray::new(__out)\"\n              } else if callee.detail == \"filter\" && isArray(target) {\n                let predicate = if callbackRepr == Repr.Bool { invoke } else { \"filter_keep(&({boxed(invoke,callbackRepr)}), {spanOf(op)})?\" }\n                direct = \"let mut __out = Vec::new(); for __item in __items.iter().cloned() \\{ let __keep = __item.clone(); if {predicate} \\{ __out.push(__keep); \\} \\} NativeArray::new(__out)\"\n              } else if has([\"sortBy\",\"sortedBy\"],callee.detail) {\n                let finish = if callee.detail == \"sortBy\" { \"__native.replace(__out); ()\" } else { \"NativeArray::new(__out)\" }\n                direct = \"let mut __keys = Vec::with_capacity(__items.len()); for __item in __items.iter().cloned() \\{ __keys.push({boxed(invoke,callbackRepr)}); \\} let __out = NativeArray::sorted_snapshot(&__items,&__keys,{spanOf(op)})?; {finish}\"\n              }\n              if direct != \"\" {\n                return Ok(Code { rs:\"\\{ let __native = {receiverCode.rs}; if __native.is_array() \\{ {guard} if let Some(__items) = __native.typed_snapshot() \\{ let __callback = {callback.rs}; {direct} \\} else \\{ {dynamic} \\} \\} else \\{ {dynamic} \\} \\}\",repr:target })\n              }\n            }\n          }\n          case None => ()\n        }\n      }\n      if receiverCode.repr == Repr.I64 && callee.detail == \"toBigInt\" && args.length == 0 {\n        let value = if object.kind == \"expression/integer\" {\n          \"\\{ thread_local! \\{ static __BIGINT: NativeBigInt = NativeBigInt::from_int({receiverCode.rs}); \\} __BIGINT.with(Clone::clone) \\}\"\n        } else { \"NativeBigInt::from_int({receiverCode.rs})\" }\n        return Ok(Code { rs:value,repr: Repr.BigInt })\n      }\n      if receiverCode.repr == Repr.BigInt && ((callee.detail == \"toInt\" && args.length == 0) || (has([\"div\",\"mod\"],callee.detail) && args.length == 1)) {\n        let repr = if callee.detail == \"toInt\" { Repr.Option(Repr.I64) } else { resultRepr(Repr.BigInt,Repr.Text) }\n        let fallback = receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__bigint), {rustStr(callee.detail)}, {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\",args)?\n        let dynamic = into(Code { rs:fallback,repr: Repr.Value },repr,op)?\n        let direct = if callee.detail == \"toInt\" { \"__bigint.to_int()\" } else { \"__bigint.division_native({into(emitExpr(ctx,args[0])?,Repr.BigInt,args[0])?}, {if callee.detail == \"mod\" { \"true\" } else { \"false\" }}, {spanOf(op)})?\" }\n        return Ok(Code { rs:\"\\{ let __bigint = {receiverCode.rs}; if __bigint.is_integer() \\{ {direct} \\} else \\{ {dynamic} \\} \\}\",repr:repr })\n      }\n      if isArray(receiverCode.repr) && callee.detail == \"push\" && args.length == 1 {\n        let fallback = receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__array), \\\"push\\\", {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\",args)?\n        let direct = \"native_mutable_member({memberImmutable(ctx,object)?},{spanOf(callee)})?; __array.push({into(emitExpr(ctx,args[0])?,elementRepr(receiverCode.repr),args[0])?}); Value::Unit\"\n        return Ok(Code { rs:\"\\{ let __array = {receiverCode.rs}; if __array.is_array() \\{ {direct} \\} else \\{ {fallback} \\} \\}\",repr: Repr.Value })\n      }\n      if receiverCode.repr == Repr.Json && has([\"get\",\"at\",\"asString\",\"asBool\",\"asInt\",\"asArray\",\"keys\",\"values\",\"numberText\",\"length\",\"kind\",\"isNull\"],callee.detail) && args.length == if callee.detail == \"get\" || callee.detail == \"at\" { 1 } else { 0 } {\n        let repr = operationReprOfCached(ctx.table.reprs, op, false)\n        let fallback = receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__json), {rustStr(callee.detail)}, {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\",args)?\n        let mut method = \"\"\n        if callee.detail == \"get\" || callee.detail == \"at\" {\n          method = \"__json.{callee.detail}({boxCode(emitExpr(ctx,args[0])?)}, {spanOf(op)})?\"\n        } else if callee.detail == \"kind\" {\n          method = \"NativeText::Shared(Rc::from(native_json_kind(__json.node().expect(\\\"JSON view admitted\\\"))))\"\n        } else if callee.detail == \"isNull\" {\n          method = \"matches!(__json.node(), Some(JsonValue::Null))\"\n        } else {\n          let leaf = match callee.detail { case \"asString\" => \"as_string\"; case \"asBool\" => \"as_bool\"; case \"asInt\" => \"as_int\"; case \"asArray\" => \"as_array_native\"; case \"keys\" => \"keys_native\"; case \"values\" => \"values_native\"; case \"numberText\" => \"number_text\"; case _ => callee.detail }\n          method = \"__json.{leaf}()\"\n        }\n        let dynamic = into(Code { rs:fallback,repr: Repr.Value },repr,op)?\n        return Ok(Code { rs:\"\\{ let __json = {receiverCode.rs}; if __json.node().is_some() \\{ {method} \\} else \\{ {dynamic} \\} \\}\",repr:repr })\n      }\n      if receiverCode.repr == Repr.Text && callee.detail == \"codePointAt\" && args.length == 1 {\n        let code = emitExpr(ctx,args[0])?\n        let argument = if code.repr == Repr.I64 { code.rs } else { boxCode(code) }\n        let method = if code.repr == Repr.I64 { \"code_point_at_int\" } else { \"code_point_at_native\" }\n        let fallback = receiverFallback(ctx,op,object,receiverCode.repr,\"native_member_value(&NativeValue::into_value(__text), {rustStr(callee.detail)}, {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?\",args)?\n        let dynamic = into(Code { rs:fallback,repr: Repr.Value },Repr.Option(Repr.I64),op)?\n        return Ok(Code { rs:\"\\{ let __text = {receiverCode.rs}; if __text.with_str(|_| ()).is_some() \\{ __text.{method}({argument}, {spanOf(op)})? \\} else \\{ {dynamic} \\} \\}\", repr: Repr.Option(Repr.I64) })\n      }\n      if builtinMethodSuspension(rootFact(ctx.provenance,object.id),callee.detail) == Suspension.Never {\n        let receiver=boxCode(receiverCode)\n        let mut steps:Array<string> = [\"let __callee = native_prepare_member({receiver}, {rustStr(callee.detail)}, {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?;\"]\n        let mut values:Array<string> = []\n        let mut i=0\n        for arg in args { steps.push(\"let __a{i} = {boxCode(emitExpr(ctx,arg)?)};\"); values.push(\"__a{i}\"); i+=1 }\n        return Ok(Code { rs:\"\\{ {steps.join(\" \")} match __callee \\{ NativeMemberCall::Method \\{ receiver,name \\} => call_method_array(receiver,name,[{values.join(\", \")}],{spanOf(op)},{spanOf(op)})?, NativeMemberCall::Callable(value) => \\{ let mut args=vec![{values.join(\", \")}]; call_value_sync(&value,&mut args,{spanOf(op)}).expect(\\\"proven pure receiver builtin\\\")? \\} \\} \\}\",repr: Repr.Value })\n      }\n      suspend(ctx.effect)\n      let receiver = boxCode(receiverCode)\n      let mut steps:Array<string> = [\"let __callee = native_prepare_member({receiver}, {rustStr(callee.detail)}, {spanOf(callee)}, {memberVersion(ctx)}, {memberImmutable(ctx,object)?})?;\"]\n      let mut values:Array<string> = []\n      let mut i = 0\n      for arg in args {\n        steps.push(\"let __a{i} = {boxCode(emitExpr(ctx,arg)?)};\")\n        values.push(\"__a{i}\")\n        i += 1\n      }\n      let methodCall = if args.length <= 4 {\n        \"call_method_array(receiver, name, [{values.join(\", \")}], {spanOf(op)}, {spanOf(op)})?\"\n      } else {\n        \"call_method(receiver, name, vec![{values.join(\", \")}], {spanOf(op)}, {spanOf(op)})?\"\n      }\n      return Ok(Code { rs:\"\\{ {steps.join(\" \")} match __callee \\{ NativeMemberCall::Method \\{ receiver, name \\} => {methodCall}, NativeMemberCall::Callable(value) => \\{ let mut __args = vec![{values.join(\", \")}]; match call_value_sync(&value, &mut __args, {spanOf(op)}) \\{ Some(__result) => __result?, None => {drive(ctx, \"call_value(value, __args, cx.clone(), {spanOf(op)})\")}? \\} \\} \\} \\}\", repr: Repr.Value })\n    }\n  }\n  Ok(Code { rs: valueCall(ctx, op, boxCode(emitExpr(ctx, callee)?), args)?, repr: Repr.Value })\n}\n\nfunction methodId(ctx:Ctx, name:string) -> int {\n  ctx.table.methodIds.get(name) ?? -1\n}\n\nfunction hasReceiverMethod(ctx: Ctx, name: string) -> bool {\n  ctx.table.receiverMethods.containsKey(name)\n}\n\nexport function emitImplementation(ctx: Ctx, impl: Stage1Operation) -> Result<string, string> {\n  let mut lines: Array<string> = []\n  for id in impl.operands {\n    let method = opAt(ctx.table, id)?\n    if method.kind != \"function\" { continue }\n    let closure = emitClosure(ctx, method, paramsOf(ctx, method, signatureOf(ctx.table, method)?)?, child(ctx.table, method, \"body\")?)?\n    let parts = impl.detail.split(\"<\")\n    let key = if parts.length == 2 {\n      let target = parts[1].replace(\">\", \"\")\n      \"g.protocols.borrow_mut().insert(({rustStr(impl.module)}.to_string(), {rustStr(parts[0])}.to_string(), {rustStr(target)}.to_string(), {rustStr(method.bindingName)}.to_string()), __method);\"\n    } else {\n      \"g.methods.borrow_mut().entry({rustStr(\"{impl.module}::{impl.detail}\")}.to_string()).or_default().insert({methodId(ctx,method.bindingName)}, __method);\"\n    }\n    lines.push(\"\\{ let __method = {closure}; {key} \\}\")\n  }\n  Ok(lines.join(\" \"))\n}\n\n// Evaluate each argument in source order, then bind it to its typed slot.\n// Only dynamic callable values use the boxed callable ABI.\nfunction emitDirectCall(ctx: Ctx, op: Stage1Operation, info: FnInfo, name: string, calleeSpan: string, args: Array<Stage1Operation>) -> Result<Code, string> {\n  call(ctx.effect,info.id)\n  let fixed = info.paramNames.length - if info.variadic { 1 } else { 0 }\n  let allocation = directArguments(info.paramNames,info.defaultIds,info.variadic,op.callArguments)\n  let slots = allocation.slots\n  let surplus = allocation.surplus\n  if !allocation.compatible {\n    return Ok(Code { rs: valueCall(ctx, op, \"top_cell_get(&g.{info.cell}, {rustStr(name)}, {calleeSpan})?\", args)?, repr: Repr.Value })\n  }\n  let mut steps: Array<string> = []\n  if !ctx.initialized.containsKey(info.cell) {\n    steps.push(\"top_cell_check(&g.{info.cell}, {rustStr(name)}, {calleeSpan})?;\")\n  }\n  let mut codes: Array<Code> = []\n  let mut position = 0\n  for arg in args {\n    let code = emitExpr(ctx, arg)?\n    if op.callArguments[position].startsWith(\"spread|\") {\n      steps.push(\"let mut __a{position} = Vec::new(); call_spread_extend(&mut __a{position}, {boxCode(code)}, {spanOf(arg)})?;\")\n      codes.push(Code { rs: \"__a{position}\", repr: Repr.Vec(Repr.Value) })\n    } else {\n      steps.push(\"let __a{position} = {bare(code.rs)};\")\n      codes.push(Code { rs: \"__a{position}\", repr: code.repr })\n    }\n    position += 1\n  }\n  let declaration = opAt(ctx.table, info.id)?\n  let defining = modInfo(ctx, declaration.module, declaration)?\n  let mut scope: Array<Bind> = []\n  for binding in defining.binds { scope.push(binding) }\n  let defaultsCtx = Ctx { ...ctx, scope: scope, inConst: false, atModuleTop: false }\n  let mut passed: Array<string> = [\"cx.clone()\", \"g.clone()\"]\n  position = 0\n  while position < fixed {\n    let source = slots[position]\n    if source >= 0 {\n      steps.push(\"let __p{position} = {into(codes[source], info.paramReprs[position], args[source])?};\")\n    } else {\n      let defaultOp = opAt(ctx.table, info.defaultIds[position])?\n      steps.push(\"let __p{position} = {into(emitExpr(defaultsCtx, defaultOp)?, info.paramReprs[position], defaultOp)?};\")\n    }\n    passed.push(\"__p{position}\")\n    position += 1\n  }\n  if info.variadic {\n    let element = elementRepr(info.paramReprs[fixed])\n    let mut tail: Array<string> = []\n    for source in surplus {\n      if op.callArguments[source].startsWith(\"spread|\") {\n        tail.push(\"for __v in {codes[source].rs} \\{ __rest.push({argumentGuard(\"__v\", element, info.paramSpans[fixed])}); \\}\")\n      } else { tail.push(\"__rest.push({into(codes[source], element, args[source])?});\") }\n    }\n    if tail.length == 0 { steps.push(\"let __rest: Vec<{rustType(element)}> = Vec::new();\") } else {\n      steps.push(\"let mut __rest: Vec<{rustType(element)}> = Vec::new(); {tail.join(\" \")}\")\n    }\n    passed.push(\"__rest\")\n  }\n  steps.push(\"let _gd = __native_enter_call(&cx, {spanOf(op)})?;\")\n  let cooperative = ctx.cooperative && info.cooperative\n  let abi = if cooperative { info.cooperativeAbi } else { info.abi }\n  let body = if cooperative { \"{info.body}_cooperative\" } else { info.body }\n  let call = if abi == CallAbi.Plain {\n    \"{body}({passed.join(\", \")})?\"\n  } else if abi == CallAbi.BoxedFuture {\n    \"{drive(ctx, \"Box::pin({body}({passed.join(\", \")}))\")}?\"\n  } else {\n    \"{drive(ctx, \"{body}({passed.join(\", \")})\")}?\"\n  }\n  Ok(Code { rs: \"\\{ {steps.join(\" \")} {call} \\}\", repr: info.retRepr })\n}\n\nfunction emitIf(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let conditionOp=child(ctx.table,op,\"condition\")?\n  let fact=rootFact(ctx.provenance,conditionOp.id)\n  if fact == \"bool:true\" || fact == \"bool:false\" {\n    let conditionCode=emitExpr(ctx,conditionOp)?\n    let otherwise=optionalChild(ctx.table,op,\"else\")?\n    if otherwise == None {\n      if fact == \"bool:false\" { return Ok(Code { rs:\"\\{ let _ = {conditionCode.rs}; () \\}\",repr: Repr.Unit }) }\n      let code=emitExpr(ctx,child(ctx.table,op,\"then\")?)?\n      return Ok(Code { rs:\"\\{ let _ = {conditionCode.rs}; let _ = {code.rs}; () \\}\",repr: Repr.Unit })\n    }\n    let selected=if fact == \"bool:true\" { Some(child(ctx.table,op,\"then\")?) } else { optionalChild(ctx.table,op,\"else\")? }\n    match selected {\n      case Some(branch) => {\n        let code=emitExpr(ctx,branch)?\n        let target=operationReprOfCached(ctx.table.reprs, op, false)\n        let repr=if target == Repr.Untyped { code.repr } else { target }\n        return Ok(Code { rs:\"\\{ let _ = {conditionCode.rs}; {into(code,repr,op)?} \\}\",repr:repr })\n      }\n      case None => return Ok(Code { rs:\"\\{ let _ = {conditionCode.rs}; () \\}\",repr: Repr.Unit })\n    }\n  }\n  let condition = emitExpr(ctx, child(ctx.table, op, \"condition\")?)?\n  let test = if condition.repr == Repr.Bool {\n    condition.rs\n  } else {\n    \"condition_bool(&({boxCode(condition)}), \\\"if\\\", {spanOf(op)})?\"\n  }\n  let thenCode = emitExpr(ctx, child(ctx.table, op, \"then\")?)?\n  match optionalChild(ctx.table, op, \"else\")? {\n    case Some(elseOp) => {\n      let elseCode = emitExpr(ctx, elseOp)?\n      let target = operationReprOfCached(ctx.table.reprs, op, false)\n      let result = if target != Repr.Untyped {\n        target\n      } else if thenCode.repr == elseCode.repr {\n        thenCode.repr\n      } else {\n        Repr.Value\n      }\n      Ok(Code {\n        rs: \"(if {bare(test)} \\{ {bare(into(thenCode, result, op)?)} \\} else \\{ {bare(into(elseCode, result, op)?)} \\})\",\n        repr: result,\n      })\n    }\n    case None => Ok(Code {\n      rs: \"\\{ if {bare(test)} \\{ let _ = {bare(thenCode.rs)}; \\} \\}\",\n      repr: Repr.Unit,\n    })\n  }\n}\n\nexport function emitBlock(outerCtx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  emitBlockMode(outerCtx,op,false)\n}\n\nfunction emitDiscarded(ctx:Ctx, op:Stage1Operation) -> Result<Code,string> {\n  if op.kind == \"expression/for\" { return emitFor(ctx,op,false) }\n  if op.kind == \"expression/block\" || op.kind == \"expression/block-expression\" { return emitBlockMode(ctx,op,true) }\n  if op.kind == \"expression/parenthesized\" { return emitDiscarded(ctx,child(ctx.table,op,\"operand\")?) }\n  if op.kind == \"expression/if\" {\n    let conditionOp=child(ctx.table,op,\"condition\")?\n    let fact=rootFact(ctx.provenance,conditionOp.id)\n    if fact == \"bool:true\" || fact == \"bool:false\" {\n      let test=condition(ctx,conditionOp,op,\"if\")?\n      let selected=if fact == \"bool:true\" { Some(child(ctx.table,op,\"then\")?) } else { optionalChild(ctx.table,op,\"else\")? }\n      match selected {\n        case Some(branch) => { let code=emitDiscarded(ctx,branch)?; return Ok(Code { rs:\"\\{ let _ = {test}; let _ = {code.rs}; \\}\",repr: Repr.Unit }) }\n        case None => return Ok(Code { rs:\"\\{ let _ = {test}; \\}\",repr: Repr.Unit })\n      }\n    }\n    let test = condition(ctx,child(ctx.table,op,\"condition\")?,op,\"if\")?\n    let yes = emitDiscarded(ctx,child(ctx.table,op,\"then\")?)?\n    let no = match optionalChild(ctx.table,op,\"else\")? {\n      case Some(other) => {\n        let branch = emitDiscarded(ctx,other)?\n        \"else \\{ let _ = {branch.rs}; \\}\"\n      }\n      case None => \"\"\n    }\n    return Ok(Code { rs:\"\\{ if {test} \\{ let _ = {yes.rs}; \\} {no} \\}\",repr: Repr.Unit })\n  }\n  emitExpr(ctx,op)\n}\n\nfunction emitBlockMode(outerCtx: Ctx, op: Stage1Operation, discard:bool) -> Result<Code, string> {\n  // A nested block is a child scope even at module top level.\n  let ctx = Ctx { ...outerCtx, atModuleTop: false }\n  let mark = ctx.scope.length\n  let mut parts: Array<string> = []\n  // Names exist throughout the block, but their values are initialized only\n  // when execution reaches each declaration (including recursive calls).\n  for item in children(ctx.table, op, \"statements\")? {\n    if item.kind == \"function\" {\n      let rust = rustName(item.bindingName)\n      let seed = match lookup(ctx, item.bindingName) {\n        case Some(bind) => \"top_cell_set(&__seed, {boxCode(readBind(ctx, bind, declarationSpan(item), item)?)});\"\n        case None => \"\"\n      }\n      parts.push(\"let {rust} = \\{ let __seed = top_cell(); {seed} __seed \\};\")\n      pushBind(ctx, Bind { name: item.bindingName, kind: \"localfn\", rust: rust, repr: Repr.Value, mutable: false })\n    }\n  }\n  let mut ownsCleanup = false\n  for item in children(ctx.table, op, \"statements\")? {\n    if item.kind == \"defer\" {\n      ownsCleanup = true\n    }\n  }\n  let stack = \"__defers_{op.lo}_{op.hi}\"\n  if ownsCleanup {\n    suspend(ctx.effect)\n    parts.push(\"let {stack} = defer_stack();\")\n    let mut stacks = ctx.defers\n    stacks.push(stack)\n  }\n  let mut tail: Option<Code> = None\n  let mut lastReturns = false\n  let mut position = 0\n  for id in op.operands {\n    let item = opAt(ctx.table, id)?\n    let field = fieldOf(op.operandLabels[position])\n    if field == \"tail\" || (field == \"block\" && op.operands.length == 1) {\n      tail = Some(if discard { emitDiscarded(ctx,item)? } else { emitExpr(ctx,item)? })\n    } else if field == \"statements\" {\n      parts.push(emitStatement(ctx, item)?)\n      lastReturns = item.kind == \"return\" || item.kind == \"break\" || item.kind == \"continue\"\n    } else {\n      restoreScope(ctx, mark)\n      return Err(refusal(\"shape block operand {field}\", op))\n    }\n    position += 1\n  }\n  restoreScope(ctx, mark)\n  if ownsCleanup {\n    let mut stacks = ctx.defers\n    let _ = stacks.pop()\n    match tail {\n      case Some(code) => {\n        parts.push(\"let __block_value = {bare(code.rs)};\")\n        parts.push(\"{drive(ctx, \"run_defers(&{stack}, &cx)\")};\")\n        tail = Some(Code { rs: \"__block_value\", repr: code.repr })\n      }\n      case None => if !lastReturns {\n        parts.push(\"{drive(ctx, \"run_defers(&{stack}, &cx)\")};\")\n      }\n    }\n  }\n  match tail {\n    case Some(code) => if parts.length == 0 {\n      Ok(code)\n    } else {\n      Ok(Code { rs: \"\\{ {parts.join(\" \")} {bare(code.rs)} \\}\", repr: code.repr })\n    }\n    case None => if lastReturns {\n      Ok(Code { rs: \"\\{ {parts.join(\" \")} \\}\", repr: Repr.Never })\n    } else {\n      Ok(Code { rs: \"\\{ {parts.join(\" \")} \\}\", repr: Repr.Unit })\n    }\n  }\n}\n\n// The lead is evaluated once, before the callee/receiver and written arguments.\n// Reuse the checked call's typed slots and dynamic callable boundary.\nfunction emitPipe(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let left = child(ctx.table, op, \"left\")?\n  let lead = emitExpr(ctx, left)?\n  let stage = optionalChild(ctx.table, op, \"right\")?\n  match stage {\n    case None => {\n      if op.detail == \"\" { return Err(refusal(\"ir pipe field name\", op)) }\n      let member = Stage1Operation { ...op, kind: \"expression/member\" }\n      return Ok(Code { rs: \"\\{ let __recv = {boxCode(lead)}; {memberBody(ctx, member, left, spanOf(op))?} \\}\", repr: Repr.Value })\n    }\n    case Some(right) => {\n      let mark = ctx.scope.length\n      let rust = \"__pipe_{op.lo}_{op.hi}\"\n      pushBind(ctx, Bind { name: \"_\", kind: \"local\", rust: rust, repr: lead.repr, mutable: false })\n      let result = emitPipeStage(ctx, op, right, left)\n      restoreScope(ctx, mark)\n      let code = result?\n      Ok(Code { rs: \"\\{ let {rust} = {bare(lead.rs)}; {bare(code.rs)} \\}\", repr: code.repr })\n    }\n  }\n}\n\nfunction emitPipeStage(ctx: Ctx, op: Stage1Operation, stage: Stage1Operation, left: Stage1Operation) -> Result<Code, string> {\n  let lead = Stage1Operation { ...left, kind: \"expression/placeholder\", operands: [], operandLabels: [] }\n  let mut args: Array<Stage1Operation> = []\n  let mut rows: Array<string> = []\n  for row in op.callArguments {\n    if row.startsWith(\"inserted-lead|\") {\n      args.push(lead)\n      rows.push(\"positional||-1|{left.lo}|{left.hi}\")\n    } else { rows.push(row) }\n  }\n  let callee = if stage.kind == \"expression/call\" {\n    let mut position = 0\n    for id in stage.operands {\n      let label = stage.operandLabels[position]\n      if label.startsWith(\"arguments:\") || label.contains(\"/arguments:\") {\n        args.push(opAt(ctx.table, id)?)\n      }\n      position += 1\n    }\n    child(ctx.table, stage, \"callee\")?\n  } else {\n    if args.length == 0 {\n      args.push(lead)\n      rows.push(\"positional||-1|{left.lo}|{left.hi}\")\n    }\n    stage\n  }\n  if args.length != rows.length { return Err(refusal(\"ir pipe arguments\", op)) }\n  let call = Stage1Operation {\n    ...if stage.kind == \"expression/call\" { stage } else { op },\n    callTarget: op.callTarget,\n    callMethod: op.callStageMethod,\n    callOptional: op.callOptional,\n    callArguments: rows,\n  }\n  emitCallWith(ctx, call, callee, args)\n}\n\n// The reference's zero-deadline fast paths depend on syntactic instantness,\n// not on how quickly an arbitrary future happens to complete.\nfunction instantConcurrent(ctx: Ctx, op: Stage1Operation) -> Result<bool, string> {\n  if has([\"expression/integer\", \"expression/length\", \"expression/float\", \"expression/boolean\", \"expression/null\", \"expression/unit\", \"expression/identifier\", \"expression/string-text\"], op.kind) { return Ok(true) }\n  if op.kind.startsWith(\"pattern/\") || op.kind.startsWith(\"type/\") { return Ok(true) }\n  if !has([\"expression/parenthesized\", \"expression/unary\", \"expression/binary\", \"expression/compose\", \"expression/range\", \"expression/array\", \"expression/set\", \"expression/map\", \"expression/record-literal\", \"expression/record-update\", \"expression/string\", \"expression/block\", \"expression/block-expression\", \"expression/if\", \"expression/match\", \"expression/member\", \"expression/optional-member\", \"expression/index\", \"let\", \"constant\", \"expression-statement\", \"match-case\"], op.kind) { return Ok(false) }\n  for id in op.operands {\n    if !instantConcurrent(ctx, opAt(ctx.table, id)?)? { return Ok(false) }\n  }\n  Ok(true)\n}\n\nfunction hasConcurrentExit(ctx: Ctx, op: Stage1Operation, tryOnly: bool) -> Result<bool, string> {\n  if op.kind == \"expression/lambda\" || op.kind == \"function\" { return Ok(false) }\n  if op.kind == \"expression/result-propagation\" || (!tryOnly && op.kind == \"return\") { return Ok(true) }\n  if !tryOnly {\n    for label in op.operandLabels { if label.startsWith(\"match-case-return[\") { return Ok(true) } }\n  }\n  for id in op.operands {\n    if hasConcurrentExit(ctx, opAt(ctx.table, id)?, tryOnly)? { return Ok(true) }\n  }\n  Ok(false)\n}\n\n// Each future owns its environment and cleanup stack. It starts at ambient\n// call depth; depth_scoped isolates arms without adding a synthetic call.\nfunction concurrentFuture(ctx: Ctx, owner: Stage1Operation, body: Stage1Operation) -> Result<string, string> {\n  let mut captures: Array<string> = [\"let cx = cx.with_cooperative();\", \"let g = g.clone();\"]\n  if containsPlaceholder(ctx, body)? {\n    match lookup(ctx, \"_\") {\n      case Some(bind) => captures.push(\"let {bind.rust} = {bind.rust}.clone();\")\n      case None => ()\n    }\n  }\n  let mut seen: Array<string> = []\n  for capture in capturesOf(ctx.table, owner) {\n    if capture.lo >= body.lo && capture.hi <= body.hi && !has(seen, capture.bindingName) {\n      seen.push(capture.bindingName)\n      match lookup(ctx, capture.bindingName) {\n        case Some(bind) => if bind.kind == \"local\" || bind.kind == \"shared\" || bind.kind == \"localfn\" {\n          captures.push(\"let {bind.rust} = {bind.rust}.clone();\")\n        }\n        case None => match typeDeclaration(ctx.table, capture.id, capture.bindingName)? {\n          case Some(_) => ()\n          case None => return Err(refusal(\"unresolved capture {capture.bindingName}\", capture))\n        }\n      }\n    }\n  }\n  let inner = Ctx { ...ctx, effect:newEffect(), fnRet: Repr.Value, inConst: false, atModuleTop: false, loops: [], defers: [], cooperative:true, asynchronous:true }\n  let value = emitExpr(inner, body)?\n  let result = if value.repr == Repr.Never { value.rs } else { \"Ok({boxCode(value)})\" }\n  Ok(\"\\{ {captures.join(\" \")} Box::pin(async move \\{ {result} \\}) as CallFuture \\}\")\n}\n\nfunction emitConcurrent(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  suspend(ctx.effect)\n  let timeout = optionalChild(ctx.table, op, \"timeout\")?\n  let otherwise = optionalChild(ctx.table, op, \"else\")?\n  let mut arms: Array<Stage1Operation> = []\n  let mut names: Array<string> = []\n  let mut allInstant = true\n  let mut position = 0\n  for id in op.operands {\n    let label = op.operandLabels[position]\n    if label.startsWith(\"concurrent-arm[\") {\n      let arm = opAt(ctx.table, id)?\n      arms.push(arm)\n      names.push(labelName(label))\n      if !instantConcurrent(ctx, arm)? { allInstant = false }\n    }\n    position += 1\n  }\n  let mut duration = \"\"\n  let mut zero = false\n  match timeout {\n    case Some(value) => {\n      if value.kind != \"expression/duration\" { return Err(refusal(\"concurrent timeout duration\", value)) }\n      if value.literalEncoding != \"checked-values/v1\" { return Err(refusal(\"duration literal encoding\", value)) }\n      duration = value.detail\n      zero = duration == \"0\"\n      match otherwise {\n        case None => return Err(refusal(\"concurrent timeout without else\", op))\n        case Some(block) => {\n          if hasConcurrentExit(ctx, block, false)? && !allInstant {\n            return Err(refusal(\"`return`/`?` in a concurrent else\", op))\n          }\n          if zero && allInstant && arms.length > 1 { return emitExpr(ctx, block) }\n          if zero && allInstant && arms.length == 1 && !hasConcurrentExit(ctx, block, true)? {\n            if hasConcurrentExit(ctx, arms[0], false)? { return Err(refusal(\"`return`/`?` in a concurrent arm\", op)) }\n            let arm = boxCode(emitExpr(ctx, arms[0])?)\n            let fallback = boxCode(emitExpr(ctx, block)?)\n            return Ok(Code { rs: \"\\{ match {drive(ctx, \"(async \\{ Ok::<Value, RtError>({arm}) \\})\")} \\{ Ok(__v) => Value::record([({rustStr(names[0])}.to_string(), __v)]), Err(_) => {fallback}, \\} \\}\", repr: Repr.Value })\n          }\n        }\n      }\n    }\n    case None => match otherwise {\n      case Some(block) => return Err(refusal(\"concurrent else without timeout\", op))\n      case None => ()\n    }\n  }\n  let mut entries: Array<string> = []\n  position = 0\n  for arm in arms {\n    if hasConcurrentExit(ctx, arm, false)? { return Err(refusal(\"`return`/`?` in a concurrent arm\", op)) }\n    entries.push(\"({rustStr(names[position])}.to_string(), depth_scoped({concurrentFuture(ctx, op, arm)?}, cx.clone()))\")\n    position += 1\n  }\n  let code = match otherwise {\n    case None => \"{drive(ctx, \"concurrent_join(vec![{entries.join(\", \")}])\")}?\"\n    case Some(block) => \"{drive(ctx, \"concurrent_join_timeout(cx.clone(), {duration}u64, vec![{entries.join(\", \")}], {concurrentFuture(ctx, op, block)?})\")}?\"\n  }\n  Ok(Code { rs: code, repr: Repr.Value })\n}\n\n// --- callables --------------------------------------------------------------\n\n// Parameter names, representations and guard spans of a function or lambda.\nexport record Params {\n  names: Array<string>,\n  reprs: Array<Repr>,\n  spans: Array<string>,\n  defaultIds: Array<string>,\n  variadic: bool,\n}\n\nexport function paramsOf(ctx: Ctx, op: Stage1Operation, signature: Option<SignatureId>) -> Result<Params, string> {\n  let mut names: Array<string> = []\n  let mut reprs: Array<Repr> = []\n  let mut spans: Array<string> = []\n  let mut defaults: Array<string> = []\n  let mut variadic = false\n  let mut index = 0\n  for parameter in children(ctx.table, op, \"parameters\")? {\n    let isRest = parameter.kind == \"binding/variadic-parameter\"\n    if parameter.kind != \"binding/parameter\" && !isRest { return Err(refusal(\"parameter {parameter.kind}\", parameter)) }\n    let declared = operationReprOfCached(ctx.table.reprs, parameter, true)\n    let slot = if declared != Repr.Untyped { declared } else { match signature { case Some(id) => slotReprCached(ctx.table.reprs, id, EdgeRole.Parameters, index); case None => Repr.Untyped } }\n    if slot == Repr.Untyped { return Err(refusal(\"parameter type\", parameter)) }\n    names.push(parameter.bindingName)\n    reprs.push(if isRest { variadicRepr(slot) } else { slot })\n    spans.push(spanOf(parameter))\n    let mut defaultId = \"\"\n    let mut position = 0\n    for id in op.operands {\n      if op.operandLabels[position].contains(\"/parameters:{index}/default:\") { defaultId = id }\n      position += 1\n    }\n    defaults.push(defaultId)\n    if isRest { variadic = true }\n    index += 1\n  }\n  Ok(Params { names: names, reprs: reprs, spans: spans, defaultIds: defaults, variadic: variadic })\n}\n\nexport function defaultValues(ctx: Ctx, ids: Array<string>, variadic: bool) -> Result<string, string> {\n  let mut values: Array<string> = []\n  let limit = ids.length - if variadic { 1 } else { 0 }\n  let mut index = 0\n  while index < limit {\n    if ids[index] == \"\" {\n      values.push(\"None\")\n    } else {\n      let value = boxCode(emitExpr(ctx, opAt(ctx.table, ids[index])?)?)\n      values.push(\"Some(\\{ let __default_g = g.clone(); EmittedDefault::Thunk(Rc::new(move |cx: RtCx| -> CallFuture \\{ let g = __default_g.clone(); Box::pin(async move \\{ let _ = (&cx, &g); Ok({value}) \\}) \\})) \\})\")\n    }\n    index += 1\n  }\n  Ok(\"vec![{values.join(\", \")}]\")\n}\n\nexport function restArgument(repr: Repr, span: string) -> string {\n  let element = elementRepr(repr)\n  \"__args.map(|__v| -> Result<{rustType(element)}, RtError> \\{ Ok({parameterGuard(\"__v\", element, span)}) \\}).collect::<Result<Vec<_>, RtError>>()?\"\n}\n\n// The guarded unbox of one boxed argument into a typed parameter slot. The\n// message and fault code are the interpreter's parameter guard.\nexport function argumentGuard(value: string, repr: Repr, span: string) -> string {\n  parameterGuard(value, repr, span)\n}\n\n// A boxed closure value: captured locals are cloned into the closure, module\n// state is reached through `g`, parameters are unboxed at the boundary and\n// the result is boxed.\nfunction emitClosure(\n  ctx: Ctx,\n  op: Stage1Operation,\n  params: Params,\n  body: Stage1Operation,\n) -> Result<string, string> {\n  let code = emitClosureWith(ctx,op,params,body,Repr.Untyped,Repr.Untyped)?\n  Ok(code.rs)\n}\n\n// The native callback result carrier and its call effect are independent.\nrecord ClosureCode { rs: string, repr: Repr, asynchronous: bool }\n\nfunction emitNativeCallback(ctx: Ctx, op: Stage1Operation, input: Repr) -> Result<Option<ClosureCode>,string> {\n  if op.kind != \"expression/lambda\" { return Ok(None) }\n  let signature = signatureOf(ctx.table, op)?\n  let params = paramsOf(ctx, op, signature)?\n  if params.names.length != 1 || params.variadic || params.defaultIds[0] != \"\" { return Ok(None) }\n  let result = match signature { case Some(id) => slotReprCached(ctx.table.reprs, id, EdgeRole.Result, 0); case None => Repr.Untyped }\n  if result == Repr.Untyped { return Ok(None) }\n  Ok(Some(emitClosureWith(ctx,op,params,child(ctx.table,op,\"body\")?,input,result)?))\n}\n\nfunction emitClosureWith(ctx: Ctx, op: Stage1Operation, params: Params, body: Stage1Operation, nativeInput: Repr, nativeResult: Repr) -> Result<ClosureCode,string> {\n  let mut outer: Array<string> = [\"let __cap_g = g.clone();\"]\n  let mut inner: Array<string> = [\"let g = __cap_g.clone();\"]\n  let mut seen: Array<string> = []\n  // `_` is a lexical value in a pipe argument, including an escaping lambda.\n  // It has no source declaration identity in the checked capture table.\n  if containsPlaceholder(ctx, body)? {\n    match lookup(ctx, \"_\") {\n      case Some(bind) => {\n        outer.push(\"let __cap{bind.rust} = {bind.rust}.clone();\")\n        inner.push(\"let {bind.rust} = __cap{bind.rust}.clone();\")\n      }\n      case None => ()\n    }\n  }\n  for capture in capturesOf(ctx.table, op) {\n    if !has(seen, capture.bindingName) {\n      seen.push(capture.bindingName)\n      match lookup(ctx, capture.bindingName) {\n        case Some(bind) => if bind.kind == \"local\" || bind.kind == \"shared\" || bind.kind == \"localfn\" {\n          if bind.mutable && bind.kind != \"shared\" {\n            return Err(refusal(\"capture of mutable local {bind.name}\", capture))\n          }\n          outer.push(\"let __cap{bind.rust} = {bind.rust}.clone();\")\n          inner.push(\"let {bind.rust} = __cap{bind.rust}.clone();\")\n        }\n        case None => match typeDeclaration(ctx.table, capture.id, capture.bindingName)? {\n          case Some(_) => ()\n          case None => return Err(refusal(\"unresolved capture {capture.bindingName}\", capture))\n        }\n      }\n    }\n  }\n  let defaults = defaultValues(ctx, params.defaultIds, params.variadic)?\n  let mark = ctx.scope.length\n  let effect = newEffect()\n  let asynchronous = nativeInput == Repr.Untyped || ctx.cooperative\n  let lambdaCtx = Ctx { ...ctx, effect:effect, fnRet: if op.kind == \"defer\" { Repr.Untyped } else if nativeInput != Repr.Untyped { nativeResult } else { Repr.Value }, inConst: false, atModuleTop: false, loops: [], defers: [], cooperative:asynchronous, asynchronous:asynchronous }\n  let mut prologue: Array<string> = [\"let _ = &cx;\", \"let _ = &g;\"]\n  if nativeInput != Repr.Untyped {\n    outer.push(\"let __cap_cx = cx.clone();\")\n    inner.push(\"let cx = __cap_cx.clone();\")\n    prologue.push(\"let _gd = __native_enter_call(&cx,__call_span)?;\")\n  } else if params.names.length > 0 {\n    prologue.push(\"let mut __args = args.into_iter();\")\n  } else {\n    prologue.push(\"let _ = args;\")\n  }\n  let mut quoted: Array<string> = []\n  let mut position = 0\n  for name in params.names {\n    let rust = rustName(name)\n    let isRest = params.variadic && position == params.names.length - 1\n    let value = if isRest { \"Value::array(__args.collect())\" } else { \"__args.next().expect(\\\"arity checked at the call site\\\")\" }\n    let repr = if isRest { Repr.Value } else { params.reprs[position] }\n    let native = if nativeInput == Repr.Untyped { \"\" } else if nativeInput == repr { \"__input\" } else {\n      argumentGuard(boxed(\"__input\",nativeInput),repr,params.spans[position])\n    }\n    prologue.push(\"let {rust} = {if nativeInput == Repr.Untyped { argumentGuard(value, repr, params.spans[position]) } else { native }};\")\n    if !isRest { quoted.push(rustStr(name)) }\n    pushBind(ctx, Bind { name: name, kind: \"local\", rust: rust, repr: repr, mutable: false })\n    position += 1\n  }\n  let result = emitExpr(lambdaCtx, body)\n  restoreScope(ctx, mark)\n  let bodyResult = result?\n  let bodyCode = if bodyResult.repr == Repr.Never {\n    bodyResult.rs\n  } else {\n    if nativeInput == Repr.Untyped { \"Ok({bare(boxCode(bodyResult))})\" } else { \"Ok::<{rustType(nativeResult)},RtError>({bare(into(bodyResult,nativeResult,body)?)})\" }\n  }\n  if nativeInput != Repr.Untyped {\n    for target in effect.calls {\n      call(ctx.effect,target)\n    }\n    let code = if asynchronous {\n      suspend(ctx.effect)\n      \"\\{ {outer.join(\" \")} move |__input: {rustType(nativeInput)}, __call_span: Span| \\{ {inner.join(\" \")} async move \\{ {prologue.join(\" \")} {bodyCode} \\} \\} \\}\"\n    } else {\n      \"\\{ {outer.join(\" \")} move |__input: {rustType(nativeInput)}, __call_span: Span| -> Result<{rustType(nativeResult)}, RtError> \\{ {inner.join(\" \")} {prologue.join(\" \")} {bodyCode} \\} \\}\"\n    }\n    return Ok(ClosureCode { rs:code,repr:nativeResult,asynchronous:asynchronous })\n  }\n  Ok(ClosureCode { rs:\n    \"\\{ {outer.join(\" \")} Value::Closure(Rc::new(EmittedClosure \\{ call: move |cx: RtCx, args: Vec<Value>| -> CallFuture \\{ {inner.join(\" \")} Box::pin(async move \\{ {prologue.join(\" \")} {bodyCode} \\}) \\}, params: &[{quoted.join(\", \")}], defaults: {defaults}, variadic: {params.variadic} \\})) \\}\", repr: Repr.Value, asynchronous:true })\n}\n\nfunction emitLambda(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let params = paramsOf(ctx, op, signatureOf(ctx.table, op)?)?\n  let body = child(ctx.table, op, \"body\")?\n  Ok(Code { rs: emitClosure(ctx, op, params, body)?, repr: Repr.Value })\n}\n\nfunction containsPlaceholder(ctx: Ctx, op: Stage1Operation) -> Result<bool, string> {\n  if op.kind == \"expression/placeholder\" { return Ok(true) }\n  for id in op.operands {\n    if containsPlaceholder(ctx, opAt(ctx.table, id)?)? { return Ok(true) }\n  }\n  Ok(false)\n}\n\n// Control transfers drain the crossed lexical scopes after evaluating their\n// value. Runtime faults skip cleanup, as in the reference backend.\nfunction drain(ctx: Ctx, from: int) -> string {\n  if ctx.defers.length > from { suspend(ctx.effect) }\n  let mut result = \"\"\n  let mut index = ctx.defers.length - 1\n  while index >= from {\n    result = result + \"{drive(ctx, \"run_defers(&{ctx.defers[index]}, &cx)\")}; \"\n    index -= 1\n  }\n  result\n}\n\nfunction condition(ctx: Ctx, op: Stage1Operation, owner: Stage1Operation, kind: string) -> Result<string, string> {\n  let value = emitExpr(ctx, op)?\n  if value.repr == Repr.Bool {\n    Ok(bare(value.rs))\n  } else {\n    Ok(\"condition_bool(&({boxCode(value)}), {rustStr(kind)}, {spanOf(owner)})?\")\n  }\n}\n\nfunction emitWhile(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  if ctx.cooperative { suspend(ctx.effect) }\n  let test = condition(ctx, child(ctx.table, op, \"condition\")?, op, \"while\")?\n  let label = \"'__loop_{op.lo}_{op.hi}\"\n  let mut loops = ctx.loops\n  loops.push(LoopFrame { id: op.id, label: label, repr: Repr.Untyped, cleanup: ctx.defers.length })\n  let body = emitDiscarded(ctx, child(ctx.table, op, \"body\")?)\n  let _ = loops.pop()\n  let code = body?\n  Ok(\"{label}: while {test} \\{ {loopCheckpoint(ctx)} let _ = {bare(code.rs)}; \\}\")\n}\n\nfunction emitLoop(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  if ctx.cooperative { suspend(ctx.effect) }\n  let target = operationReprOfCached(ctx.table.reprs, op, false)\n  let repr = if target == Repr.Untyped { Repr.Value } else { target }\n  let label = \"'__loop_{op.lo}_{op.hi}\"\n  let mut loops = ctx.loops\n  loops.push(LoopFrame { id: op.id, label: label, repr: repr, cleanup: ctx.defers.length })\n  let body = emitDiscarded(ctx, child(ctx.table, op, \"body\")?)\n  let _ = loops.pop()\n  let code = body?\n  Ok(Code { rs: \"({label}: loop \\{ {loopCheckpoint(ctx)} let _ = {bare(code.rs)}; \\})\", repr: repr })\n}\n\nfunction emitLoopControl(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  let mut index = ctx.loops.length - 1\n  while index >= 0 {\n    let frame = ctx.loops[index]\n    if op.controlTarget == frame.id {\n      let cleanup = drain(ctx, frame.cleanup)\n      if op.kind == \"continue\" {\n        return Ok(\"{cleanup}continue {frame.label};\")\n      }\n      let value = match optionalChild(ctx.table, op, \"value\")? {\n        case Some(found) => emitExpr(ctx, found)?\n        case None => Code { rs: \"()\", repr: Repr.Unit }\n      }\n      if frame.repr == Repr.Untyped {\n        return Ok(\"let _ = {value.rs}; {cleanup}break {frame.label};\")\n      }\n      return Ok(\"let __break_value = {bare(into(value, frame.repr, op)?)}; {cleanup}break {frame.label} __break_value;\")\n    }\n    index -= 1\n  }\n  Err(refusal(\"ir loop target {op.controlTarget}\", op))\n}\n\nfunction emitRange(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let lo = emitExpr(ctx, child(ctx.table, op, \"low\")?)?\n  let hi = emitExpr(ctx, child(ctx.table, op, \"high\")?)?\n  let step = match optionalChild(ctx.table, op, \"step\")? {\n    case Some(value) => emitExpr(ctx, value)?\n    case None => Code { rs: \"1i64\", repr: Repr.I64 }\n  }\n  if lo.repr == Repr.I64 && hi.repr == Repr.I64 && step.repr == Repr.I64 {\n    return Ok(Code {\n      rs: \"\\{ let __lo: i64 = {bare(lo.rs)}; let __hi: i64 = {bare(hi.rs)}; let __step: i64 = {bare(step.rs)}; if __step == 0 \\{ return Err(fault(codes::FAULT_RANGE_STEP, \\\"range step must not be zero (§10)\\\", {spanOf(op)})); \\} (__lo, __hi, {op.detail}, __step) \\}\",\n      repr: Repr.RangeInt,\n    })\n  }\n  finish(ctx, Code { rs: \"make_range({boxCode(lo)}, {boxCode(hi)}, {op.detail}, Some({boxCode(step)}), {spanOf(op)})?\", repr: Repr.Value }, op)\n}\n\nrecord Iteration {\n  setup: string,\n  values: string,\n  repr: Repr,\n  fallible: bool = false,\n}\n\n// Statically integer ranges use checked i64 counters. Collection iteration\n// takes the same snapshot as `for_items`, preserving mutation semantics.\nfunction iteration(ctx: Ctx, op: Stage1Operation, owner: Stage1Operation) -> Result<Iteration, string> {\n  match scalarReceiver(ctx,op)? {\n    case Some(receiver) => {\n      let source = emitExpr(ctx,receiver)?\n      let fallback = scalarFallback(ctx,op,receiver)?\n      if source.repr == Repr.Text {\n        return Ok(Iteration {\n          setup:\"let __text = {source.rs}; let __scalars = if __text.with_str(|_| ()).is_some() \\{ NativeTextItems::text(__text) \\} else \\{ let __recv = NativeValue::into_value(__text); NativeTextItems::values(for_items(&({fallback}),{spanOf(owner)})?) \\};\",\n          values:\"__scalars\",repr: Repr.Text,\n        })\n      }\n      return Ok(Iteration {\n        setup:\"let __recv = {boxCode(source)}; let __scalars = match __recv \\{ Value::Str(__text) => NativeTextItems::text(NativeText::Shared(__text)), __recv => NativeTextItems::values(for_items(&({fallback}),{spanOf(owner)})?) \\};\",\n        values:\"__scalars\",repr: Repr.Text,\n      })\n    }\n    case None => ()\n  }\n  let value = emitExpr(ctx, op)?\n  if isArray(value.repr) && owner.kind == \"expression/for\" {\n    let pattern = child(ctx.table,owner,\"pattern\")?\n    if pattern.kind == \"pattern/binding\" {\n      return Ok(Iteration { setup:\"\",values:\"({value.rs}).items_at({spanOf(owner)},{spanOf(pattern)})?\",repr:elementRepr(value.repr),fallible:true })\n    }\n  }\n  if value.repr == Repr.RangeInt {\n    return Ok(Iteration {\n      setup: \"let (__lo, __hi, __inclusive, __step) = {bare(value.rs)}; if __step == 0 \\{ return Err(fault(codes::FAULT_RANGE_STEP, \\\"range step must not be zero (§10)\\\", {spanOf(owner)})); \\}\",\n      values: \"std::iter::successors(Some(__lo), move |v| v.checked_add(__step)).take_while(move |v| if __step > 0 \\{ if __inclusive \\{ *v <= __hi \\} else \\{ *v < __hi \\} \\} else if __inclusive \\{ *v >= __hi \\} else \\{ *v > __hi \\})\",\n      repr: Repr.I64,\n    })\n  }\n  Ok(Iteration { setup: \"\", values: \"native_for_items(&({boxCode(value)}), {spanOf(owner)})?\", repr: Repr.Value })\n}\n\nfunction iterationBinding(ctx: Ctx, pattern: Stage1Operation, repr: Repr, owner: Stage1Operation, fallible: bool = false) -> Result<string, string> {\n  if fallible {\n    let binding = iterationBinding(ctx,pattern,repr,owner)?\n    return Ok(\"let __item = __item?; {binding}\")\n  }\n  if pattern.kind == \"pattern/wildcard\" {\n    return Ok(\"let _ = __item;\")\n  }\n  if pattern.kind != \"pattern/binding\" {\n    return emitPatternLet(ctx, owner, pattern, Code { rs: \"__item\", repr: repr }, true)\n  }\n  let name = rustName(pattern.bindingName)\n  let declared = operationReprOfCached(ctx.table.reprs, pattern, false)\n  let target = if declared == Repr.Untyped { repr } else { declared }\n  let read = into(Code { rs: \"__item\", repr: repr }, target, pattern)?\n  pushBind(ctx, Bind { name: pattern.bindingName, kind: \"local\", rust: name, repr: target, mutable: false })\n  Ok(\"let {name}: {rustType(target)} = {bare(read)};\")\n}\n\nfunction emitFor(ctx: Ctx, op: Stage1Operation, collect: bool) -> Result<Code, string> {\n  let iter = iteration(ctx, child(ctx.table, op, \"iterator\")?, op)?\n  let mark = ctx.scope.length\n  let binding = iterationBinding(ctx, child(ctx.table, op, \"pattern\")?, iter.repr, op, iter.fallible)?\n  let label = \"'__loop_{op.lo}_{op.hi}\"\n  let mut loops = ctx.loops\n  if !collect {\n    loops.push(LoopFrame { id: op.id, label: label, repr: Repr.Untyped, cleanup: ctx.defers.length })\n  }\n  let bodyOp = child(ctx.table,op,\"body\")?\n  let body = if collect { emitExpr(ctx,bodyOp) } else { emitDiscarded(ctx,bodyOp) }\n  if !collect {\n    let _ = loops.pop()\n  }\n  restoreScope(ctx, mark)\n  let code = body?\n  if collect {\n    Ok(Code { rs: \"\\{ {iter.setup} let mut __acc: Vec<Value> = Vec::new(); for __item in {iter.values} \\{ {binding} __acc.push({boxCode(code)}); \\} Value::array(__acc) \\}\", repr: Repr.Value })\n  } else {\n    Ok(Code { rs: \"\\{ {iter.setup} {label}: for __item in {iter.values} \\{ {binding} let _ = {bare(code.rs)}; \\} \\}\", repr: Repr.Unit })\n  }\n}\n\nfunction comprehensionClauses(ctx: Ctx, op: Stage1Operation, position: int) -> Result<string, string> {\n  if position >= op.operands.length {\n    if op.detail == \"map\" {\n      let key = boxCode(emitExpr(ctx, child(ctx.table, op, \"bodyKey\")?)?)\n      let value = boxCode(emitExpr(ctx, child(ctx.table, op, \"bodyValue\")?)?)\n      return Ok(\"__acc.push(({key}, {value}));\")\n    }\n    return Ok(\"__acc.push({boxCode(emitExpr(ctx, child(ctx.table, op, \"body\")?)?)});\")\n  }\n  let field = fieldOf(op.operandLabels[position])\n  let current = opAt(ctx.table, op.operands[position])?\n  if field == \"iterator\" {\n    let iter = iteration(ctx, current, op)?\n    let pattern = opAt(ctx.table, op.operands[position + 1])?\n    let mark = ctx.scope.length\n    let binding = iterationBinding(ctx, pattern, iter.repr, op, iter.fallible)?\n    let inner = comprehensionClauses(ctx, op, position + 2)\n    restoreScope(ctx, mark)\n    return Ok(\"\\{ {iter.setup} for __item in {iter.values} \\{ {binding} {inner?} \\} \\}\")\n  }\n  if field == \"condition\" {\n    let test = condition(ctx, current, op, \"if\")?\n    return Ok(\"if {test} \\{ {comprehensionClauses(ctx, op, position + 1)?} \\}\")\n  }\n  comprehensionClauses(ctx, op, position + 1)\n}\n\nfunction emitComprehension(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let inner = comprehensionClauses(ctx, op, 0)?\n  let result = match op.detail {\n    case \"array\" => \"Value::array(__acc)\"\n    case \"set\" => \"builtin_set_of(__acc, {spanOf(op)})?\"\n    case \"map\" => \"builtin_map_of(__acc, {spanOf(op)})?\"\n    case _ => return Err(refusal(\"ir collection {op.detail}\", op))\n  }\n  Ok(Code { rs: \"\\{ let mut __acc = Vec::new(); {inner} {result} \\}\", repr: Repr.Value })\n}\n\nfunction emitTry(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let operandOp = child(ctx.table, op, \"operand\")?\n  let operand = emitExpr(ctx, operandOp)?\n  if isResult(operand.repr) && ctx.fnRet != Repr.Untyped {\n    let fallback = resultParts(operand.repr)\n    let parts = [sumPayloadRepr(ctx,operandOp,operand.repr,\"Ok\",fallback[0]),\n      sumPayloadRepr(ctx,operandOp,operand.repr,\"Err\",fallback[1])]\n    let early = into(Code { rs:\"NativeResult::<Value, _>::Err(__error)\",repr:resultRepr(Repr.Value,parts[1]) },ctx.fnRet,op)?\n    let dynamicEarly = into(Code { rs:\"__early\",repr: Repr.Value },ctx.fnRet,op)?\n    let dynamicValue = unboxed(\"__value\",parts[0],spanOf(op))\n    return Ok(Code { rs:\"match {operand.rs} \\{ NativeResult::Ok(__value) => __value, NativeResult::Err(__error) => \\{ {drain(ctx,0)}return Ok({early}); \\}, NativeResult::Dynamic(__dynamic) => match try_value(__dynamic,{spanOf(op)})? \\{ Ok(__value) => {dynamicValue}, Err(__early) => \\{ {drain(ctx,0)}return Ok({dynamicEarly}); \\} \\} \\}\",repr:parts[0] })\n  }\n  let value = boxCode(operand)\n  if ctx.fnRet == Repr.Untyped {\n    return Err(refusal(\"return outside a function\", op))\n  }\n  let early = into(Code { rs: \"__early\", repr: Repr.Value }, ctx.fnRet, op)?\n  Ok(Code { rs: \"match try_value({value}, {spanOf(op)})? \\{ Ok(__value) => __value, Err(__early) => \\{ {drain(ctx, 0)}return Ok({early}); \\} \\}\", repr: Repr.Value })\n}\n\nfunction emitDefer(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  if ctx.defers.length == 0 {\n    return Err(refusal(\"defer outside a function body\", op))\n  }\n  let body = child(ctx.table, op, \"value\")?\n  let action = emitClosure(ctx, op, Params { names: [], reprs: [], spans: [], defaultIds: [], variadic: false }, body)?\n  Ok(\"defer_push(&{ctx.defers[ctx.defers.length - 1]}, {action});\")\n}\n\nfunction emitUsing(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  suspend(ctx.effect)\n  let value = boxCode(emitExpr(ctx, child(ctx.table, op, \"value\")?)?)\n  let name = rustName(op.bindingName)\n  let stack = \"__using_{op.lo}_{op.hi}\"\n  let span = spanOf(op)\n  let mark = ctx.scope.length\n  pushBind(ctx, Bind { name: op.bindingName, kind: \"local\", rust: name, repr: Repr.Value, mutable: false })\n  let mut stacks = ctx.defers\n  stacks.push(stack)\n  let body = emitExpr(ctx, child(ctx.table, op, \"body\")?)\n  let _ = stacks.pop()\n  restoreScope(ctx, mark)\n  let code = body?\n  let close = \"\\{ let __resource = {name}.clone(); Value::Closure(Rc::new(EmittedClosure \\{ call: move |cx: RtCx, _args: Vec<Value>| -> CallFuture \\{ let __resource = __resource.clone(); Box::pin(async move \\{ call_resource_method(&*cx.host(), __resource, \\\"close\\\", vec![], {span}, {span}) \\}) \\}, params: &[], defaults: Vec::new(), variadic: false \\})) \\}\"\n  Ok(\"\\{ let {stack} = defer_stack(); let {name} = {value}; if {name}.kind() != \\\"File\\\" \\{ return Err(fault(codes::GUARD_TYPE, format!(\\\"`using` expects a `File`, found `\\{\\}`\\\", {name}.kind()), {span})); \\} defer_push(&{stack}, {close}); let __using_value = {bare(code.rs)}; {drive(ctx, \"run_defers(&{stack}, &cx)\")}; let _ = __using_value; \\}\")\n}\n\n// --- statements -----------------------------------------------------------\n\nexport function emitStatement(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  match op.kind {\n    case \"let\" => emitLet(ctx, op)\n    case \"constant\" => emitConstant(ctx, op)\n    case \"assignment\" => emitAssignment(ctx, op)\n    case \"expression/block\" => {\n      let expression = child(ctx.table, op, \"value\")?\n      let value = emitDiscarded(ctx,expression)?\n      Ok(\"let _ = {value.rs};\")\n    }\n    case \"while\" => emitWhile(ctx, op)\n    case \"break\" => emitLoopControl(ctx, op)\n    case \"continue\" => emitLoopControl(ctx, op)\n    case \"defer\" => emitDefer(ctx, op)\n    case \"using\" => emitUsing(ctx, op)\n    case \"return\" => {\n      if ctx.fnRet == Repr.Untyped {\n        return Err(refusal(\"return outside a function\", op))\n      }\n      match optionalChild(ctx.table, op, \"value\")? {\n        case Some(value) => Ok(\"let __return_value = {bare(into(emitExpr(ctx, value)?, ctx.fnRet, value)?)}; {drain(ctx, 0)}return Ok(__return_value);\")\n        case None => Ok(\"{drain(ctx, 0)}return Ok({into(Code { rs: \"()\", repr: Repr.Unit }, ctx.fnRet, op)?});\")\n      }\n    }\n    case \"function\" => emitLocalFunction(ctx, op)\n    case \"type-alias\" => Ok(\"\")\n    case \"record\" => Ok(\"\")\n    case \"enum\" => Ok(\"\")\n    case \"newtype\" => Ok(\"\")\n    case \"protocol\" => Ok(\"\")\n    case \"implementation\" => emitImplementation(ctx, op)\n    case _ => Err(refusal(\"kind {op.kind}\", op))\n  }\n}\n\n// Pattern checks return owned bindings before the arm guard/body is evaluated,\n// so a list's temporary borrow never survives into user code.\nrecord PatternPlan {\n  conditions: Array<string>,\n  reads: Array<string>,\n  bindings: Array<Stage1Operation>,\n  reprs: Array<Repr>,\n}\n\nfunction emptyPattern() -> PatternPlan {\n  PatternPlan { conditions: [], reads: [], bindings: [], reprs: [] }\n}\n\nfunction addPattern(plan: PatternPlan, nested: PatternPlan) -> () {\n  let mut conditions = plan.conditions\n  let mut reads = plan.reads\n  let mut bindings = plan.bindings\n  let mut reprs = plan.reprs\n  for item in nested.conditions { conditions.push(item) }\n  for item in nested.reads { reads.push(item) }\n  for item in nested.bindings { bindings.push(item) }\n  for item in nested.reprs { reprs.push(item) }\n  ()\n}\n\nfunction patternCondition(plan: PatternPlan) -> string {\n  if plan.conditions.length == 0 { \"true\" } else { plan.conditions.join(\" && \") }\n}\n\nfunction tupleOf(items: Array<string>) -> string {\n  if items.length == 0 { \"()\" } else { \"({items.join(\", \")},)\" }\n}\n\nfunction extraction(plan: PatternPlan) -> string {\n  \"if {patternCondition(plan)} \\{ Some({tupleOf(plan.reads)}) \\} else \\{ None \\}\"\n}\n\nfunction planPattern(ctx: Ctx, pattern: Stage1Operation, value: Code, span: string) -> Result<PatternPlan, string> {\n  let plan = emptyPattern()\n  let mut conditions = plan.conditions\n  let mut reads = plan.reads\n  let mut bindings = plan.bindings\n  let mut reprs = plan.reprs\n  let access = value.rs\n  // Pattern tests borrow the scrutinee: a failed arm must leave it available\n  // to later arms. Concrete carriers own shared storage, so project a clone\n  // when the pattern crosses the dynamic matching boundary.\n  let projected = boxCode(Code { rs: if isCopyRepr(value.repr) || value.repr == Repr.Value { access } else { \"({access}).clone()\" }, repr: value.repr })\n  let stem = \"__p{pattern.lo}_{pattern.hi}\"\n  if pattern.kind == \"pattern/wildcard\" { return Ok(plan) }\n  if pattern.kind == \"pattern/binding\" || pattern.kind == \"pattern/typed-binding\" {\n    if pattern.kind == \"pattern/typed-binding\" {\n      conditions.push(\"({typeTest(ctx.table, pattern.id, pattern.semanticTypeAtoms, 0, access, value.repr)?})\")\n    }\n    let repr = bindingRepr(ctx, pattern, value)\n    reads.push(into(Code { rs: if isCopyRepr(value.repr) { access } else { \"({access}).clone()\" }, repr: value.repr }, repr, pattern)?)\n    bindings.push(pattern)\n    reprs.push(repr)\n    return Ok(plan)\n  }\n  if pattern.kind == \"pattern/literal\" {\n    let literalOp = child(ctx.table, pattern, \"value\")?\n    let literal = emitExpr(ctx, literalOp)?\n    if value.repr == Repr.Text && literal.repr == Repr.Text {\n      match stringLiteral(ctx,literalOp)? {\n        case Some(text) => {\n          conditions.push(\"({access}).matches_literal({rustStr(text)}, {span})?\")\n          return Ok(plan)\n        }\n        case None => ()\n      }\n    }\n    let test = if isCopyRepr(value.repr) && value.repr == literal.repr {\n      \"({access}) == ({literal.rs})\"\n    } else {\n      \"values_equal(&({boxCode(literal)}), &({projected})).map_err(|e| cmp_guard(e, {span}))?\"\n    }\n    conditions.push(test)\n    return Ok(plan)\n  }\n  if pattern.kind == \"pattern/range\" {\n    let low = emitExpr(ctx, child(ctx.table, pattern, \"low\")?)?\n    let high = emitExpr(ctx, child(ctx.table, pattern, \"high\")?)?\n    let cmp = if pattern.detail == \"true\" { \"<=\" } else { \"<\" }\n    if value.repr == Repr.I64 {\n      conditions.push(\"({access}) >= ({low.rs}) && ({access}) {cmp} ({high.rs})\")\n    } else {\n      conditions.push(\"matches!(&({projected}), Value::Int(__n) if *__n >= ({low.rs}) && *__n {cmp} ({high.rs}))\")\n    }\n    return Ok(plan)\n  }\n  if pattern.kind == \"pattern/alternatives\" {\n    let mut chain: Array<string> = []\n    let mut alternatives: Array<PatternPlan> = []\n    let mut canonical: Array<Stage1Operation> = []\n    let mut targets: Array<Repr> = []\n    for id in pattern.operands {\n      let sub = planPattern(ctx, opAt(ctx.table, id)?, value, span)?\n      if alternatives.length == 0 {\n        canonical = sub.bindings\n        for repr in sub.reprs { targets.push(repr) }\n      }\n      alternatives.push(sub)\n      let mut position = 0\n      for binding in canonical {\n        let mut index = 0\n        for other in sub.bindings {\n          if other.bindingName == binding.bindingName && targets[position] != sub.reprs[index] {\n            targets[position] = Repr.Value\n          }\n          index += 1\n        }\n        position += 1\n      }\n    }\n    for sub in alternatives {\n      let mut ordered: Array<string> = []\n      let mut position = 0\n      for binding in canonical {\n        let mut found = false\n        let mut index = 0\n        for other in sub.bindings {\n          if other.bindingName == binding.bindingName {\n            ordered.push(into(Code { rs: sub.reads[index], repr: sub.reprs[index] }, targets[position], other)?)\n            found = true\n          }\n          index += 1\n        }\n        if !found { return Err(refusal(\"alternative binding {binding.bindingName}\", pattern)) }\n        position += 1\n      }\n      chain.push(\"if {patternCondition(sub)} \\{ Some({tupleOf(ordered)}) \\} else \")\n    }\n    let mut temps: Array<string> = []\n    let mut position = 0\n    for binding in canonical {\n      let temp = \"{stem}_{position}\"\n      temps.push(temp)\n      reads.push(temp)\n      bindings.push(binding)\n      reprs.push(targets[position])\n      position += 1\n    }\n    conditions.push(\"let Some({tupleOf(temps)}) = \\{ {chain.join(\"\")} \\{ None \\} \\}\")\n    return Ok(plan)\n  }\n  if pattern.kind == \"pattern/constructor\" {\n    let name = pattern.detail\n    let enums = patternNominals(pattern, \"enum\")\n    let newtypes = patternNominals(pattern, \"newtype\")\n    if isOption(value.repr) && name == \"None\" {\n      conditions.push(\"matches!(&({access}), NativeOption::None | NativeOption::Dynamic(Value::None))\")\n      return Ok(plan)\n    }\n    if ((isOption(value.repr) && name == \"Some\") || (isResult(value.repr) && (name == \"Ok\" || name == \"Err\"))) && pattern.operands.length == 1 {\n      let sub = opAt(ctx.table,pattern.operands[0])?\n      let fallbackRepr = if isResult(value.repr) { resultParts(value.repr)[if name == \"Ok\" { 0 } else { 1 }] } else { elementRepr(value.repr) }\n      let payload = sumPayloadRepr(ctx,pattern,value.repr,name,fallbackRepr)\n      let carrier = if isResult(value.repr) { \"NativeResult\" } else { \"NativeOption\" }\n      let typed = planPattern(ctx,sub,Code { rs:\"(*{stem})\",repr:payload },span)?\n      let dynamic = planPattern(ctx,sub,Code { rs:\"(**{stem})\",repr: Repr.Value },span)?\n      let mut values: Array<string> = []\n      let mut temps: Array<string> = []\n      let mut at = 0\n      for binding in typed.bindings {\n        let repr = typed.reprs[at]\n        values.push(into(Code { rs:dynamic.reads[at],repr:dynamic.reprs[at] },repr,binding)?)\n        let temp = \"{stem}_binding{at}\"\n        temps.push(temp); reads.push(temp); bindings.push(binding); reprs.push(repr)\n        at += 1\n      }\n      let fallback = \"if {patternCondition(dynamic)} \\{ Some({tupleOf(values)}) \\} else \\{ None \\}\"\n      conditions.push(\"let Some({tupleOf(temps)}) = match &({access}) \\{ {carrier}::{name}({stem}) => \\{ {extraction(typed)} \\}, {carrier}::Dynamic(Value::{name}({stem})) => \\{ {fallback} \\}, _ => None \\}\")\n      return Ok(plan)\n    }\n    if isEnum(value.repr) && has(enums,reprIdentity(value.repr)) {\n      match enumLayout(ctx.table,value.repr) {\n        case Some(layout) => {\n          for variant in layout.variants {\n            if variant.name == name {\n              let mut payloadNames:Array<string> = []\n              let typed = emptyPattern()\n              let mut ordinal = 0\n              for payload in variant.payloads {\n                if ordinal >= pattern.operands.length { return Err(refusal(\"enum pattern arity\",pattern)) }\n                let local = \"{stem}_payload{ordinal}\"\n                payloadNames.push(local)\n                addPattern(typed,planPattern(ctx,opAt(ctx.table,pattern.operands[ordinal])?,Code { rs:\"(*{local})\",repr:payload.value.repr },span)?)\n                ordinal += 1\n              }\n              if ordinal != pattern.operands.length { return Err(refusal(\"enum pattern arity\",pattern)) }\n              let dynamic = planPattern(ctx,pattern,Code { rs:projected,repr: Repr.Value },span)?\n              let mut values:Array<string> = []\n              let mut temps:Array<string> = []\n              let mut at = 0\n              for binding in typed.bindings {\n                values.push(into(Code { rs:dynamic.reads[at],repr:dynamic.reprs[at] },typed.reprs[at],binding)?)\n                let temp = \"{stem}_binding{at}\"\n                temps.push(temp); reads.push(temp); bindings.push(binding); reprs.push(typed.reprs[at])\n                at += 1\n              }\n              let payload = if payloadNames.length == 0 { \"\" } else { \"({payloadNames.join(\", \")})\" }\n              let fallback = \"if {patternCondition(dynamic)} \\{ Some({tupleOf(values)}) \\} else \\{ None \\}\"\n              conditions.push(\"let Some({tupleOf(temps)}) = match ({access}).concrete() \\{ Some({nominalRustName(value.repr)}::V{variant.variantIndex}{payload}) => \\{ {extraction(typed)} \\}, Some(_) => None, None => \\{ {fallback} \\} \\}\")\n              return Ok(plan)\n            }\n          }\n        }\n        case None => ()\n      }\n    }\n    if name == \"None\" {\n      conditions.push(\"matches!(&({projected}), Value::None)\")\n      return Ok(plan)\n    }\n    if (name == \"Some\" || name == \"Ok\" || name == \"Err\") && pattern.operands.length == 1 {\n      conditions.push(\"let Value::{name}({stem}) = &({projected})\")\n      addPattern(plan, planPattern(ctx, opAt(ctx.table, pattern.operands[0])?, Code { rs: \"(**{stem})\", repr: Repr.Value }, span)?)\n      return Ok(plan)\n    }\n    let mut owners: Array<string> = []\n    if enums.length > 0 {\n      for identity in enums { owners.push(rustStr(identity)) }\n      conditions.push(\"let Value::Enum \\{ enum_id: {stem}_id, declaration_identity: {stem}_decl, variant: {stem}_tag, payloads: {stem}_args, .. \\} = &({projected})\")\n      conditions.push(\"[{owners.join(\", \")}].contains(&nominal_declaration_identity({stem}_id.as_ref(), {stem}_decl.as_deref())) && {stem}_tag.as_ref() == {rustStr(name)}\")\n      let arity = pattern.operands.length\n      conditions.push(\"\\{ if {stem}_args.len() != {arity} \\{ return Err(fault(codes::GUARD_ARITY, format!(\\\"enum variant `{name}` pattern takes \\{\\} subpattern\\{\\}\\\", {stem}_args.len(), if {stem}_args.len() == 1 \\{ \\\"\\\" \\} else \\{ \\\"s\\\" \\}), {span})); \\} true \\}\")\n      let mut index = 0\n      for id in pattern.operands {\n        addPattern(plan, planPattern(ctx, opAt(ctx.table, id)?, Code { rs: \"{stem}_args[{index}]\", repr: Repr.Value }, span)?)\n        index += 1\n      }\n      return Ok(plan)\n    }\n    if newtypes.length > 0 && pattern.operands.length == 1 {\n      let declaration = match typeDeclaration(ctx.table, pattern.id, name)? {\n        case Some(found) => found\n        case None => return Err(refusal(\"newtype declaration {name}\", pattern))\n      }\n      if isNewtype(value.repr) && reprIdentity(value.repr) == nominalIdentity(declaration.typeDefinition[0]) {\n        let typed = planPattern(ctx,opAt(ctx.table,pattern.operands[0])?,Code { rs:\"{stem}_native.f0\",repr:newtypeBase(ctx.table,value.repr) },span)?\n        let dynamic = planPattern(ctx,pattern,Code { rs:projected,repr:Repr.Value },span)?\n        let mut values:Array<string> = []\n        let mut temps:Array<string> = []\n        let mut at = 0\n        for binding in typed.bindings {\n          values.push(into(Code { rs:dynamic.reads[at],repr:dynamic.reprs[at] },typed.reprs[at],binding)?)\n          let temp = \"{stem}_binding{at}\"\n          temps.push(temp); reads.push(temp); bindings.push(binding); reprs.push(typed.reprs[at])\n          at += 1\n        }\n        let fallback = \"if {patternCondition(dynamic)} \\{ Some({tupleOf(values)}) \\} else \\{ None \\}\"\n        conditions.push(\"let Some({tupleOf(temps)}) = if let Some({stem}_native) = ({access}).concrete() \\{ {extraction(typed)} \\} else \\{ {fallback} \\}\")\n        return Ok(plan)\n      }\n      owners.push(rustStr(declaration.typeDefinition[0].identity))\n      conditions.push(\"let Value::Newtype \\{ newtype_id: {stem}_id, declaration_identity: {stem}_decl, inner: {stem}_inner, .. \\} = &({projected})\")\n      conditions.push(\"[{owners.join(\", \")}].contains(&nominal_declaration_identity({stem}_id.as_ref(), {stem}_decl.as_deref()))\")\n      addPattern(plan, planPattern(ctx, opAt(ctx.table, pattern.operands[0])?, Code { rs: \"(**{stem}_inner)\", repr: Repr.Value }, span)?)\n      return Ok(plan)\n    }\n    return Err(refusal(\"constructor {name}\", pattern))\n  }\n  if pattern.kind == \"pattern/record\" || pattern.kind == \"pattern/nominal-record\" {\n    let nominal = pattern.kind == \"pattern/nominal-record\"\n      if nominal {\n        let mut tests: Array<string> = []\n        let declaredIdentity = match typeDeclaration(ctx.table, pattern.id, pattern.detail)? {\n          case Some(decl) => decl.typeDefinition[0].identity\n          case None => pattern.referenceIdentity\n        }\n        for identity in patternNominals(pattern, \"nominal-record\") {\n          if declaredIdentity == \"\" || identity == declaredIdentity {\n          tests.push(\"{stem}.is_nominal_record_declaration({rustStr(identity)})\")\n        }\n      }\n      if tests.length == 0 { return Err(refusal(\"nominal record identity\", pattern)) }\n      conditions.push(\"let {stem} = &({projected})\")\n      conditions.push(\"({tests.join(\" || \")})\")\n    } else {\n      conditions.push(\"let Value::Record({stem}) = &({projected})\")\n    }\n    let mut position = 0\n    for id in pattern.operands {\n      let label = pattern.operandLabels[position]\n      let temp = \"{stem}_{position}\"\n      let method = if nominal { \"nominal_field\" } else { \"get\" }\n      conditions.push(\"let Some({temp}) = {stem}.{method}({rustStr(labelName(label))})\")\n      addPattern(plan, planPattern(ctx, opAt(ctx.table, id)?, Code { rs: \"(*{temp})\", repr: Repr.Value }, span)?)\n      position += 1\n    }\n    return Ok(plan)\n  }\n  if pattern.kind == \"pattern/list\" {\n    conditions.push(\"let Value::Array({stem}) = &({projected})\")\n    let mut shape: Array<string> = []\n    let mut position = 0\n    for label in pattern.operandLabels {\n      let temp = \"{stem}_{position}\"\n      shape.push(if label.startsWith(\"list-pattern/rest[\") { \"{temp} @ ..\" } else { temp })\n      position += 1\n    }\n    conditions.push(\"let [{shape.join(\", \")}] = &{stem}.borrow()[..]\")\n    position = 0\n    for id in pattern.operands {\n      let temp = \"{stem}_{position}\"\n      let read = if pattern.operandLabels[position].startsWith(\"list-pattern/rest[\") { \"Value::array({temp}.to_vec())\" } else { \"(*{temp})\" }\n      addPattern(plan, planPattern(ctx, opAt(ctx.table, id)?, Code { rs: read, repr: Repr.Value }, span)?)\n      position += 1\n    }\n    return Ok(plan)\n  }\n  Err(refusal(\"kind {pattern.kind}\", pattern))\n}\n\nfunction installPattern(ctx: Ctx, plan: PatternPlan, temporary: string, op: Stage1Operation, moduleTop: bool) -> Result<string, string> {\n  let mut statements: Array<string> = []\n  let mut position = 0\n  for pattern in plan.bindings {\n    let repr = plan.reprs[position]\n    let read = \"{temporary}.{position}\"\n    if moduleTop {\n      let bind = match lookup(ctx, pattern.bindingName) {\n        case Some(found) => found\n        case None => return Err(refusal(\"module binding {pattern.bindingName}\", pattern))\n      }\n      let value = into(Code { rs:read, repr:repr },bind.repr,op)?\n      if bind.kind == \"local\" {\n        let mutable = if bind.mutable { \"mut \" } else { \"\" }\n        statements.push(\"let {mutable}{bind.rust}: {rustType(bind.repr)} = {bare(value)};\")\n      } else { statements.push(writeBind(bind,value,op)?) }\n    } else {\n      let rust = rustName(pattern.bindingName)\n      let shared = pattern.bindingMutable && ctx.table.capturedBindings.containsKey(pattern.declarationIdentity)\n      let mutable = if pattern.bindingMutable { \"mut \" } else { \"\" }\n      if shared { statements.push(\"let {rust} = {sharedInit(read, repr)};\") }\n      else { statements.push(\"let {mutable}{rust}: {rustType(repr)} = {read};\") }\n      pushBind(ctx, Bind { name: pattern.bindingName, kind: if shared { \"shared\" } else { \"local\" }, rust: rust, repr: repr, mutable: pattern.bindingMutable })\n    }\n    position += 1\n  }\n  Ok(statements.join(\" \"))\n}\n\nfunction emitPatternLet(ctx: Ctx, op: Stage1Operation, pattern: Stage1Operation, value: Code, loopBinding: bool) -> Result<string, string> {\n  let plan = planPattern(ctx, pattern, Code { rs: \"__scrut\", repr: value.repr }, spanOf(op))?\n  let install = installPattern(ctx, plan, \"__bindings\", op, !loopBinding && ctx.atModuleTop)?\n  let message = if loopBinding { \"`for` pattern did not match an element\" } else { \"`let` pattern did not match the value (§4)\" }\n  Ok(\"let __bindings = \\{ let __scrut = {bare(value.rs)}; match \\{ {extraction(plan)} \\} \\{ Some(__bindings) => __bindings, None => return Err(fault(codes::GUARD_TYPE, {rustStr(message)}, {spanOf(op)})) \\} \\}; {install}\")\n}\n\nrecord MatchArm {\n  pattern:Stage1Operation, plan:PatternPlan, install:string,\n  guard:string, guarded:bool, body:Code, operation:Stage1Operation, returns:bool,\n}\n\nfunction matchArmResult(ctx: Ctx, arm: MatchArm, repr: Repr, label: string) -> Result<string,string> {\n  let body = into(arm.body,if arm.returns { ctx.fnRet } else { repr },arm.operation)?\n  if arm.returns {\n    Ok(\"let __return_value = {bare(body)}; {drain(ctx,0)}return Ok(__return_value);\")\n  } else { Ok(\"break {label} {bare(body)};\") }\n}\n\n// A concrete outer variant has already passed its discriminant test. Keep\n// the payload tests in source order, including nested Dynamic carriers and\n// alternatives' canonical binding tuple. No speculative payload admission or\n// flattening of Some(None) into a later Some(_) arm is allowed here.\nfunction variantPattern(ctx: Ctx, arm: MatchArm, repr: Repr, variant: LayoutVariant, names: Array<string>, span: string) -> Result<Option<PatternPlan>,string> {\n  if arm.pattern.kind != \"pattern/constructor\" { return Ok(Some(arm.plan)) }\n  if !matchesVariant(arm.pattern,repr,variant) { return Ok(None) }\n  let plan = emptyPattern()\n  let mut at = 0\n  for payload in variant.payloads {\n    let pattern = opAt(ctx.table,arm.pattern.operands[at])?\n    addPattern(plan,planPattern(ctx,pattern,Code { rs:\"(*{names[at]})\",repr:payload.value.repr },span)?)\n    at += 1\n  }\n  Ok(Some(plan))\n}\n\nfunction mentionsVariant(ctx: Ctx, pattern: Stage1Operation, repr: Repr, variant: LayoutVariant) -> Result<bool,string> {\n  if matchesVariant(pattern,repr,variant) { return Ok(true) }\n  if pattern.kind == \"pattern/alternatives\" {\n    for id in pattern.operands {\n      if mentionsVariant(ctx,opAt(ctx.table,id)?,repr,variant)? { return Ok(true) }\n    }\n  }\n  Ok(false)\n}\n\n// Both admission paths select an arm and an owned binding tuple. The local\n// enum keeps each arm's existing binding representations without boxing or a\n// closure. Only the final dispatch contains user bodies, so a nested match is\n// emitted once instead of once for every enclosing admission path.\nfunction concreteMatch(ctx: Ctx, layout: LayoutPlan, plans: Array<MatchArm>, repr: Repr, label: string, span: string) -> Result<string,string> {\n  let selection = \"{label}_select\"\n  let mut bindings: Array<string> = []\n  let mut bodies: Array<string> = []\n  let mut dynamic: Array<string> = []\n  let mut ordinal = 0\n  for arm in plans {\n    let mut types: Array<string> = []\n    for binding in arm.plan.reprs { types.push(rustType(binding)) }\n    bindings.push(\"Arm{ordinal}({tupleOf(types)})\")\n    let result = matchArmResult(ctx,arm,repr,label)?\n    bodies.push(\"__MatchBindings::Arm{ordinal}(__bindings) => \\{ {arm.install} {result} \\}\")\n    dynamic.push(\"if let Some(__bindings) = \\{ {extraction(arm.plan)} \\} \\{ break {selection} __MatchBindings::Arm{ordinal}(__bindings); \\}\")\n    ordinal += 1\n  }\n  let fallback = \"{dynamic.join(\" \")} return Err(fault(codes::FAULT_MATCH_MISS, \\\"no `case` matched and no catch-all exists (§5)\\\", {span}));\"\n  let mut arms: Array<string> = []\n  let mut defaultBody: Option<string> = None\n  for variant in layout.variants {\n    let mut specific = false\n    for arm in plans {\n      if mentionsVariant(ctx,arm.pattern,layout.repr,variant)? { specific = true; break }\n    }\n    if !specific { match defaultBody { case Some(_) => { continue }; case None => () } }\n    let mut names: Array<string> = []\n    let mut at = 0\n    for payload in variant.payloads { names.push(\"__sum_payload{at}\"); at += 1 }\n    let mut body: Array<string> = []\n    let mut complete = false\n    ordinal = 0\n    for arm in plans {\n      let selected = \"break {selection} __MatchBindings::Arm{ordinal}(__bindings);\"\n      ordinal += 1\n      match variantPattern(ctx,arm,layout.repr,variant,names,span)? {\n        case None => { continue }\n        case Some(plan) => {\n          if plan.conditions.length == 0 {\n            body.push(\"let __bindings = {tupleOf(plan.reads)}; {selected}\")\n            complete = true\n            break\n          }\n          body.push(\"if let Some(__bindings) = \\{ {extraction(plan)} \\} \\{ {selected} \\}\")\n        }\n      }\n    }\n    if !complete {\n      // Exhaustiveness is about checked values. A nested Dynamic payload can\n      // still miss every pattern, with exactly the existing runtime fault.\n      body.push(\"return Err(fault(codes::FAULT_MATCH_MISS, \\\"no `case` matched and no catch-all exists (§5)\\\", {span}));\")\n    }\n    // Variants with no constructor-specific arm share their selection tests.\n    if !specific { defaultBody = Some(body.join(\" \")); continue }\n    let payload = if names.length == 0 { \"\" } else { \"({names.join(\", \")})\" }\n    let pattern = if isEnum(layout.repr) {\n      \"Some({nominalRustName(layout.repr)}::V{variant.variantIndex}{payload})\"\n    } else {\n      \"{if isOption(layout.repr) { \"NativeOption\" } else { \"NativeResult\" }}::{variant.name}{payload}\"\n    }\n    arms.push(\"{pattern} => \\{ {body.join(\" \")} \\}\")\n  }\n  let dispatch = if isEnum(layout.repr) {\n    match defaultBody { case Some(body) => arms.push(\"Some(_) => \\{ {body} \\}\"); case None => () }\n    \"match (__scrut).concrete() \\{ {arms.join(\", \")}, None => \\{ {fallback} \\} \\}\"\n  } else {\n    let carrier = if isOption(layout.repr) { \"NativeOption\" } else { \"NativeResult\" }\n    arms.push(\"{carrier}::Dynamic(_) => \\{ {fallback} \\}\")\n    match defaultBody { case Some(body) => arms.push(\"_ => \\{ {body} \\}\"); case None => () }\n    \"match &__scrut \\{ {arms.join(\", \")} \\}\"\n  }\n  // End all pattern borrows before installing bindings or running user code.\n  // No closure or function boundary is added: ?, return, loop exits and defer\n  // still use the original context, and every arm targets the same result slot.\n  Ok(\"enum __MatchBindings \\{ {bindings.join(\", \")} \\} let __selected = {selection}: \\{ {dispatch} \\}; match __selected \\{ {bodies.join(\", \")} \\}\")\n}\n\nfunction emitMatch(ctx: Ctx, op: Stage1Operation) -> Result<Code, string> {\n  let scrutOp = child(ctx.table, op, \"scrutinee\")?\n  let scrut = emitExpr(ctx, scrutOp)?\n  let declared = operationReprOfCached(ctx.table.reprs, op, false)\n  let mut repr = if declared == Repr.Untyped { Repr.Value } else { declared }\n  let label = \"'__match_{op.lo}_{op.hi}\"\n  let mut plans:Array<MatchArm> = []\n  let mut common: Option<Repr> = None\n  let mut position = 0\n  while position < op.operands.length {\n    let pattern = opAt(ctx.table, op.operands[position])?\n    if fieldOf(op.operandLabels[position]) != \"pattern\" { position += 1; continue }\n    let plan = planPattern(ctx, pattern, Code { rs: \"__scrut\", repr: scrut.repr }, spanOf(op))?\n    let mark = ctx.scope.length\n    let install = installPattern(ctx, plan, \"__bindings\", op, false)?\n    position += 1\n    let mut guard = \"true\"\n    let mut guarded = false\n    if fieldOf(op.operandLabels[position]) == \"guard\" {\n      guarded = true\n      let guardOp = opAt(ctx.table, op.operands[position])?\n      let code = emitExpr(ctx, guardOp)?\n      guard = if code.repr == Repr.Bool { code.rs } else { \"case_guard_bool(&({boxCode(code)}), {spanOf(op)})?\" }\n      position += 1\n    }\n    let bodyOp = opAt(ctx.table, op.operands[position])?\n    let returns = op.operandLabels[position].contains(\"match-case-return\")\n    if returns && ctx.fnRet == Repr.Untyped { return Err(refusal(\"return outside a function\", bodyOp)) }\n    let body = emitExpr(ctx, bodyOp)?\n    if !returns && body.repr != Repr.Never {\n      common = Some(match common { case None => body.repr; case Some(previous) => if previous == body.repr { previous } else { Repr.Value } })\n    }\n    restoreScope(ctx, mark)\n    plans.push(MatchArm { pattern:pattern,plan:plan,install:install,guard:guard,guarded:guarded,body:body,operation:bodyOp,returns:returns })\n    position += 1\n    if plan.conditions.length == 0 && guard == \"true\" { break }\n  }\n  if declared == Repr.Untyped || declared == Repr.Value {\n    match common { case Some(found) => { repr = found }; case None => () }\n  }\n  let mut patterns:Array<Stage1Operation> = []\n  let mut guarded = false\n  for arm in plans {\n    patterns.push(arm.pattern)\n    if arm.guarded { guarded = true }\n  }\n  // Build every original arm and its ownership/effect facts once, before\n  // asking for this optimization. The result slot remains common to all arms\n  // and both admission paths. Even an explicit `if true` keeps the old path.\n  if !guarded {\n    match matchLayout(ctx.table,scrutOp,scrut.repr) {\n      case Some(layout) => if exhaustiveSum(ctx.table,layout,patterns)? {\n        let dispatch = concreteMatch(ctx,layout,plans,repr,label,spanOf(op))?\n        return Ok(Code { rs:\"{label}: \\{ let __scrut = {bare(scrut.rs)}; {dispatch} \\}\",repr:repr })\n      }\n      case None => ()\n    }\n  }\n  let mut arms:Array<string> = []\n  for arm in plans {\n    let result = matchArmResult(ctx,arm,repr,label)?\n    arms.push(\"if let Some(__bindings) = \\{ {extraction(arm.plan)} \\} \\{ {arm.install} if {arm.guard} \\{ {result} \\} \\}\")\n  }\n  let fallback = \"{arms.join(\" \")} return Err(fault(codes::FAULT_MATCH_MISS, \\\"no `case` matched and no catch-all exists (§5)\\\", {spanOf(op)}));\"\n  Ok(Code { rs: \"{label}: \\{ let __scrut = {bare(scrut.rs)}; {fallback} \\}\", repr: repr })\n}\n\nfunction bindingRepr(ctx: Ctx, pattern: Stage1Operation, value: Code) -> Repr {\n  let declared = plannedSemanticRepr(ctx.table.plan,pattern)\n  if declared == Repr.Untyped {\n    value.repr\n  } else {\n    declared\n  }\n}\n\nfunction emitLet(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  let valueOp = child(ctx.table, op, \"value\")?\n  let pattern = child(ctx.table, op, \"pattern\")?\n  let value = emitExpr(ctx, valueOp)?\n  if pattern.kind == \"pattern/wildcard\" {\n    return Ok(\"let _ = {value.rs};\")\n  }\n  if pattern.kind != \"pattern/binding\" {\n    return emitPatternLet(ctx, op, pattern, value, false)\n  }\n  if ctx.atModuleTop {\n    match lookup(ctx, pattern.bindingName) {\n      case Some(bind) => if bind.kind == \"global\" {\n        return writeBind(bind, into(value, bind.repr, valueOp)?, op)\n      } else if bind.kind == \"builtin\" {\n        return Ok(\"\")\n      } else if bind.kind == \"local\" {\n        let mutable = if bind.mutable { \"mut \" } else { \"\" }\n        return Ok(\"let {mutable}{bind.rust}: {rustType(bind.repr)} = {bare(into(value,bind.repr,valueOp)?)};\")\n      }\n      case None => ()\n    }\n    return Err(refusal(\"module binding {pattern.bindingName}\", pattern))\n  }\n  let repr = bindingRepr(ctx, pattern, value)\n  let code = into(value, repr, valueOp)?\n  let rust = rustName(pattern.bindingName)\n  let storage = ctx.table.plan.storage.get(planPosition(ctx.table.plan,pattern))\n  let shared = match storage {\n    case Some(found) => found == Storage.Shared\n    case None => pattern.bindingMutable && ctx.table.capturedBindings.containsKey(pattern.declarationIdentity)\n  }\n  if shared {\n    pushBind(ctx, Bind { name: pattern.bindingName, kind: \"shared\", rust: rust, repr: repr, mutable: true })\n    return Ok(\"let {rust} = {sharedInit(code, repr)};\")\n  }\n  let mutable = if pattern.bindingMutable {\n    \"mut \"\n  } else {\n    \"\"\n  }\n  pushBind(ctx, Bind {\n    name: pattern.bindingName,\n    kind: \"local\",\n    rust: rust,\n    repr: repr,\n    mutable: pattern.bindingMutable,\n  })\n  Ok(\"let {mutable}{rust}: {rustType(repr)} = {bare(code)};\")\n}\n\nfunction emitConstant(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  let valueOp = child(ctx.table, op, \"value\")?\n  let value = emitExpr(ctx, valueOp)?\n  if ctx.atModuleTop {\n    match lookup(ctx, op.bindingName) {\n      case Some(bind) => if bind.kind == \"global\" {\n        return writeBind(bind, into(value, bind.repr, valueOp)?, op)\n      } else if bind.kind == \"local\" {\n        return Ok(\"let {bind.rust}: {rustType(bind.repr)} = {bare(into(value,bind.repr,valueOp)?)};\")\n      }\n      case None => ()\n    }\n    return Err(refusal(\"module binding {op.bindingName}\", op))\n  }\n  let declared = operationReprOfCached(ctx.table.reprs, op, true)\n  let repr = if declared == Repr.Untyped {\n    value.repr\n  } else {\n    declared\n  }\n  let rust = rustName(op.bindingName)\n  pushBind(ctx, Bind { name: op.bindingName, kind: \"local\", rust: rust, repr: repr, mutable: false })\n  Ok(\"let {rust}: {rustType(repr)} = {bare(into(value, repr, valueOp)?)};\")\n}\n\n// Collection slots mutate their shared store. Record paths rebuild the value\n// at the root or indexed slot; compound reads precede the right-hand side.\nfunction emitPathAssignment(ctx: Ctx, op: Stage1Operation, target: Stage1Operation) -> Result<string, string> {\n  let mut root = target\n  while root.kind == \"expression/member\" || root.kind == \"expression/index\" {\n    root = child(ctx.table, root, \"object\")?\n  }\n  let span = spanOf(op)\n  if root.kind == \"expression/identifier\" {\n    let binding = match lookup(ctx, root.detail) {\n      case Some(found) => found\n      case None => return Err(refusal(\"unresolved identifier {root.detail}\", root))\n    }\n    if !binding.mutable {\n      return Ok(\"return Err(fault(codes::GUARD_IMMUTABLE, {rustStr(\"`{root.detail}` is not `let mut` and cannot be assigned\")}, {span}));\")\n    }\n  }\n  let mut cursor = target\n  let mut fields: Array<string> = []\n  while cursor.kind == \"expression/member\" {\n    fields.insert(0, rustStr(cursor.detail))\n    cursor = child(ctx.table, cursor, \"object\")?\n  }\n  if fields.length == 0 && cursor.kind == \"expression/index\" && op.detail == \"assign\" {\n    let object = emitExpr(ctx,child(ctx.table,cursor,\"object\")?)?\n    if isArray(object.repr) {\n      let indexCode = emitExpr(ctx,child(ctx.table,cursor,\"index\")?)?\n      let index = if indexCode.repr == Repr.I64 { indexCode.rs } else { boxCode(indexCode) }\n      let slot = if indexCode.repr == Repr.I64 { \"__base.slot_int(__index,{span})?\" } else { \"__base.slot(&__index,{span})?\" }\n      let value = into(emitExpr(ctx,child(ctx.table,op,\"value\")?)?,elementRepr(object.repr),op)?\n      return Ok(\"let __base = {object.rs}; let __index = {index}; let (__store,__index) = {slot}; let __value = {value}; NativeArray::set(&__store,__index,__value);\")\n    }\n  }\n  let path = \"&[{fields.join(\", \")}]\"\n  let value = boxCode(emitExpr(ctx, child(ctx.table, op, \"value\")?)?)\n  let mut anchor = \"\"\n  let mut before = \"\"\n  let mut read = \"\"\n  let mut write = \"\"\n  if cursor.kind == \"expression/index\" {\n    let object = boxCode(emitExpr(ctx, child(ctx.table, cursor, \"object\")?)?)\n    let index = boxCode(emitExpr(ctx, child(ctx.table, cursor, \"index\")?)?)\n    anchor = \"let __base = {object}; let __index = {index};\"\n    before = \"let (__store, __index) = index_slot(&__base, &__index, {span})?;\"\n    read = \"__store.borrow()[__index].clone()\"\n    write = \"__store.borrow_mut()[__index] = __value;\"\n    if fields.length > 0 {\n      before = \"index_slot(&__base, &__index, {span})?;\"\n      read = \"\\{ let (__store, __k) = index_slot(&__base, &__index, {span})?; let __record = __store.borrow()[__k].clone(); walk_fields_value(&__record, {path}, {span})? \\}\"\n      write = \"let (__store, __k) = index_slot(&__base, &__index, {span})?; let __record = __store.borrow()[__k].clone(); let __updated = update_fields_value(&__record, {path}, __value, {span})?; __store.borrow_mut()[__k] = __updated;\"\n    }\n  } else if cursor.kind == \"expression/identifier\" && fields.length > 0 {\n    let binding = match lookup(ctx, root.detail) {\n      case Some(found) => found\n      case None => return Err(refusal(\"unresolved identifier {root.detail}\", root))\n    }\n    let current = boxCode(readBind(ctx, binding, spanOf(root), root)?)\n    read = \"walk_fields_value(&({current}), {path}, {span})?\"\n    let updated = \"update_fields_value(&({current}), {path}, __value, {span})?\"\n    write = writeBind(binding, unboxed(updated,binding.repr,span), op)?\n  } else { return Err(refusal(\"assignment target {target.kind}\", target)) }\n  let body = if op.detail == \"assign\" {\n    \"{before} let __value = {value}; {write}\"\n  } else if op.detail == \"coalesce\" {\n    \"{before} let __old = {read}; if matches!(__old, Value::Null | Value::None) \\{ let __value = {value}; {write} \\}\"\n  } else {\n    let combined = arithmetic(ctx, op.detail, Code { rs: \"__old\", repr: Repr.Value }, Code { rs: \"__rhs\", repr: Repr.Value }, span, op)?\n    \"{before} let __old = {read}; let __rhs = {value}; let __value = {boxCode(combined)}; {write}\"\n  }\n  Ok(\"\\{ {anchor} {body} \\}\")\n}\n\nfunction emitAssignment(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  let target = child(ctx.table, op, \"target\")?\n  if target.kind != \"expression/identifier\" {\n    return emitPathAssignment(ctx, op, target)\n  }\n  let bind = match lookup(ctx, target.detail) {\n    case Some(found) => found\n    case None => return Err(refusal(\"unresolved identifier {target.detail}\", target))\n  }\n  let valueOp = child(ctx.table, op, \"value\")?\n  // A noncaptured local cannot be replaced while its RHS executes. Its text\n  // snapshots still share through Rc, so append clones only surviving aliases.\n  if bind.kind == \"local\" && bind.mutable && bind.repr == Repr.Text {\n    let mut rhs:Option<Stage1Operation> = None\n    if op.detail == \"add\" { rhs = Some(valueOp) }\n    if op.detail == \"assign\" && valueOp.kind == \"expression/binary\" && valueOp.detail == \"add\" {\n      let left = child(ctx.table,valueOp,\"left\")?\n      if left.kind == \"expression/identifier\" && left.referenceIdentity == target.referenceIdentity && left.detail == target.detail {\n        rhs = Some(child(ctx.table,valueOp,\"right\")?)\n      }\n    }\n    match rhs {\n      case Some(value) => {\n        let code = emitExpr(ctx,value)?\n        if code.repr == Repr.Text {\n          let span = if op.detail == \"assign\" { spanOf(valueOp) } else { spanOf(op) }\n          return Ok(\"\\{ let __rhs = {code.rs}; {bind.rust}.append(__rhs, {span})?; \\}\")\n        }\n      }\n      case None => ()\n    }\n  }\n  if op.detail == \"assign\" {\n    let value = emitExpr(ctx, valueOp)?\n    return writeBind(bind, into(value, bind.repr, valueOp)?, op)\n  }\n  let current = readBind(ctx, bind, spanOf(target), target)?\n  if op.detail == \"coalesce\" {\n    if bind.repr != Repr.Value {\n      return Err(refusal(\"coalescing assignment on {reprName(bind.repr)}\", op))\n    }\n    let value = emitExpr(ctx, valueOp)?\n    let write = writeBind(bind, into(value, Repr.Value, valueOp)?, op)?\n    return Ok(\"if matches!(&{current.rs}, Value::Null | Value::None) \\{ {write} \\}\")\n  }\n  // Compound: read the target, evaluate the right side, then the leaf.\n  let value = emitExpr(ctx, valueOp)?\n  let combined = arithmetic(\n    ctx,\n    op.detail,\n    Code { rs: \"__lhs\", repr: current.repr },\n    Code { rs: \"__rhs\", repr: value.repr },\n    spanOf(op),\n    op,\n  )?\n  let write = writeBind(bind, into(combined, bind.repr, op)?, op)?\n  Ok(\"\\{ let __lhs = {current.rs}; let __rhs = {value.rs}; {write} \\}\")\n}\n\n// A function declared inside a block binds a closure value at its position.\nfunction emitLocalFunction(ctx: Ctx, op: Stage1Operation) -> Result<string, string> {\n  let params = paramsOf(ctx, op, signatureOf(ctx.table, op)?)?\n  let body = child(ctx.table, op, \"body\")?\n  let closure = emitClosure(ctx, op, params, body)?\n  let rust = rustName(op.bindingName)\n  Ok(\"top_cell_set(&{rust}, {closure});\")\n}\n",
      "sourceSha256": "4049685e410361675826d2a288370b23581e2466b2dfef14845997c16fd01ffc"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/exports.tpz",
      "language": "topaz",
      "bytes": 3721,
      "sha256": "4ad549adba331dd178aa05570a129c07c7e010be3f64c505afc32eceed1865fd",
      "content": "import emitter.ir { Table, children, child, fieldOf, opAt, refusal }\nimport stage1_types { Stage1Operation }\n\n// Target-neutral export facts of the entry module, projected from the IR.\n// This is the Topaz form of the export half of the Rust shell's adapter-fact\n// projection: value exports of the entry module sorted by name, with the\n// declared parameter names and defaults of exported functions. An export\n// that is not a function declaration carries no parameter names.\nexport record ExportFact {\n  name: string,\n  namesKnown: bool,\n  parameterNames: Array<string>,\n  parameterDefaults: Array<bool>,\n}\n\nfunction signatureParameterCount(declaration: Stage1Operation) -> int {\n  let mut count = 0\n  for atom in declaration.declaredTypeAtoms {\n    if atom.parent == 0 && atom.field == \"parameters\" {\n      count += 1\n    }\n  }\n  count\n}\n\nfunction functionFact(table: Table, declaration: Stage1Operation) -> Result<ExportFact, string> {\n  let mut names: Array<string> = []\n  let mut defaults: Array<bool> = []\n  for parameter in children(table, declaration, \"parameters\")? {\n    names.push(parameter.bindingName)\n    defaults.push(false)\n  }\n  // A default expression hangs off the function with the parameter's path.\n  let mut position = 0\n  for label in declaration.operandLabels {\n    if fieldOf(label) == \"default\" {\n      let mut index = 0\n      while index < names.length {\n        if label.contains(\"/parameters:{index}/\") {\n          defaults[index] = true\n        }\n        index += 1\n      }\n    }\n    position += 1\n  }\n  if declaration.declaredTypeAtoms.length == 0 || declaration.declaredTypeAtoms[0].kind != \"function\" {\n    return Err(refusal(\"export {declaration.bindingName} is declared as a function but has a non-function type\", declaration))\n  }\n  if signatureParameterCount(declaration) != names.length {\n    return Err(refusal(\"export {declaration.bindingName} parameter facts disagree with its checked type\", declaration))\n  }\n  Ok(ExportFact {\n    name: declaration.bindingName,\n    namesKnown: true,\n    parameterNames: names,\n    parameterDefaults: defaults,\n  })\n}\n\nfunction insertSorted(facts: Array<ExportFact>, fact: ExportFact) -> Array<ExportFact> {\n  let mut out: Array<ExportFact> = []\n  let mut placed = false\n  for existing in facts {\n    if !placed && fact.name < existing.name {\n      out.push(fact)\n      placed = true\n    }\n    out.push(existing)\n  }\n  if !placed {\n    out.push(fact)\n  }\n  out\n}\n\nexport function projectExports(table: Table, entryRoot: Stage1Operation) -> Result<Array<ExportFact>, string> {\n  let mut facts: Array<ExportFact> = []\n  for id in entryRoot.operands {\n    let item = opAt(table, id)?\n    if item.kind != \"export\" {\n      continue\n    }\n    let declaration = child(table, item, \"item\")?\n    let fact = match declaration.kind {\n      case \"function\" => Some(functionFact(table, declaration)?)\n      case \"let\" => {\n        let pattern = child(table, declaration, \"pattern\")?\n        Some(ExportFact {\n          name: pattern.bindingName,\n          namesKnown: false,\n          parameterNames: [],\n          parameterDefaults: [],\n        })\n      }\n      case \"constant\" => Some(ExportFact {\n        name: declaration.bindingName,\n        namesKnown: false,\n        parameterNames: [],\n        parameterDefaults: [],\n      })\n      case _ => None\n    }\n    match fact {\n      case Some(found) => {\n        facts = insertSorted(facts, found)\n      }\n      case None => ()\n    }\n  }\n  Ok(facts)\n}\n\n// The one entry-point judgement: `export function main` in the entry module.\nexport function hasExplicitMain(facts: Array<ExportFact>) -> bool {\n  for fact in facts {\n    if fact.namesKnown && fact.name == \"main\" {\n      return true\n    }\n  }\n  false\n}\n",
      "sourceSha256": "4ad549adba331dd178aa05570a129c07c7e010be3f64c505afc32eceed1865fd"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/ir.tpz",
      "language": "topaz",
      "bytes": 11367,
      "sha256": "7c4396600492bd93afeb229fcae03ff11ac7406fbf01a56f7c5687a683da940f",
      "content": "import stage1_types { Stage1Module, Stage1Operation, LoweringOutput }\nimport types { PreviewTypeAtom }\nimport std.bytes { Bytes }\nimport emitter.repr { ReprCache, reprAtCached, reprName }\nimport emitter.plan { EmissionPlan, newEmissionPlan }\nimport ir.model { Namespace, SignatureId }\nimport ir.codec { signatureAt }\nimport query.database { Database, newDatabase }\nimport query.names { resolveName, definition, declaredSignature }\n\nexport record Shape { atoms: Array<PreviewTypeAtom>, position: int }\n\nexport record Table {\n  db: Database,\n  reprs: ReprCache,\n  plan: EmissionPlan,\n  languageMode: string,\n  ops: Array<Stage1Operation>,\n  index: Map<string, int>,\n  captures: Map<string, Array<Stage1Operation>>,\n  capturedBindings: Map<string, bool>,\n  nominals: Map<string, Array<PreviewTypeAtom>>,\n  nominalDeclarations: Map<string, Array<Stage1Operation>>,\n  receiverMethods: Map<string, bool>,\n  methodIds: Map<string, int>,\n  protocols: Map<string, bool>,\n  implementations: Map<string, bool>,\n  qualifiedNominals: Map<string, Array<Stage1Operation>>,\n  exportPositions: Map<string, Array<int>>,\n  rootIds: Map<string, bool>,\n  shapes: Map<string, Shape>,\n}\n\n// Length prefixes keep module, scope and name distinct even in malformed IR.\nfunction lookupKey(module: string, scope: string, name: string) -> string {\n  \"{module.encodeUtf8().length()}:{module}{scope.encodeUtf8().length()}:{scope}{name}\"\n}\n\nexport function buildTable(output: LoweringOutput) -> Table { tableWithDatabase(newDatabase(output)) }\n\nexport function tableWithDatabase(db: Database) -> Table {\n  let plan = newEmissionPlan(db)\n  let view = plan.db\n  let snapshot = view.snapshots[0]\n  let index = snapshot.index\n  let mut captures: Map<string, Array<Stage1Operation>> = map {}\n  let mut capturedBindings: Map<string, bool> = map {}\n  let mut nominalDeclarations: Map<string, Array<Stage1Operation>> = map {}\n  let mut receiverMethods: Map<string, bool> = map {}\n  let mut methodIds: Map<string, int> = map {}\n  let mut methodCount = 0\n  let mut protocols: Map<string, bool> = map {}\n  let mut implementations: Map<string, bool> = map {}\n  let mut qualifiedNominals: Map<string, Array<Stage1Operation>> = map {}\n  let mut exportPositions: Map<string, Array<int>> = map {}\n  let mut rootIds: Map<string, bool> = map {}\n  let mut shapes: Map<string, Shape> = map {}\n  let mut position = 0\n  for op in snapshot.ops {\n    for atoms in [op.semanticTypeAtoms, op.declaredTypeAtoms, op.typeDefinition] {\n      let mut at = 0\n      for atom in atoms {\n        if atom.kind == \"record\" { shapes.insert(reprName(reprAtCached(plan.reprs,atoms,at)), Shape { atoms:atoms, position:at }) }\n        at += 1\n      }\n    }\n    if op.kind == \"function\" && !methodIds.containsKey(op.bindingName) {\n      methodIds.insert(op.bindingName, methodCount)\n      methodCount += 1\n    }\n    if op.kind == \"protocol\" { protocols.insert(lookupKey(op.module,\"\",op.detail),true) }\n    if op.kind == \"implementation\" { implementations.insert(lookupKey(op.module,\"\",op.detail),true) }\n    if op.kind == \"export\" {\n      let mut positions=exportPositions.get(op.id) ?? []\n      positions.push(position)\n      exportPositions.insert(op.id,positions)\n    }\n    if op.typeDefinition.length > 0 {\n      let identity=op.typeDefinition[0].identity\n      let mut declarations=nominalDeclarations.get(identity) ?? []\n      declarations.push(op)\n      nominalDeclarations.insert(identity,declarations)\n      if op.parentId != \"\" && (op.kind == \"record\" || op.kind == \"enum\" || op.kind == \"newtype\") {\n        let key=lookupKey(op.module,\"\",op.typeDefinition[0].name)\n        let mut candidates=qualifiedNominals.get(key) ?? []\n        candidates.push(op)\n        qualifiedNominals.insert(key,candidates)\n      }\n    }\n    if op.parentId == \"\" {\n      rootIds.insert(op.id,true)\n    }\n    if op.kind == \"binding/capture\" {\n      let mut found = match captures.get(op.parentId) {\n        case Some(list) => list\n        case None => []\n      }\n      found.push(op)\n      captures.insert(op.parentId, found)\n      capturedBindings.insert(op.declarationIdentity, true)\n    }\n    position += 1\n  }\n  // Resolve implementation operands after the complete id index is built.\n  // Missing operands stay ignored here, as in the former presence lookup;\n  // emission of that implementation still reports its original error.\n  for impl in snapshot.ops {\n    if impl.kind != \"implementation\" || impl.detail.contains(\"<\") { continue }\n    for id in impl.operands {\n      match index.get(id) {\n        case Some(at) => {\n          let method=snapshot.ops[at]\n          if method.kind == \"function\" { receiverMethods.insert(method.bindingName,true) }\n        }\n        case None => ()\n      }\n    }\n  }\n  // Every c8 index and DB query observes this same pinned operations snapshot.\n  Table {\n    db: view, reprs: plan.reprs, plan: plan, languageMode: snapshot.languageMode, ops: snapshot.ops, index: index,\n    captures: captures, capturedBindings: capturedBindings, nominals: snapshot.nominals, shapes: shapes,\n    nominalDeclarations: nominalDeclarations, receiverMethods: receiverMethods,\n    methodIds: methodIds, protocols: protocols, implementations: implementations,\n    qualifiedNominals: qualifiedNominals, exportPositions: exportPositions, rootIds: rootIds,\n  }\n}\n\nexport function hasProtocol(table:Table, module:string, name:string) -> bool {\n  table.protocols.containsKey(lookupKey(module,\"\",name))\n}\n\nexport function hasImplementation(table:Table, module:string, name:string) -> bool {\n  table.implementations.containsKey(lookupKey(module,\"\",name))\n}\n\nexport function qualifiedTypeDeclarations(table:Table, module:string, name:string) -> Array<Stage1Operation> {\n  table.qualifiedNominals.get(lookupKey(module,\"\",name)) ?? []\n}\n\n// Match the former forward scan even for duplicate ids or nested malformed\n// export wrappers: only a later occurrence may update the parent again.\nexport function moduleDefaultContext(table:Table, parentId:string) -> bool {\n  let mut parent=parentId\n  let mut after = -1\n  loop {\n    let mut next = -1\n    for position in table.exportPositions.get(parent) ?? [] {\n      if position > after { next=position; break }\n    }\n    if next < 0 { break }\n    parent=table.ops[next].parentId\n    after=next\n  }\n  table.rootIds.containsKey(parent)\n}\n\n// Find the runtime type name in its lexical scope, including selected imports.\nexport function typeDeclaration(table: Table, originId: string, name: string) -> Result<Option<Stage1Operation>, string> {\n  match resolveName(table.db, originId, Namespace.Type, name)? {\n    case Some(id) => Ok(Some(definition(table.db, id)?))\n    case None => Ok(None)\n  }\n}\n\nexport function signatureOf(table: Table, op: Stage1Operation) -> Result<Option<SignatureId>, string> {\n  let snapshot = table.db.snapshots[0]\n  let mut at = table.index.get(op.id) ?? -1\n  // Normal inputs take the indexed path. A retained candidate with a\n  // duplicate wire ID must use its own signature, not the last occurrence.\n  if snapshot.index.length != snapshot.ops.length && at >= 0 && table.ops[at] != op {\n    let mut found = -1\n    let mut position = 0\n    for candidate in table.ops {\n      if candidate == op { found = position; break }\n      position += 1\n    }\n    at = found\n  }\n  match snapshot.definitionIds.get(at) {\n    case Some(id) => declaredSignature(table.db, id)\n    case None => Ok(if at >= 0 { signatureAt(table.db.registry, snapshot, at) } else { None })\n  }\n}\n\n// `index` and `ops` are the columns of the snapshot `db` pins, so this is\n// `query.names.operation(table.db, id)` without the extra call layer.\nexport function opAt(table: Table, id: string) -> Result<Stage1Operation, string> {\n  match table.index.get(id) {\n    case Some(position) => Ok(table.ops[position])\n    case None => Err(\"unsupported: ir missing operation {id}\")\n  }\n}\n\nexport function capturesOf(table: Table, op: Stage1Operation) -> Array<Stage1Operation> {\n  match table.captures.get(op.id) {\n    case Some(list) => list\n    case None => []\n  }\n}\n\n// The structural field of an operand label: the last path segment before `:`.\nexport function fieldOf(label: string) -> string {\n  let segments = label.split(\"/\")\n  let last = segments[segments.length - 1]\n  last.split(\":\")[0]\n}\n\n// The name carried by a `field-initializer[i]=<name>` label head.\nexport function labelName(label: string) -> string {\n  let head = label.split(\"/\")[0]\n  let parts = head.split(\"=\")\n  if parts.length < 2 {\n    \"\"\n  } else {\n    parts[1]\n  }\n}\n\nexport function children(\n  table: Table,\n  op: Stage1Operation,\n  field: string,\n) -> Result<Array<Stage1Operation>, string> {\n  let mut found: Array<Stage1Operation> = []\n  let mut position = 0\n  for id in op.operands {\n    if fieldOf(op.operandLabels[position]) == field {\n      found.push(opAt(table, id)?)\n    }\n    position += 1\n  }\n  Ok(found)\n}\n\nexport function child(\n  table: Table,\n  op: Stage1Operation,\n  field: string,\n) -> Result<Stage1Operation, string> {\n  let found = children(table, op, field)?\n  if found.length != 1 {\n    return Err(refusal(\"shape {op.kind} operand {field} x{found.length}\", op))\n  }\n  Ok(found[0])\n}\n\nexport function optionalChild(\n  table: Table,\n  op: Stage1Operation,\n  field: string,\n) -> Result<Option<Stage1Operation>, string> {\n  let found = children(table, op, field)?\n  if found.length == 0 {\n    Ok(None)\n  } else if found.length == 1 {\n    Ok(Some(found[0]))\n  } else {\n    Err(refusal(\"shape {op.kind} operand {field} x{found.length}\", op))\n  }\n}\n\n// Structured refusal: one line naming the first construct outside the\n// emitter's surface and where it occurs. Never a silent fallback.\nexport function refusal(what: string, op: Stage1Operation) -> string {\n  \"unsupported: {what} at {op.module}:{op.lo}-{op.hi}\"\n}\n\n// B2a carries the runtime FileId explicitly, independently of operation ids.\nexport function fileOf(op: Stage1Operation) -> string {\n  \"{op.sourceOrdinal}\"\n}\n\nexport function spanOf(op: Stage1Operation) -> string {\n  spanAt(op, op.lo, op.hi)\n}\n\nexport function spanAt(op: Stage1Operation, lo: int, hi: int) -> string {\n  // Source locations are compile-time data. Keeping the literal in an inline\n  // const removes a constructor call from successful arithmetic, indexing and\n  // binding reads without moving or rounding any diagnostic byte offset.\n  \"const \\{ Span \\{ file: FileId({fileOf(op)}), lo: {lo}, hi: {hi} \\} \\}\"\n}\n\n// The declared name span of a binding identity `source:<n>:<lo>:<hi>`.\nexport function declarationSpan(op: Stage1Operation) -> string {\n  let parts = op.declarationIdentity.split(\":\")\n  if parts.length == 4 {\n    spanAt(op, parts[2].toInt() ?? op.lo, parts[3].toInt() ?? op.hi)\n  } else {\n    spanOf(op)\n  }\n}\n\nexport function rustName(name: string) -> string {\n  \"_t_{(name).encodeUtf8().toHex()}\"\n}\n\nexport function patternBindings(table: Table, pattern: Stage1Operation) -> Result<Array<Stage1Operation>, string> {\n  let mut found: Array<Stage1Operation> = []\n  if pattern.kind == \"pattern/binding\" || pattern.kind == \"pattern/typed-binding\" {\n    if pattern.bindingName != \"\" { found.push(pattern) }\n  } else if pattern.kind.startsWith(\"pattern/\") {\n    for id in pattern.operands {\n      let sub = opAt(table, id)?\n      for bind in patternBindings(table, sub)? { found.push(bind) }\n      if pattern.kind == \"pattern/alternatives\" { break }\n    }\n    ()\n  }\n  Ok(found)\n}\n",
      "sourceSha256": "7c4396600492bd93afeb229fcae03ff11ac7406fbf01a56f7c5687a683da940f"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/module.tpz",
      "language": "topaz",
      "bytes": 33571,
      "sha256": "8891911d6dcc53505127bb636cbb95e8a23f8368a48147401fec69d306aece90",
      "content": "import ir.model { EdgeRole }\nimport query.database { Database, newDatabase }\nimport emitter.provenance { analyzeProvenance }\nimport emitter.effects { newEffect, synchronousFunctions }\nimport emitter.plan { CallAbi, functionPlanForWire }\nimport emitter.function_plan { planFunction, planModuleInit, finishFunctionPlans, functionAbi, cooperativeAbi }\nimport emitter.ownership { exitMoves }\nimport emitter.init_plan { entryLocal, functionsReadyOnEntry }\nimport emitter.builtins { lispexIntrinsic }\nimport emitter.rust_text { rustStr }\nimport emitter.emit {\n  Bind,\n  FnInfo,\n  ModInfo,\n  Ctx,\n  Code,\n  pushBind,\n  restoreScope,\n  newCell,\n  modBind,\n  paramsOf,\n  argumentGuard,\n  defaultValues,\n  restArgument,\n  emitExpr,\n  emitStatement,\n  emitImplementation,\n  into,\n  has,\n}\nimport emitter.exports { projectExports, hasExplicitMain }\nimport emitter.ir { Table, tableWithDatabase, signatureOf, patternBindings, opAt, child, children, refusal, spanOf, declarationSpan, rustName }\nimport emitter.repr { Repr, operationReprOfCached, isVec, slotReprCached, rustType, isCopyRepr, boxed, bare }\nimport emitter.native_layout { emitNativeLayouts }\nimport stage1_types { Stage1Module, Stage1Operation, LoweringOutput }\n\n// The emitted-crate contract every Topaz program crate exposes (the same\n// items the reference crate's `emitted.rs` defines). This emitter names\n// nominal values by their defining-module identity in every language mode, so\n// the runtime context projects host-returned std.lispex values to the same\n// identities (the Rust emitter selects this context from 5.20 on).\nconst CONTRACT = \"\"\"\npub fn run_with_host(host: Rc<dyn Host>) -> RunOutcome \\{\n    run_with_host_and_input(host, Vec::new(), String::new())\n\\}\n\npub fn run_with_host_and_input(host: Rc<dyn Host>, args: Vec<String>, stdin: String) -> RunOutcome \\{\n    let cx = RtCx::new_module_stable(host);\n    let __topaz_args = Value::array(args.into_iter().map(Value::str).collect());\n    let __topaz_stdin = Value::str(stdin);\n    match entry(cx, __topaz_args, __topaz_stdin) \\{\n        Ok(value) => RunOutcome::Completed(value),\n        Err(error) => RunOutcome::Faulted(error),\n    \\}\n\\}\n\npub fn call_export_with_host(host: Rc<dyn Host>, name: &str, args: Vec<Value>) -> RunOutcome \\{\n    call_export_with_host_and_input(host, name, args, Vec::new(), String::new())\n\\}\n\npub fn call_export_with_host_until(\n    host: Rc<dyn Host>,\n    name: &str,\n    args: Vec<Value>,\n    deadline: std::time::Instant,\n) -> Result<RunOutcome, DeadlineExceeded> \\{\n    let outcome = block_on_until(deadline, call_export_with_host_future(host, name, args))?;\n    Ok(match outcome \\{\n        Ok(value) => RunOutcome::Completed(value),\n        Err(error) => RunOutcome::Faulted(error),\n    \\})\n\\}\n\npub fn call_export_with_host_future(\n    host: Rc<dyn Host>,\n    name: &str,\n    args: Vec<Value>,\n) -> CallFuture \\{\n    let cx = RtCx::new_module_stable(host).with_cooperative();\n    let __span = const \\{ Span \\{ file: FileId(0), lo: 0, hi: 0 \\} \\};\n    let name = name.to_string();\n    Box::pin(async move \\{\n        __topaz_call_export(cx, &name, args, __span).await\n    \\})\n\\}\n\npub fn call_export_with_host_and_input(\n    host: Rc<dyn Host>,\n    name: &str,\n    args: Vec<Value>,\n    _program_args: Vec<String>,\n    _stdin: String,\n) -> RunOutcome \\{\n    let cx = RtCx::new_module_stable(host);\n    let __span = const \\{ Span \\{ file: FileId(0), lo: 0, hi: 0 \\} \\};\n    match block_on(__topaz_call_export(cx, name, args, __span)) \\{\n        Ok(value) => RunOutcome::Completed(value),\n        Err(error) => RunOutcome::Faulted(error),\n    \\}\n\\}\n\npub fn call_export_json_with_host(host: Rc<dyn Host>, name: &str, args_json: &str) -> String \\{\n    call_export_json_with_host_and_input(host, name, args_json, Vec::new(), String::new())\n\\}\n\npub fn call_export_json_with_host_and_input(\n    host: Rc<dyn Host>,\n    name: &str,\n    args_json: &str,\n    program_args: Vec<String>,\n    stdin: String,\n) -> String \\{\n    let args = match canonical_abi_decode_args(args_json) \\{\n        Ok(args) => args,\n        Err(error) => return canonical_abi_error(&error),\n    \\};\n    match call_export_with_host_and_input(host, name, args, program_args, stdin) \\{\n        RunOutcome::Completed(value) => canonical_abi_completed(&value),\n        RunOutcome::Faulted(error) => canonical_abi_faulted(&error),\n    \\}\n\\}\n\nfn __topaz_exports(cx: RtCx) -> Result<Value, RtError> \\{\n    let (_, _, __exports) = __topaz_initialize(cx)?;\n    Ok(__exports)\n\\}\n\nasync fn __topaz_call_export(cx: RtCx, name: &str, args: Vec<Value>, span: Span) -> Result<Value, RtError> \\{\n    let __exports = __INITIALIZE_EXPORTS__;\n    let __callee = member_value_required(&__exports, name, span)?;\n    call_value(__callee, args, cx, span).await\n\\}\n\"\"\"\n\nconst CELL_HELPER = \"\"\"\nfn __cell_get<T: Copy>(cell: &std::cell::Cell<Option<T>>, name: &str, span: Span) -> Result<T, RtError> \\{\n    cell.get().ok_or_else(|| fault(codes::GUARD_UNBOUND, format!(\"`\\{name\\}` is not bound\"), span))\n\\}\n\"\"\"\n\nconst CONST_HELPER = \"\"\"\nfn __cg<T>(result: Result<T, RtError>, span: Span) -> Result<T, RtError> \\{\n    result.map_err(|error| \\{\n        if error.is_fault() \\{\n            fault(codes::GUARD_TYPE, format!(\"constant expression error: \\{\\}\", error.message), span)\n        \\} else \\{\n            error\n        \\}\n    \\})\n\\}\n\"\"\"\n\nrecord Item {\n  decl: Stage1Operation,\n  exported: bool,\n}\n\nfunction itemsOf(table: Table, root: Stage1Operation) -> Result<Array<Item>, string> {\n  let mut items: Array<Item> = []\n  for id in root.operands {\n    let item = opAt(table, id)?\n    if item.kind == \"export\" {\n      items.push(Item { decl: child(table, item, \"item\")?, exported: true })\n    } else {\n      items.push(Item { decl: item, exported: false })\n    }\n  }\n  Ok(items)\n}\n\nrecord ImportRow {\n  kind: string,\n  source: string,\n  bound: string,\n}\n\nfunction importRows(op: Stage1Operation) -> Result<Array<ImportRow>, string> {\n  let mut rows: Array<ImportRow> = []\n  for row in op.importBindings {\n    let parts = row.split(\"|\")\n    if parts.length != 5 {\n      return Err(refusal(\"import row {row}\", op))\n    }\n    rows.push(ImportRow { kind: parts[0], source: parts[1], bound: parts[2] })\n  }\n  Ok(rows)\n}\n\nfunction fnKey(ctx: Ctx) -> int {\n  ctx.fns.length\n}\n\n// Module-level names become cells or function entries before any body is\n// emitted, so a function may name a binding declared later in its module.\nfunction registerModule(ctx: Ctx, module: Stage1Module, root: Stage1Operation) -> Result<ModInfo, string> {\n  let mut binds: Array<Bind> = []\n  let mut exported: Array<string> = []\n  for item in itemsOf(ctx.table, root)? {\n    let decl = item.decl\n    if decl.kind == \"function\" {\n      let signature = signatureOf(ctx.table, decl)?\n      let params = paramsOf(ctx, decl, signature)?\n      let ret = match signature { case Some(id) => slotReprCached(ctx.table.reprs, id, EdgeRole.Result, 0); case None => Repr.Untyped }\n      if ret == Repr.Untyped {\n        return Err(refusal(\"function result type\", decl))\n      }\n      let number = fnKey(ctx)\n      let info = FnInfo {\n        id: decl.id,\n        name: decl.bindingName,\n        body: \"__b{number}\",\n        adapter: \"__v{number}\",\n        cell: newCell(ctx, Repr.Value),\n        paramNames: params.names,\n        paramReprs: params.reprs,\n        paramSpans: params.spans,\n        defaultIds: params.defaultIds,\n        variadic: params.variadic,\n        retRepr: ret,\n        synchronous: false,\n      }\n      let mut fns = ctx.fns\n      fns.insert(decl.id, info)\n      binds.push(Bind { name: decl.bindingName, kind: \"fn\", rust: decl.id, repr: Repr.Value, mutable: false })\n      if item.exported {\n        exported.push(decl.bindingName)\n      }\n    } else if decl.kind == \"let\" {\n      let pattern = child(ctx.table, decl, \"pattern\")?\n      let value = child(ctx.table, decl, \"value\")?\n      for binding in patternBindings(ctx.table, pattern)? {\n        let declared = operationReprOfCached(ctx.table.reprs, binding, false)\n        let repr = if declared == Repr.Untyped { Repr.Value } else { declared }\n        let intrinsic = if module.generatedStd && !binding.bindingMutable &&\n          value.kind == \"expression/identifier\" && value.referenceIdentity.startsWith(\"builtin::\") {\n          lispexIntrinsic(module.identity,value.detail)\n        } else { \"\" }\n        let local = entryLocal(ctx.table,decl,binding,module.entry,item.exported)\n        let kind = if intrinsic != \"\" { \"builtin\" } else if local { \"local\" } else { \"global\" }\n        let rust = if intrinsic != \"\" { intrinsic } else if local { rustName(binding.bindingName) } else { newCell(ctx,repr) }\n        binds.push(Bind { name: binding.bindingName, kind:kind, rust:rust, repr:repr, mutable:binding.bindingMutable })\n        if item.exported { exported.push(binding.bindingName) }\n      }\n    } else if decl.kind == \"constant\" {\n      let declared = operationReprOfCached(ctx.table.reprs, decl, true)\n      let repr = if declared != Repr.Untyped {\n        declared\n      } else {\n        let value = child(ctx.table, decl, \"value\")?\n        operationReprOfCached(ctx.table.reprs, value, false)\n      }\n      if repr == Repr.Untyped {\n        return Err(refusal(\"binding type {decl.bindingName}\", decl))\n      }\n      let local = entryLocal(ctx.table,decl,decl,module.entry,item.exported)\n      binds.push(Bind { name: decl.bindingName, kind:if local { \"local\" } else { \"global\" }, rust:if local { rustName(decl.bindingName) } else { newCell(ctx,repr) }, repr:repr, mutable:false })\n      if item.exported {\n        exported.push(decl.bindingName)\n      }\n    } else if decl.kind == \"import\" {\n      for row in importRows(decl)? {\n        if row.kind == \"namespace-import\" {\n          binds.push(Bind { name: row.bound, kind: \"namespace\", rust: decl.importModule, repr: Repr.Value, mutable: false })\n        } else if row.kind == \"selected-import\" {\n          let target = match ctx.mods.get(decl.importModule) {\n            case Some(found) => found\n            case None => return Err(refusal(\"import of {decl.importModule}\", decl))\n          }\n          match modBind(target, row.source) {\n            case Some(bind) => if bind.kind == \"fn\" || bind.kind == \"builtin\" {\n              binds.push(Bind { ...bind, name: row.bound })\n            } else if has(target.exports, row.source) {\n              binds.push(Bind { name: row.bound, kind: \"global\", rust: newCell(ctx, Repr.Value), repr: Repr.Value, mutable: false })\n            }\n            case None => ()\n          }\n        } else {\n          return Err(refusal(\"import form {row.kind}\", decl))\n        }\n      }\n    }\n  }\n  let info = ModInfo { identity: module.identity, cell: newCell(ctx, Repr.Value), binds: binds, exports: exported, generatedStd: module.generatedStd,\n    root:root.id, ordinal:module.initializationOrdinal, functionsReady:functionsReadyOnEntry(ctx.table,root) }\n  let mut mods = ctx.mods\n  mods.insert(module.identity, info)\n  Ok(info)\n}\n\nfunction enterModule(ctx: Ctx, info: ModInfo) -> () {\n  restoreScope(ctx, 0)\n  for bind in info.binds {\n    pushBind(ctx, bind)\n  }\n  ()\n}\n\nfunction findBind(info: ModInfo, name: string, op: Stage1Operation) -> Result<Bind, string> {\n  match modBind(info, name) {\n    case Some(bind) => Ok(bind)\n    case None => Err(refusal(\"module binding {name}\", op))\n  }\n}\n\nfunction fnOf(ctx: Ctx, key: string, op: Stage1Operation) -> Result<FnInfo, string> {\n  match ctx.fns.get(key) {\n    case Some(info) => Ok(info)\n    case None => Err(refusal(\"ir function {key}\", op))\n  }\n}\n\n// The boxed value of a module binding, for export records.\nfunction exportValue(ctx: Ctx, bind: Bind, op: Stage1Operation) -> Result<string, string> {\n  let name = rustStr(bind.name)\n  if bind.kind == \"builtin\" {\n    Ok(\"Value::Builtin \\{ kind: Builtin::{bind.rust}, recv: None \\}\")\n  } else if bind.kind == \"fn\" {\n    let info = fnOf(ctx, bind.rust, op)?\n    Ok(\"top_cell_value(&g.{info.cell}, {name})?\")\n  } else if bind.kind == \"global\" && isCopyRepr(bind.repr) {\n    Ok(boxed(\"__cell_get(&g.{bind.rust}, {name}, const \\{ Span \\{ file: FileId(0), lo: 0, hi: 0 \\} \\})?\", bind.repr))\n  } else if bind.kind == \"global\" {\n    Ok(\"top_cell_value(&g.{bind.rust}, {name})?\")\n  } else {\n    Err(refusal(\"export of {bind.kind} binding {bind.name}\", op))\n  }\n}\n\nfunction exportRecord(ctx: Ctx, info: ModInfo, root: Stage1Operation) -> Result<string, string> {\n  let mut fields: Array<string> = []\n  for name in info.exports {\n    let bind = findBind(info, name, root)?\n    fields.push(\"({rustStr(name)}.to_string(), {exportValue(ctx, bind, root)?})\")\n  }\n  Ok(\"Value::record([{fields.join(\", \")}])\")\n}\n\n// The typed body function and the boxed adapter of one module function.\nfunction emitFunction(ctx: Ctx, info: FnInfo, modInfo: ModInfo) -> Result<(), string> {\n  emitFunctionVariant(ctx, info, modInfo, false)?\n  if info.cooperative { emitFunctionVariant(ctx, info, modInfo, true)? }\n  Ok(())\n}\n\nfunction emitFunctionVariant(ctx: Ctx, info: FnInfo, modInfo: ModInfo, cooperative: bool) -> Result<(), string> {\n  let decl = opAt(ctx.table, info.id)?\n  enterModule(ctx, modInfo)\n  let effect = newEffect()\n  let abi = if cooperative { info.cooperativeAbi } else { info.abi }\n  let bodyName = if cooperative { \"{info.body}_cooperative\" } else { info.body }\n  let mut initialized:Map<string,bool> = map {}\n  for module in ctx.mods.values {\n    if module.ordinal < modInfo.ordinal || (module.identity == modInfo.identity && modInfo.functionsReady) {\n      for binding in module.binds {\n        if binding.kind == \"fn\" { initialized.insert((fnOf(ctx,binding.rust,decl)?).cell,true) }\n        else if binding.kind == \"global\" && module.ordinal < modInfo.ordinal { initialized.insert(binding.rust,true) }\n      }\n    }\n  }\n  initialized.insert(info.cell,true)\n  let fnCtx = Ctx { ...ctx, effect:effect, fnRet: info.retRepr, inConst: false, atModuleTop: false, loops: [], defers: [], cooperative:cooperative, asynchronous:abi != CallAbi.Plain, initialized:initialized }\n  let defaults = defaultValues(ctx, info.defaultIds, info.variadic)?\n  let mut params: Array<string> = []\n  let mut entry: Array<string> = []\n  let mut position = 0\n  for name in info.paramNames {\n    let rust = rustName(name)\n    params.push(\", {rust}: {rustType(info.paramReprs[position])}\")\n    let repr = if isVec(info.paramReprs[position]) { Repr.Value } else { info.paramReprs[position] }\n    if repr == Repr.Value && isVec(info.paramReprs[position]) {\n      entry.push(\"let {rust} = {boxed(rust, info.paramReprs[position])};\")\n    }\n    pushBind(ctx, Bind { name: name, kind: \"local\", rust: rust, repr: repr, mutable: false })\n    position += 1\n  }\n  let body = emitExpr(fnCtx, child(ctx.table, decl, \"body\")?)?\n  let result = if body.repr == Repr.Never {\n    body.rs\n  } else {\n    \"Ok({bare(into(body, info.retRepr, decl)?)})\"\n  }\n  let prefix = if abi == CallAbi.Plain { \"\" } else { \"async \" }\n  // Keep the admitted recursive frame boundary intact under release LTO.\n  let frameBoundary = if info.recursive && abi == CallAbi.Plain { \"#[inline(never)]\\n\" } else { \"\" }\n  let mut items = ctx.items\n  items.push(\n    \"{frameBoundary}{prefix}fn {bodyName}(cx: RtCx, g: Rc<__G>{params.join(\"\")}) -> Result<{rustType(info.retRepr)}, RtError> \\{\\n    let _ = &cx;\\n    let _ = &g;\\n    {entry.join(\" \")}\\n    {result}\\n\\}\\n\",\n  )\n  if cooperative { return Ok(()) }\n  let mut prologue: Array<string> = []\n  let mut passed: Array<string> = [\"cx\", \"g\"]\n  if info.paramNames.length > 0 {\n    prologue.push(\"let mut __args = args.into_iter();\")\n  } else {\n    prologue.push(\"let _ = args;\")\n  }\n  position = 0\n  for name in info.paramNames {\n    let value = if isVec(info.paramReprs[position]) {\n      restArgument(info.paramReprs[position], info.paramSpans[position])\n    } else { argumentGuard(\"__args.next().expect(\\\"arity checked at the call site\\\")\", info.paramReprs[position], info.paramSpans[position]) }\n    prologue.push(\"let __a{position} = {value};\")\n    passed.push(\"__a{position}\")\n    position += 1\n  }\n  let mut quoted = quotedAll(info.paramNames)\n  if info.variadic { let _ = quoted.pop() }\n  let suffix = if info.abi == CallAbi.Plain { \"?\" } else { \".await?\" }\n  let invocation = if info.cooperative {\n    \"if cx.is_cooperative() \\{ {info.body}_cooperative({passed.join(\", \")}).await? \\} else \\{ {info.body}({passed.join(\", \")}){suffix} \\}\"\n  } else { \"{info.body}({passed.join(\", \")}){suffix}\" }\n  let returned = boxed(invocation, info.retRepr)\n  items.push(\n    \"fn {info.adapter}(g: &Rc<__G>) -> Value \\{\\n    let __cap_g = g.clone();\\n    Value::Closure(Rc::new(EmittedClosure \\{ call: move |cx: RtCx, args: Vec<Value>| -> CallFuture \\{ let g = __cap_g.clone(); Box::pin(async move \\{ {prologue.join(\" \")} Ok({bare(returned)}) \\}) \\}, params: &[{quoted.join(\", \")}], defaults: {defaults}, variadic: {info.variadic} \\}))\\n\\}\\n\",\n  )\n  Ok(())\n}\n\nfunction quotedAll(names: Array<string>) -> Array<string> {\n  let mut out: Array<string> = []\n  for name in names {\n    out.push(rustStr(name))\n  }\n  out\n}\n\nfunction importsOf(items: Array<Item>) -> Array<Item> {\n  let mut out: Array<Item> = []\n  for item in items {\n    if item.decl.kind == \"import\" {\n      out.push(item)\n    }\n  }\n  out\n}\n\nrecord ModuleCode {\n  lines: Array<string>,\n  tail: string,\n}\n\n// A module's top-level code in execution order: hoisted constants, value\n// imports, then its items (functions bind positionally).\nfunction emitModuleInit(\n  ctx: Ctx,\n  module: Stage1Module,\n  root: Stage1Operation,\n  info: ModInfo,\n) -> Result<ModuleCode, string> {\n  enterModule(ctx, info)\n  let topCtx = Ctx { ...ctx, fnRet: Repr.Untyped, inConst: false, atModuleTop: true }\n  let constCtx = Ctx { ...topCtx, inConst: true }\n  let mut initialized = ctx.initialized\n  let items = itemsOf(ctx.table, root)?\n  let mut lines: Array<string> = []\n  for item in items {\n    if item.decl.kind == \"constant\" {\n      lines.push(emitStatement(constCtx, item.decl)?)\n      let bind = findBind(info,item.decl.bindingName,item.decl)?\n      if bind.kind == \"global\" { initialized.insert(bind.rust,true) }\n    }\n  }\n  for item in importsOf(items) {\n    let target = match ctx.mods.get(item.decl.importModule) {\n      case Some(found) => found\n      case None => return Err(refusal(\"import of {item.decl.importModule}\", item.decl))\n    }\n    for row in importRows(item.decl)? {\n      if row.kind == \"selected-import\" {\n        match modBind(info, row.bound) {\n          case Some(bind) => if bind.kind == \"global\" {\n            let read = \"member_value_required(&top_cell_get(&g.{target.cell}, {rustStr(target.identity)}, {spanOf(item.decl)})?, {rustStr(row.source)}, {spanOf(item.decl)})?\"\n            lines.push(\"top_cell_set(&g.{bind.rust}, {read});\")\n            initialized.insert(bind.rust,true)\n          }\n          case None => ()\n        }\n      }\n    }\n  }\n  let mut tail = \"Value::Unit\"\n  for item in items {\n    if item.decl.kind == \"implementation\" { lines.push(emitImplementation(topCtx, item.decl)?) }\n  }\n  let mut position = 0\n  for item in items {\n    let decl = item.decl\n    let last = position == items.length - 1\n    if decl.kind == \"function\" {\n      let declared = fnOf(ctx, decl.id, decl)?\n      lines.push(\"top_cell_set(&g.{declared.cell}, {declared.adapter}(&g));\")\n      initialized.insert(declared.cell,true)\n    } else if has([\"constant\", \"import\", \"type-alias\", \"record\", \"enum\", \"newtype\", \"protocol\", \"implementation\"], decl.kind) {\n      ()\n    } else if decl.kind == \"expression/block\" && module.entry && last {\n      let expression = child(ctx.table, decl, \"value\")?\n      // Module-level for remains a statement at the last item as well.\n      if expression.kind == \"expression/for\" {\n        lines.push(emitStatement(topCtx, decl)?)\n      } else {\n        let value = emitExpr(topCtx, expression)?\n        tail = bare(into(value, Repr.Value, decl)?)\n      }\n    } else {\n      lines.push(emitStatement(topCtx, decl)?)\n      if decl.kind == \"let\" {\n        for binding in patternBindings(ctx.table,child(ctx.table,decl,\"pattern\")?)? {\n          let bind = findBind(info,binding.bindingName,decl)?\n          if bind.kind == \"global\" { initialized.insert(bind.rust,true) }\n        };\n      }\n    }\n    position += 1\n  }\n  Ok(ModuleCode { lines: lines, tail: tail })\n}\n\nfunction chainTo(modules: Array<Stage1Module>, edges: Array<Array<string>>, entry: string, target: string) -> string {\n  let mut queue: Array<string> = [entry]\n  let mut previous: Map<string, string> = map {}\n  let mut head = 0\n  while head < queue.length {\n    let current = queue[head]\n    head += 1\n    if current == target {\n      let mut chain: Array<string> = [current]\n      let mut at = current\n      while previous.containsKey(at) {\n        at = previous.get(at) ?? \"\"\n        chain.push(at)\n      }\n      chain.reverse()\n      return \"import chain: \" + chain.join(\" -> \")\n    }\n    for edge in edges {\n      if edge[0] == current && !previous.containsKey(edge[1]) && edge[1] != entry {\n        previous.insert(edge[1], current)\n        queue.push(edge[1])\n      }\n    }\n  }\n  \"imported from `{entry}`\"\n}\n\nfunction sortedModules(output: LoweringOutput) -> Array<Stage1Module> {\n  let mut out: Array<Stage1Module> = []\n  let mut ordinal = 0\n  while out.length < output.modules.length {\n    for module in output.modules {\n      if module.initializationOrdinal == ordinal {\n        out.push(module)\n      }\n    }\n    ordinal += 1\n    if ordinal > output.modules.length + 1 {\n      return out\n    }\n  }\n  out\n}\n\nexport function emitProgram(output: LoweringOutput) -> Result<string, string> {\n  emitProgramWithDatabase(output, newDatabase(output))\n}\n\nexport record PlannedProgram {\n  ctx:Ctx, modules:Array<Stage1Module>, roots:Array<Stage1Operation>,\n  infos:Array<ModInfo>, entryIndex:int, edges:Array<Array<string>>,\n  cooperativeInit:bool,\n}\n\nexport function planProgram(output:LoweringOutput) -> Result<PlannedProgram,string> {\n  planProgramWithDatabase(output,newDatabase(output))\n}\n\nexport function planProgramWithDatabase(output: LoweringOutput, db: Database) -> Result<PlannedProgram, string> {\n  let table = tableWithDatabase(db)\n  let ctx = Ctx {\n    table: table,\n    provenance: analyzeProvenance(table,output)?,\n    exitMoves: exitMoves(table),\n    effect:newEffect(),\n    effects:map {},\n    scope: [],\n    fns: map {},\n    mods: map {},\n    cellDecls: [],\n    items: [],\n    fnRet: Repr.Untyped,\n    inConst: false,\n    atModuleTop: false,\n    loops: [],\n    defers: [],\n  }\n  let modules = sortedModules(output)\n  if modules.length != output.modules.length {\n    return Err(\"unsupported: module initialization order\")\n  }\n  let mut roots: Array<Stage1Operation> = []\n  let mut infos: Array<ModInfo> = []\n  let mut entryIndex = -1\n  let mut position = 0\n  for module in modules {\n    if module.extern {\n      return Err(\"unsupported: extern module {module.identity}\")\n    }\n    if module.operationIds.length == 0 {\n      return Err(\"unsupported: empty module {module.identity}\")\n    }\n    let root = opAt(table, module.operationIds[0])?\n    roots.push(root)\n    infos.push(registerModule(ctx, module, root)?)\n    if module.entry {\n      entryIndex = position\n    }\n    position += 1\n  }\n  if entryIndex < 0 {\n    return Err(\"unsupported: no entry module\")\n  }\n  let entryModule = modules[entryIndex]\n  let entryRoot = roots[entryIndex]\n  let entryInfo = infos[entryIndex]\n\n  // Import edges in module source order, for the initialization-fault chain.\n  let mut edges: Array<Array<string>> = []\n  let mut ordinal = 0\n  while ordinal < modules.length {\n    let mut index = 0\n    for module in modules {\n      if module.sourceOrdinal == ordinal {\n        for id in roots[index].operands {\n          let item = opAt(table, id)?\n          if item.kind == \"import\" {\n            edges.push([module.identity, item.importModule])\n          }\n        }\n      }\n      index += 1\n    }\n    ordinal += 1\n  }\n\n  position = 0\n  for module in modules {\n    for bind in infos[position].binds {\n      if bind.kind == \"fn\" {\n        let declaration = opAt(table, bind.rust)?\n        if declaration.module != module.identity {\n          continue\n        }\n        planFunction(ctx, fnOf(ctx, bind.rust, roots[position])?, infos[position])\n      }\n    }\n    position += 1\n  }\n\n  position = 0\n  for module in modules {\n    planModuleInit(ctx,roots[position],infos[position],module.entry)\n    position += 1\n  }\n\n  // A deadline export includes initialization. Reachability starts at all\n  // initializers only for a program exposing an actual export entrypoint.\n  // The public future/deadline export API initializes before looking up the\n  // requested name, even when no exports exist. Keep that initializer's\n  // cooperative flavor so missing-export calls retain output/fault/timeout\n  // order. Ordinary entry still uses the synchronous flavor.\n  for root in roots {\n    match ctx.effects.get(root.id) {\n      case Some(effect) => { let mut calls = effect.cooperativeCalls; calls.push(root.id) }\n      case None => ()\n    }\n  };\n  let synchronous = synchronousFunctions(ctx.effects)\n  finishFunctionPlans(ctx,synchronous)\n  let mut functions = ctx.fns\n  for id in functions.keys {\n    let info = functions.get(id) ?? fnOf(ctx,id,entryRoot)?\n    let abi = functionAbi(synchronous,id)\n    let result = match functionPlanForWire(ctx.table.plan,id) { case Some(plan) => plan.result.repr; case None => info.retRepr }\n    functions.insert(id,FnInfo { ...info,synchronous:abi == CallAbi.Plain,\n      boxed:abi == CallAbi.BoxedFuture,abi:abi,retRepr:result,\n      recursive:synchronous.recursive.get(id) ?? false,\n      fatFrame:synchronous.deferredFrames.containsKey(id),\n      cooperative:synchronous.cooperative.get(id) ?? false,\n      cooperativeAbi:cooperativeAbi(synchronous,id) })\n  }\n  let mut cooperativeInit = false\n  for root in roots {\n    if synchronous.cooperative.get(root.id) ?? false { cooperativeInit = true }\n  };\n  Ok(PlannedProgram { ctx:ctx, modules:modules, roots:roots, infos:infos,\n    entryIndex:entryIndex, edges:edges, cooperativeInit:cooperativeInit })\n}\n\nfunction initializerBody(ctx:Ctx, planned:PlannedProgram) -> Result<Array<string>,string> {\n  let modules = planned.modules\n  let roots = planned.roots\n  let infos = planned.infos\n  let edges = planned.edges\n  let entryModule = modules[planned.entryIndex]\n  let mut body: Array<string> = []\n  let mut position = 0\n  for module in modules {\n    let code = emitModuleInit(ctx, module, roots[position], infos[position])?\n    if module.entry {\n      for line in code.lines {\n        body.push(\"    {line}\")\n      }\n      body.push(\"    let __topaz_init_value = {code.tail};\")\n    } else {\n      let record = exportRecord(ctx, infos[position], roots[position])?\n      let suffix = \"(during initialization of module `{module.identity}`; {chainTo(modules, edges, entryModule.identity, module.identity)})\"\n      body.push(if ctx.asynchronous { \"    match (async \\{\" } else { \"    match (|| -> Result<(), RtError> \\{\" })\n      for line in code.lines {\n        body.push(\"        {line}\")\n      }\n      body.push(\"        top_cell_set(&g.{infos[position].cell}, {record});\")\n      body.push(\"        Ok::<(), RtError>(())\")\n      let invoke = if ctx.asynchronous { \".await\" } else { \"()\" }\n      body.push(\"    \\}){invoke} \\{ Ok(()) => \\{\\}, Err(__e) => return Err(RtError \\{ code: __e.code, message: format!(\\\"\\{\\} \\{\\}\\\", __e.message, {rustStr(suffix)}), span: __e.span \\}), \\}\")\n    }\n    position += 1\n  }\n\n  Ok(body)\n}\n\nexport function emitProgramWithDatabase(output: LoweringOutput, db: Database) -> Result<string, string> {\n  let planned = planProgramWithDatabase(output,db)?\n  let ctx = planned.ctx\n  let table = ctx.table\n  let modules = planned.modules\n  let roots = planned.roots\n  let infos = planned.infos\n  let edges = planned.edges\n  let entryIndex = planned.entryIndex\n  let entryModule = modules[entryIndex]\n  let entryRoot = roots[entryIndex]\n  let entryInfo = infos[entryIndex]\n  let mut position = 0\n  for module in modules {\n    for bind in infos[position].binds {\n      if bind.kind == \"fn\" {\n        let declaration = opAt(table, bind.rust)?\n        if declaration.module != module.identity {\n          continue\n        }\n        emitFunction(ctx, fnOf(ctx, bind.rust, roots[position])?, infos[position])?\n      }\n    }\n    position += 1\n  }\n\n  let body = initializerBody(Ctx { ...ctx, initialized:map {} },planned)?\n  let deadlineBody = if planned.cooperativeInit {\n    initializerBody(Ctx { ...ctx, initialized:map {}, cooperative:true, asynchronous:true },planned)?\n  } else { [] }\n\n  let facts = projectExports(table, entryRoot)?\n  let explicitMain = hasExplicitMain(facts)\n  let mut entryValue = \"__topaz_init_value\"\n  let mut mainSpan = \"const \\{ Span \\{ file: FileId(0), lo: 0, hi: 0 \\} \\}\"\n  let mut mainCall = \"\"\n  if explicitMain {\n    let bind = findBind(entryInfo, \"main\", entryRoot)?\n    let info = fnOf(ctx, bind.rust, entryRoot)?\n    mainSpan = declarationSpan(opAt(table, info.id)?)\n    entryValue = \"top_cell_get(&g.{info.cell}, \\\"main\\\", {mainSpan})?\"\n    mainCall = \"block_on(call_value(__topaz_entry_value, vec![__topaz_args, __topaz_stdin], cx, {mainSpan}))\"\n    if info.paramNames.length == 2 && !info.variadic {\n      let args = [argumentGuard(\"__topaz_args\",info.paramReprs[0],info.paramSpans[0]),\n        argumentGuard(\"__topaz_stdin\",info.paramReprs[1],info.paramSpans[1])]\n      let invocation = if info.abi == CallAbi.Plain { \"{info.body}(cx.clone(), g, __a0, __a1)?\" }\n        else { \"block_on(Box::pin({info.body}(cx.clone(), g, __a0, __a1)))?\" }\n      mainCall = \"let _gd = __native_enter_call(&cx,{mainSpan})?; let __a0 = {args[0]}; let __a1 = {args[1]}; Ok({bare(boxed(invocation,info.retRepr))})\"\n    }\n  }\n  let record = exportRecord(ctx, entryInfo, entryRoot)?\n  let exportNames = quotedAll(entryInfo.exports).join(\", \")\n\n  let mut out: Array<string> = []\n  out.push(\"// @generated by the Topaz self emitter; do not edit.\\n\")\n  out.push(\"#![allow(non_snake_case)]\\n\")\n  out.push(\"use std::rc::Rc;\\nuse topaz_rt::*;\\n\\n\")\n  let mode = table.languageMode.replace(\"topaz-\", \"V\").replace(\".\", \"_\")\n  out.push(\"fn member_value(v: &Value, name: &str, span: Span) -> Result<Option<Value>, RtError> \\{ member_value_with_version(v, name, span, LangVersion::{mode}) \\}\\n\")\n  out.push(\"fn member_value_required(v: &Value, name: &str, span: Span) -> Result<Value, RtError> \\{ member_value(v, name, span)?.ok_or_else(|| no_member_fault(v, name, span)) \\}\\n\")\n  out.push(\"fn bind_receiver_builtin(v: Value, name: &str, span: Span) -> Result<Value, RtError> \\{ bind_receiver_builtin_with_version(v, name, span, LangVersion::{mode}) \\}\\n\")\n  out.push(\"pub const TOPAZ_EXPLICIT_MAIN: bool = {explicitMain};\\n\\n\")\n  out.push(\"pub fn topaz_export_names() -> &'static [&'static str] \\{\\n    &[{exportNames}]\\n\\}\\n\")\n  let initializeExports = if deadlineBody.length > 0 {\n    \"if cx.is_cooperative() \\{ let (_, _, exports) = __topaz_initialize_cooperative(cx.clone()).await?; exports \\} else \\{ __topaz_exports(cx.clone())? \\}\"\n  } else { \"__topaz_exports(cx.clone())?\" }\n  out.push(CONTRACT.replace(\"__INITIALIZE_EXPORTS__\",initializeExports))\n  out.push(emitNativeLayouts(table))\n  let bodyText = body.join(\"\\n\")\n  let itemText = ctx.items.join(\"\\n\")\n  let mut fields: Array<string> = []\n  let mut inits: Array<string> = []\n  if bodyText.contains(\"g.methods\") || itemText.contains(\"g.methods\") {\n    fields.push(\"    methods: std::cell::RefCell<std::collections::HashMap<String, std::collections::HashMap<i64, Value>>>,\\n\")\n    inits.push(\"methods: Default::default()\")\n  }\n  if bodyText.contains(\"g.protocols\") || itemText.contains(\"g.protocols\") {\n    fields.push(\"    protocols: std::cell::RefCell<std::collections::HashMap<(String, String, String, String), Value>>,\\n\")\n    inits.push(\"protocols: Default::default()\")\n  }\n  for decl in ctx.cellDecls {\n    let parts = decl.split(\"|\")\n    fields.push(\"    {parts[0]},\\n\")\n    inits.push(\"{parts[0].split(\":\")[0]}: {parts[1]}\")\n  }\n  out.push(\"\\nstruct __G \\{\\n{fields.join(\"\")}\\}\\n\\n\")\n  if bodyText.contains(\"__cell_get(\") || itemText.contains(\"__cell_get(\") || record.contains(\"__cell_get(\") {\n    out.push(CELL_HELPER)\n  }\n  if bodyText.contains(\"__cg(\") || itemText.contains(\"__cg(\") {\n    out.push(CONST_HELPER)\n  }\n  out.push(\"\\n\")\n  out.push(itemText)\n  if explicitMain {\n    out.push(\"\\nfn entry(cx: RtCx, __topaz_args: Value, __topaz_stdin: Value) -> Result<Value, RtError> \\{\\n    let (g, __topaz_entry_value, _) = __topaz_initialize(cx.clone())?;\\n    {mainCall}\\n\\}\\n\")\n  } else {\n    out.push(\"\\nfn entry(cx: RtCx, __topaz_args: Value, __topaz_stdin: Value) -> Result<Value, RtError> \\{\\n    let _ = (&__topaz_args, &__topaz_stdin);\\n    let (_, __topaz_entry_value, _) = __topaz_initialize(cx)?;\\n    Ok(__topaz_entry_value)\\n\\}\\n\")\n  }\n  out.push(\"\\nfn __topaz_initialize(cx: RtCx) -> Result<(Rc<__G>, Value, Value), RtError> \\{\\n    let _ = &cx;\\n\")\n  out.push(\"    let g = Rc::new(__G \\{ {inits.join(\", \")} \\});\\n    let _ = &g;\\n\")\n  out.push(bodyText)\n  out.push(\"\\n    let __topaz_entry_value = {entryValue};\\n    let exports = {record};\\n    Ok((g, __topaz_entry_value, exports))\\n\\}\\n\")\n  if deadlineBody.length > 0 {\n    out.push(\"\\nasync fn __topaz_initialize_cooperative(cx: RtCx) -> Result<(Rc<__G>, Value, Value), RtError> \\{\\n    let _ = &cx;\\n\")\n    out.push(\"    let g = Rc::new(__G \\{ {inits.join(\", \")} \\});\\n    let _ = &g;\\n\")\n    out.push(deadlineBody.join(\"\\n\"))\n    out.push(\"\\n    let __topaz_entry_value = {entryValue};\\n    let exports = {record};\\n    Ok((g, __topaz_entry_value, exports))\\n\\}\\n\")\n  }\n  Ok(out.join(\"\"))\n}\n",
      "sourceSha256": "8891911d6dcc53505127bb636cbb95e8a23f8368a48147401fec69d306aece90"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/repr.tpz",
      "language": "topaz",
      "bytes": 26528,
      "sha256": "40b793788219de8d832b54877bb50590113ca663a76934d8211b4eaecdf5f48f",
      "content": "import types { PreviewTypeAtom }\nimport stage1_types { Stage1Operation }\nimport ir.model { Registry, TypeId, DefId, SignatureId, TypeKind, EdgeRole }\nimport ir.codec { Snapshot, operationTypeAt, newtypeDefinition, enumDefinition }\nimport query.database { Database }\n\n// Semantic TypeIds describe the checked language type. Repr describes only\n// its runtime carrier; nominal payloads and structural keys keep wire names,\n// never session-local DefIds or type-interning order.\nexport enum Repr {\n  Untyped, Never, Value, I64, F64, Bool, Unit, RangeInt, Text, Json, BigInt,\n  Array(Repr), Option(Repr), Result(Repr, Repr),\n  Record(string), Enum(string), Newtype(string), Shape(string), Vec(Repr), SharedCell(Repr),\n}\n\n// TypeIds belong to the shared arena, but nominal spellings belong to one\n// snapshot. Pin both here; an editing database cannot retarget this cache.\n// `uniqueWires` is fixed with the pinned snapshot: its index covers every\n// operation exactly when no wire ID repeats.\nexport record ReprCache {\n  registry: Registry, snapshot: Snapshot, byType: Map<int, Repr>, newtypes: Map<int, Repr>, enums: Map<int, Repr>,\n  // One lazy canonical declaration index, shared by this snapshot's projections.\n  nominalOwners: Array<Map<string, int>>,\n  uniqueWires: bool,\n}\n\nexport function newReprCache(db: Database) -> ReprCache {\n  let snapshot = db.snapshots[0]\n  ReprCache {\n    registry: db.registry, snapshot: snapshot, byType: map {}, newtypes: map {}, enums: map {}, nominalOwners: [],\n    uniqueWires: snapshot.index.length == snapshot.ops.length,\n  }\n}\n\nexport function operationRepr(db: Database, wire: string, declared: bool) -> Repr {\n  operationReprCached(newReprCache(db), wire, declared)\n}\n\nexport function operationReprCached(cache: ReprCache, wire: string, declared: bool) -> Repr {\n  let snapshot = cache.snapshot\n  let at = match snapshot.index.get(wire) { case Some(at) => at; case None => return Repr.Untyped }\n  match snapshot.typed.get(at) {\n    case Some(facts) => {\n      let cached = if declared { facts.declared } else { facts.typeId }\n      let id = match cached { case Some(id) => id; case None => operationTypeAt(cache.registry,snapshot,at,declared) }\n      return reprOfCached(cache,id)\n    }\n    case None => ()\n  }\n  reprOfAtomsCached(cache,if declared { snapshot.ops[at].declaredTypeAtoms } else { snapshot.ops[at].semanticTypeAtoms })\n}\n\n// The wire API keeps indexed lookup semantics. A caller that already holds\n// an operation must retain that exact candidate when malformed input repeats\n// an ID; the index's last operation cannot replace its carrier silently.\nexport function operationReprOf(db: Database, op: Stage1Operation, declared: bool) -> Repr {\n  operationReprOfCached(newReprCache(db), op, declared)\n}\n\n// One index lookup on the hot path; the indexed branch is operationReprCached's.\nexport function operationReprOfCached(cache: ReprCache, op: Stage1Operation, declared: bool) -> Repr {\n  let snapshot = cache.snapshot\n  let at = if cache.uniqueWires { snapshot.index.get(op.id) ?? -1 } else { -1 }\n  if at < 0 {\n    return reprOfAtomsCached(cache,if declared { op.declaredTypeAtoms } else { op.semanticTypeAtoms })\n  }\n  match snapshot.typed.get(at) {\n    case Some(facts) => {\n      // A warmed column already has its TypeId. Reuse this exact facts row\n      // instead of entering operationTypeAt/factsAt for a second map read.\n      // An unmaterialized column still takes the same lazy codec path.\n      let cached = if declared { facts.declared } else { facts.typeId }\n      let id = match cached { case Some(id) => id; case None => operationTypeAt(cache.registry,snapshot,at,declared) }\n      return reprOfCached(cache,id)\n    }\n    case None => ()\n  }\n  reprOfAtomsCached(cache,if declared { snapshot.ops[at].declaredTypeAtoms } else { snapshot.ops[at].semanticTypeAtoms })\n}\n\nfunction scalarRepr(name: string) -> Repr {\n  match name {\n    case \"int\" => Repr.I64\n    case \"float\" => Repr.F64\n    case \"bool\" => Repr.Bool\n    case \"unit\" => Repr.Unit\n    case \"string\" => Repr.Text\n    case _ => Repr.Value\n  }\n}\n\nexport function reprOfAtom(atom: PreviewTypeAtom) -> Repr {\n  if atom.kind == \"primitive\" || (atom.kind == \"literal\" && atom.name != \"null\") { scalarRepr(atom.name) } else { Repr.Value }\n}\n\n// An opaque, generic or intrinsic nominal has no declaration-owned base\n// layout. A known newtype over an unknown base still stores that base as Value.\nexport function declaredNewtypeRepr(atoms: Array<PreviewTypeAtom>) -> Repr {\n  if atoms.length == 0 { return Repr.Value }\n  let root = atoms[0]\n  if root.kind != \"newtype\" || root.identity == \"\" || root.identity.startsWith(\"builtin:\") { return Repr.Value }\n  let mut base = false\n  for atom in atoms {\n    if atom.parent != 0 { continue }\n    if atom.field == \"typeParameters\" { return Repr.Value }\n    if atom.field == \"base\" { base = true }\n  }\n  if !base { return Repr.Value }\n  let identity = if root.identity.contains(\"::\") || root.origin == \"\" { root.identity } else { \"{root.origin}::{root.identity}\" }\n  Repr.Newtype(identity)\n}\n\n// A generic declaration has no monomorphized layout in this slice. Its values\n// keep the existing Value ABI even if a malformed reference omits arguments.\nexport function declaredEnumRepr(atoms: Array<PreviewTypeAtom>) -> Repr {\n  if atoms.length == 0 { return Repr.Value }\n  let root = atoms[0]\n  if root.kind != \"enum\" || root.identity == \"\" || root.identity.startsWith(\"builtin:\") { return Repr.Value }\n  for atom in atoms {\n    if atom.parent == 0 && atom.field == \"typeParameters\" { return Repr.Value }\n  }\n  let identity = if root.identity.contains(\"::\") || root.origin == \"\" { root.identity } else { \"{root.origin}::{root.identity}\" }\n  Repr.Enum(identity)\n}\n\nfunction nominalOwnerIndex(cache: ReprCache) -> Map<string, int> {\n  if cache.nominalOwners.length > 0 { return cache.nominalOwners[0] }\n  let mut owners: Map<string, int> = map {}\n  // Inspect declaration headers once; do not force operation type columns or\n  // runtime values. A conflicting canonical owner keeps the Value boundary.\n  for owner in cache.snapshot.definitionPositions.keys {\n    let at = cache.snapshot.definitionPositions.get(owner) ?? -1\n    if at < 0 { continue }\n    let candidate = cache.snapshot.ops[at]\n    if candidate.typeDefinition.length == 0 { continue }\n    let root = candidate.typeDefinition[0]\n    let canonical = if root.identity.contains(\"::\") || root.origin == \"\" { root.identity } else { \"{root.origin}::{root.identity}\" }\n    match owners.get(canonical) {\n      case None => owners.insert(canonical,at)\n      case Some(previous) => {\n        if previous < 0 { continue }\n        let prior = cache.snapshot.ops[previous]\n        if prior.kind != candidate.kind || prior.module != candidate.module || prior.typeDefinition != candidate.typeDefinition {\n          owners.insert(canonical,-1)\n        }\n      }\n    }\n  }\n  let mut indexes = cache.nominalOwners\n  indexes.push(owners)\n  owners\n}\n\nexport function newtypeForDefinition(cache: ReprCache, id: DefId) -> Repr {\n  match cache.newtypes.get(id.value()) { case Some(repr) => return repr; case None => () }\n  let mut repr = match cache.snapshot.definitionPositions.get(id.value()) {\n    case Some(at) => if cache.snapshot.ops[at].kind == \"newtype\" { declaredNewtypeRepr(cache.snapshot.ops[at].typeDefinition) } else { Repr.Value }\n    case None => Repr.Value\n  }\n  if isNewtype(repr) {\n    let owners = nominalOwnerIndex(cache)\n    if (owners.get(reprIdentity(repr)) ?? -1) < 0 { repr = Repr.Value }\n  }\n  let mut newtypes = cache.newtypes\n  newtypes.insert(id.value(),repr)\n  repr\n}\n\nexport function enumForDefinition(cache: ReprCache, id: DefId) -> Repr {\n  match cache.enums.get(id.value()) { case Some(repr) => return repr; case None => () }\n  let mut repr = match cache.snapshot.definitionPositions.get(id.value()) {\n    case Some(at) => if cache.snapshot.ops[at].kind == \"enum\" { declaredEnumRepr(cache.snapshot.ops[at].typeDefinition) } else { Repr.Value }\n    case None => Repr.Value\n  }\n  if isEnum(repr) {\n    let owners = nominalOwnerIndex(cache)\n    if (owners.get(reprIdentity(repr)) ?? -1) < 0 { repr = Repr.Value }\n  }\n  let mut enums = cache.enums\n  enums.insert(id.value(),repr)\n  repr\n}\n\n// The wire fallback and the typed projection deliberately use the same child\n// rules: first Array/Option payload, last Result/signature slot, ordered shape\n// fields, and Value for nominal references that still have type arguments.\nexport function reprAt(atoms: Array<PreviewTypeAtom>, position: int) -> Repr {\n  reprAtIn(None,atoms,position)\n}\n\nexport function reprAtCached(cache: ReprCache, atoms: Array<PreviewTypeAtom>, position: int) -> Repr {\n  reprAtIn(Some(cache),atoms,position)\n}\n\nfunction reprAtIn(cache: Option<ReprCache>, atoms: Array<PreviewTypeAtom>, position: int) -> Repr {\n  let atom = atoms[position]\n  if atom.kind == \"big-int\" { return Repr.BigInt }\n  if atom.kind == \"json-value\" { return Repr.Json }\n  if atom.kind == \"constructor\" && atom.name == \"Result\" {\n    let mut payloads:Array<Repr> = [Repr.Value,Repr.Value]\n    let mut at = 0\n    for child in atoms {\n      if child.parent == position && child.field == \"arguments\" && child.index >= 0 && child.index < 2 {\n        payloads[child.index] = reprAtIn(cache,atoms,at)\n      }\n      at += 1\n    }\n    return resultRepr(payloads[0],payloads[1])\n  }\n  if atom.kind == \"constructor\" && atom.name == \"Option\" {\n    let mut at = 0\n    for child in atoms {\n      if child.parent == position && child.field == \"arguments\" && child.index == 0 {\n        return Repr.Option(reprAtIn(cache,atoms,at))\n      }\n      at += 1\n    }\n  }\n  if atom.kind == \"record\" {\n    let mut fields:Array<string> = []\n    let mut index = 0\n    for child in atoms {\n      if child.parent == position && child.field == \"fields\" {\n        let fieldRepr = reprName(reprAtIn(cache,atoms,index))\n        fields.push(\"{child.edgeName.encodeUtf8().toHex()}_{fieldRepr.scalars().length}:{fieldRepr}\")\n      }\n      index += 1\n    }\n    return Repr.Shape(fields.join(\"_\"))\n  }\n  if atom.kind == \"nominal-record\" || atom.kind == \"enum\" || atom.kind == \"newtype\" {\n    for child in atoms { if child.parent == position { return Repr.Value } }\n    if atom.kind == \"newtype\" || atom.kind == \"enum\" {\n      let context = match cache { case Some(found) => found; case None => return Repr.Value }\n      let definition = if atom.kind == \"enum\" { enumDefinition(context.snapshot.nominalDefs,atom.identity,atom.origin) }\n        else { newtypeDefinition(context.snapshot.nominalDefs,atom.identity,atom.origin) }\n      return match definition {\n        case Some(id) => if atom.kind == \"enum\" { enumForDefinition(context,id) } else { newtypeForDefinition(context,id) }\n        case None => Repr.Value\n      }\n    }\n    let identity = if atom.identity.contains(\"::\") || atom.origin == \"\" { atom.identity } else { \"{atom.origin}::{atom.identity}\" }\n    return if atom.kind == \"enum\" { Repr.Enum(identity) } else { Repr.Record(identity) }\n  }\n  if atom.kind == \"constructor\" && atom.name == \"Array\" {\n    let mut at = 0\n    for child in atoms {\n      if child.parent == position && child.field == \"arguments\" && child.index == 0 {\n        return Repr.Array(reprAtIn(cache,atoms,at))\n      }\n      at += 1\n    }\n    return Repr.Array(Repr.Value)\n  }\n  if atom.kind == \"constructor\" && atom.name == \"Range\" {\n    for child in atoms {\n      if child.parent == position && child.field == \"arguments\" && child.index == 0 &&\n        child.kind == \"primitive\" && child.name == \"int\" {\n        return Repr.RangeInt\n      }\n    }\n  }\n  reprOfAtom(atom)\n}\n\nexport function reprOfAtoms(atoms: Array<PreviewTypeAtom>) -> Repr {\n  if atoms.length == 0 { Repr.Untyped } else { reprAt(atoms, 0) }\n}\n\nexport function reprOfAtomsCached(cache: ReprCache, atoms: Array<PreviewTypeAtom>) -> Repr {\n  if atoms.length == 0 { Repr.Untyped } else { reprAtCached(cache,atoms,0) }\n}\n\nexport function reprOf(db: Database, id: TypeId) -> Repr {\n  reprOfCached(newReprCache(db), id)\n}\n\nexport function reprOfCached(cache: ReprCache, id: TypeId) -> Repr {\n  match cache.byType.get(id.value()) { case Some(repr) => return repr; case None => () }\n  let repr = computeRepr(cache, id)\n  let mut byType = cache.byType\n  byType.insert(id.value(), repr)\n  repr\n}\n\nfunction computeRepr(cache: ReprCache, id: TypeId) -> Repr {\n  let node = cache.registry.types[id.value()]\n  if node.kind == TypeKind.Untyped { return Repr.Untyped }\n  if node.wireKind == \"big-int\" { return Repr.BigInt }\n  if node.wireKind == \"json-value\" { return Repr.Json }\n  if node.wireKind == \"constructor\" && node.wireName == \"Result\" {\n    let mut payloads:Array<Repr> = [Repr.Value,Repr.Value]\n    for edge in node.edges {\n      if edge.role == EdgeRole.Arguments && edge.fieldIndex >= 0 && edge.fieldIndex < 2 {\n        payloads[edge.fieldIndex] = reprOfCached(cache,edge.child)\n      }\n    }\n    return resultRepr(payloads[0],payloads[1])\n  }\n  if node.wireKind == \"constructor\" && node.wireName == \"Option\" {\n    for edge in node.edges {\n      if edge.role == EdgeRole.Arguments && edge.fieldIndex == 0 { return Repr.Option(reprOfCached(cache,edge.child)) }\n    }\n    ()\n  }\n  if node.wireKind == \"record\" {\n    let mut fields:Array<string> = []\n    for edge in node.edges {\n      if edge.role == EdgeRole.Fields {\n        let fieldRepr = reprName(reprOfCached(cache,edge.child))\n        fields.push(\"{edge.name.encodeUtf8().toHex()}_{fieldRepr.scalars().length}:{fieldRepr}\")\n      }\n    }\n    return Repr.Shape(fields.join(\"_\"))\n  }\n  if node.wireKind == \"nominal-record\" || node.wireKind == \"enum\" || node.wireKind == \"newtype\" {\n    if node.edges.length > 0 { return Repr.Value }\n    if node.wireKind == \"newtype\" || node.wireKind == \"enum\" {\n      let definition = match node.kind {\n        case Nominal(id) => Some(id)\n        case _ => if node.wireKind == \"enum\" { enumDefinition(cache.snapshot.nominalDefs,node.wireIdentity,node.wireOrigin) }\n          else { newtypeDefinition(cache.snapshot.nominalDefs,node.wireIdentity,node.wireOrigin) }\n      }\n      return match definition {\n        case Some(id) => if node.wireKind == \"enum\" { enumForDefinition(cache,id) } else { newtypeForDefinition(cache,id) }\n        case None => Repr.Value\n      }\n    }\n    let mut identity = node.wireIdentity\n    let mut origin = node.wireOrigin\n    // A semantic nominal survives a wire/span edit. Read its current wire\n    // spelling from this snapshot instead of freezing it in the type arena.\n    match node.kind {\n      case Nominal(id) => {\n        let snapshot = cache.snapshot\n        match snapshot.definitionPositions.get(id.value()) {\n          case Some(at) => {\n            let atoms = snapshot.ops[at].typeDefinition\n            if atoms.length > 0 { identity = atoms[0].identity; origin = atoms[0].origin }\n          }\n          case None => ()\n        }\n      }\n      case _ => ()\n    }\n    let qualified = if identity.contains(\"::\") || origin == \"\" { identity } else { \"{origin}::{identity}\" }\n    return if node.wireKind == \"enum\" { Repr.Enum(qualified) } else { Repr.Record(qualified) }\n  }\n  if node.wireKind == \"constructor\" && node.wireName == \"Array\" {\n    for edge in node.edges {\n      if edge.role == EdgeRole.Arguments && edge.fieldIndex == 0 { return Repr.Array(reprOfCached(cache,edge.child)) }\n    }\n    return Repr.Array(Repr.Value)\n  }\n  if node.wireKind == \"constructor\" && node.wireName == \"Range\" {\n    for edge in node.edges {\n      if edge.role == EdgeRole.Arguments && edge.fieldIndex == 0 {\n        let child = cache.registry.types[edge.child.value()]\n        if child.wireKind == \"primitive\" && child.wireName == \"int\" { return Repr.RangeInt }\n      }\n    }\n    ()\n  }\n  if node.wireKind == \"primitive\" || (node.wireKind == \"literal\" && node.wireName != \"null\") { scalarRepr(node.wireName) } else { Repr.Value }\n}\n\nexport function slotRepr(db: Database, signature: SignatureId, role: EdgeRole, index: int) -> Repr {\n  slotReprCached(newReprCache(db), signature, role, index)\n}\n\nexport function slotReprCached(cache: ReprCache, signature: SignatureId, role: EdgeRole, index: int) -> Repr {\n  let mut found = Repr.Untyped\n  for edge in cache.registry.types[cache.registry.signatures[signature.value()].root.value()].edges {\n    if edge.role == role && edge.fieldIndex == index { found = reprOfCached(cache, edge.child) }\n  }\n  found\n}\n\n// The existing spelling is an external diagnostic and stable-symbol boundary.\n// It is never used as a semantic type or parsed to make carrier decisions.\nexport function reprName(repr: Repr) -> string {\n  match repr {\n    case Untyped => \"none\"\n    case Never => \"never\"\n    case Value => \"value\"\n    case I64 => \"i64\"\n    case F64 => \"f64\"\n    case Bool => \"bool\"\n    case Unit => \"unit\"\n    case RangeInt => \"range\"\n    case Text => \"text\"\n    case Json => \"json\"\n    case BigInt => \"bigint\"\n    case Array(element) => \"array:{reprName(element)}\"\n    case Option(element) => \"option:{reprName(element)}\"\n    case Result(ok, error) => { let name = reprName(ok); \"result:{name.scalars().length}:{name}{reprName(error)}\" }\n    case Record(identity) => \"record:{identity}\"\n    case Enum(identity) => \"enum:{identity}\"\n    case Newtype(identity) => \"newtype:{identity}\"\n    case Shape(key) => \"shape:{key}\"\n    case Vec(element) => \"vec:{reprName(element)}\"\n    case SharedCell(element) => \"cell:{reprName(element)}\"\n  }\n}\n\nexport function variadicRepr(element: Repr) -> Repr { Repr.Vec(element) }\nexport function isVec(repr: Repr) -> bool { match repr { case Vec(_) => true; case _ => false } }\nexport function isArray(repr: Repr) -> bool { match repr { case Array(_) => true; case _ => false } }\nexport function isOption(repr: Repr) -> bool { match repr { case Option(_) => true; case _ => false } }\nexport function isResult(repr: Repr) -> bool { match repr { case Result(_, _) => true; case _ => false } }\n// Variant tests by match; `repr == Repr.Untyped` builds a temporary carrier per test.\nexport function isUntyped(repr: Repr) -> bool { match repr { case Untyped => true; case _ => false } }\nexport function isNever(repr: Repr) -> bool { match repr { case Never => true; case _ => false } }\nexport function isValueRepr(repr: Repr) -> bool { match repr { case Value => true; case _ => false } }\nexport function isRecord(repr: Repr) -> bool { match repr { case Record(_) => true; case _ => false } }\nexport function isEnum(repr: Repr) -> bool { match repr { case Enum(_) => true; case _ => false } }\nexport function isNewtype(repr: Repr) -> bool { match repr { case Newtype(_) => true; case _ => false } }\nexport function isShape(repr: Repr) -> bool { match repr { case Shape(_) => true; case _ => false } }\nexport function elementRepr(repr: Repr) -> Repr {\n  match repr { case Vec(element) => element; case Array(element) => element; case Option(element) => element; case SharedCell(element) => element; case _ => Repr.Untyped }\n}\nexport function reprIdentity(repr: Repr) -> string {\n  match repr { case Record(identity) => identity; case Enum(identity) => identity; case Newtype(identity) => identity; case Shape(key) => key; case _ => \"\" }\n}\nexport function resultRepr(ok: Repr, error: Repr) -> Repr { Repr.Result(ok, error) }\nexport function resultParts(repr: Repr) -> Array<Repr> {\n  match repr { case Result(ok, error) => [ok, error]; case _ => [Repr.Untyped, Repr.Untyped] }\n}\n\nexport function rustType(repr: Repr) -> string {\n  match repr {\n    case Vec(element) => return \"Vec<{rustType(element)}>\"\n    case SharedCell(element) => return if isCopyRepr(element) { \"Rc<std::cell::Cell<{rustType(element)}>>\" } else { \"Rc<std::cell::RefCell<{rustType(element)}>>\" }\n    case Array(element) => return \"NativeArray<{rustType(element)}>\"\n    case Option(element) => return \"NativeOption<{rustType(element)}>\"\n    case Result(ok, error) => return \"NativeResult<{rustType(ok)}, {rustType(error)}>\"\n    case _ => ()\n  }\n  if nativeRepr(repr) { return \"{nominalRustName(repr)}_Value\" }\n  match repr {\n    case I64 => \"i64\"\n    case F64 => \"f64\"\n    case Bool => \"bool\"\n    case Unit => \"()\"\n    case RangeInt => \"(i64, i64, bool, i64)\"\n    case Text => \"NativeText\"\n    case Json => \"NativeJson\"\n    case BigInt => \"NativeBigInt\"\n    case _ => \"Value\"\n  }\n}\n\nexport function nativeRepr(repr: Repr) -> bool { isRecord(repr) || isEnum(repr) || isNewtype(repr) || isShape(repr) }\nfunction nativeValueRepr(repr: Repr) -> bool {\n  match repr {\n    case Record(_) => true\n    case Enum(_) => true\n    case Newtype(_) => true\n    case Shape(_) => true\n    case Text => true\n    case Json => true\n    case Option(_) => true\n    case Result(_, _) => true\n    case Array(_) => true\n    case BigInt => true\n    case _ => false\n  }\n}\nexport function nominalRustName(repr: Repr) -> string { \"__N{reprName(repr).encodeUtf8().toHex()}\" }\nexport function isCopyRepr(repr: Repr) -> bool {\n  match repr {\n    case I64 => true\n    case F64 => true\n    case Bool => true\n    case Unit => true\n    case RangeInt => true\n    case _ => false\n  }\n}\n\n// Code without one pair of outer parentheses when they enclose all of it\n// (string literals inside are skipped), for positions where Rust needs none.\nexport function bare(code: string) -> string {\n  if code == \"()\" || !code.startsWith(\"(\") || !code.endsWith(\")\") {\n    return code\n  }\n  let mut depth = 0\n  let mut inString = false\n  let mut escaped = false\n  let mut index = 0\n  let last = code.scalars().length - 1\n  for scalar in code.scalars() {\n    if inString {\n      if escaped {\n        escaped = false\n      } else if scalar == \"\\\\\" {\n        escaped = true\n      } else if scalar == \"\\\"\" {\n        inString = false\n      }\n    } else if scalar == \"\\\"\" {\n      inString = true\n    } else if scalar == \"(\" {\n      depth += 1\n    } else if scalar == \")\" {\n      depth -= 1\n      if depth == 0 && index != last {\n        return code\n      }\n    }\n    index += 1\n  }\n  code.slice(1, last)\n}\n\n// Box boundary: a typed value entering a `Value` slot.\nexport function boxed(code: string, repr: Repr) -> string {\n  if nativeValueRepr(repr) { return \"<{rustType(repr)} as NativeValue>::into_value({bare(code)})\" }\n  if isVec(repr) { return \"Value::array(({code}).into_iter().map(|__v| {boxed(\"__v\", elementRepr(repr))}).collect())\" }\n  match repr {\n    case I64 => \"Value::Int({bare(code)})\"\n    case F64 => \"Value::Float({bare(code)})\"\n    case Bool => \"Value::Bool({bare(code)})\"\n    case Unit => \"\\{ let _: () = {code}; Value::Unit \\}\"\n    case RangeInt => \"\\{ let (lo, hi, inclusive, step) = {code}; Value::Range \\{ lo, hi, inclusive, step \\} \\}\"\n    case _ => code\n  }\n}\n\n// Unbox boundary: a `Value` entering a typed slot. The checker proves the\n// runtime kind; the shared leaf still faults (never panics) if it differs.\nexport function unboxed(code: string, repr: Repr, span: string) -> string {\n  if nativeValueRepr(repr) { return \"<{rustType(repr)} as NativeValue>::from_value({bare(code)}, {span})?\" }\n  match repr {\n    case I64 => \"native_unbox_int({bare(code)}, {span})?\"\n    case F64 => \"native_unbox_float({bare(code)}, {span})?\"\n    case Bool => \"native_unbox_bool({bare(code)}, {span})?\"\n    case Unit => \"\\{ let _: Value = {code}; \\}\"\n    case RangeInt => \"match {code} \\{ Value::Range \\{ lo, hi, inclusive, step \\} => (lo, hi, inclusive, step), __other => return Err(fault(codes::GUARD_TYPE, format!(\\\"native array element expected `Range<int>`, found `\\{\\}` (internal: unreachable on a checked build)\\\", __other.kind()), {span})) \\}\"\n    case _ => code\n  }\n}\n\nexport function coerce(code: string, from: Repr, to: Repr, span: string) -> Result<string, string> {\n  if from == to || isUntyped(to) {\n    Ok(code)\n  } else if isUntyped(from) {\n    Err(\"unsupported: type untyped value into {reprName(to)}\")\n  } else if isOption(from) && isOption(to) {\n    let source = elementRepr(from)\n    let target = elementRepr(to)\n    let payload = coerce(\"__payload\",source,target,span)?\n    Ok(\"match {code} \\{ NativeOption::Some(__payload) => NativeOption::Some({payload}), NativeOption::None => NativeOption::None, NativeOption::Dynamic(__value) => NativeOption::Dynamic(__value) \\}\")\n  } else if isResult(from) && isResult(to) {\n    let source = resultParts(from)\n    let target = resultParts(to)\n    let ok = coerce(\"__payload\",source[0],target[0],span)?\n    let error = coerce(\"__payload\",source[1],target[1],span)?\n    Ok(\"match {code} \\{ NativeResult::Ok(__payload) => NativeResult::Ok({ok}), NativeResult::Err(__payload) => NativeResult::Err({error}), NativeResult::Dynamic(__value) => NativeResult::Dynamic(__value) \\}\")\n  } else if isValueRepr(to) {\n    Ok(boxed(code, from))\n  } else if isValueRepr(from) {\n    Ok(unboxed(code, to, span))\n  } else if isArray(from) && isArray(to) {\n    Ok(unboxed(boxed(code,from),to,span))\n  } else if nativeRepr(from) && nativeRepr(to) {\n    Ok(unboxed(boxed(code,from),to,span))\n  } else if to == Repr.Unit {\n    Ok(\"\\{ let _ = {code}; \\}\")\n  } else {\n    Err(\"unsupported: type representation {reprName(from)} as {reprName(to)}\")\n  }\n}\n\n// A captured mutable local shares storage with every closure and defer.\n// Scalar cells retain their Rust type; boxed cells retain Value sharing.\nexport function sharedInit(code: string, repr: Repr) -> string {\n  if isCopyRepr(repr) {\n    \"Rc::new(std::cell::Cell::new({bare(code)}))\"\n  } else {\n    \"Rc::new(std::cell::RefCell::new({bare(code)}))\"\n  }\n}\n\nexport function sharedRead(name: string, repr: Repr) -> string {\n  // End the borrow before surrounding code calls another closure or writes.\n  if isCopyRepr(repr) { \"{name}.get()\" } else { \"\\{ let __value = {name}.borrow().clone(); __value \\}\" }\n}\n\nexport function sharedWrite(name: string, code: string, repr: Repr) -> string {\n  if isCopyRepr(repr) { \"{name}.set({bare(code)});\" } else { \"\\{ let __value = {bare(code)}; *{name}.borrow_mut() = __value; \\}\" }\n}\n\nexport function parameterGuard(value: string, repr: Repr, span: string) -> string {\n  if nativeValueRepr(repr) { return unboxed(value, repr, span) }\n  let fault = \"return Err(fault(codes::GUARD_TYPE, \\\"argument does not match parameter type (§6)\\\", {span}))\"\n  match repr {\n    case I64 => \"match {value} \\{ Value::Int(__v) => __v, _ => {fault} \\}\"\n    case F64 => \"match {value} \\{ Value::Float(__v) => __v, _ => {fault} \\}\"\n    case Bool => \"match {value} \\{ Value::Bool(__v) => __v, _ => {fault} \\}\"\n    case Unit => \"match {value} \\{ Value::Unit => (), _ => {fault} \\}\"\n    case RangeInt => \"match {value} \\{ Value::Range \\{ lo, hi, inclusive, step \\} => (lo, hi, inclusive, step), _ => {fault} \\}\"\n    case _ => value\n  }\n}\n",
      "sourceSha256": "40b793788219de8d832b54877bb50590113ca663a76934d8211b4eaecdf5f48f"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/rust_text.tpz",
      "language": "topaz",
      "bytes": 1044,
      "sha256": "aa8b580dec9f7b638bd053827eedda4add8aa06f1bd14f2f7a88b29405075ce0",
      "content": "// Rust source text encoding, independent of the IR transport.\nconst HEX_DIGITS = \"0123456789abcdef\"\n\nfunction hex(value: int) -> string {\n  // rustStr calls this only for control scalars below 32 and DEL (127).\n  // Two hexadecimal digits cover that domain without a recursive call edge.\n  if value < 16 {\n    HEX_DIGITS.slice(value, value + 1)\n  } else {\n    HEX_DIGITS.slice(value / 16, value / 16 + 1) + HEX_DIGITS.slice(value % 16, value % 16 + 1)\n  }\n}\n\n// A Rust string literal whose value is exactly `text`.\nexport function rustStr(text: string) -> string {\n  let mut out: Array<string> = [\"\\\"\"]\n  for scalar in text.scalars() {\n    let code = scalar.codePointAt(0) ?? 0\n    if scalar == \"\\\\\" {\n      out.push(\"\\\\\\\\\")\n    } else if scalar == \"\\\"\" {\n      out.push(\"\\\\\\\"\")\n    } else if scalar == \"\\n\" {\n      out.push(\"\\\\n\")\n    } else if scalar == \"\\t\" {\n      out.push(\"\\\\t\")\n    } else if code < 32 || code == 127 {\n      out.push(\"\\\\u\\{{hex(code)}\\}\")\n    } else {\n      out.push(scalar)\n    }\n  }\n  out.push(\"\\\"\")\n  out.join(\"\")\n}\n",
      "sourceSha256": "aa8b580dec9f7b638bd053827eedda4add8aa06f1bd14f2f7a88b29405075ce0"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/emitter/type_test.tpz",
      "language": "topaz",
      "bytes": 14654,
      "sha256": "c363a0188540d395c08f9295328bed196aef2d83b76f1d8b1ba399f6f9b95a44",
      "content": "import std.json as jsonBoundary\n\nimport emitter.ir { Table, typeDeclaration }\nimport types { PreviewTypeAtom }\nimport emitter.repr { Repr, isArray, isOption, isResult, reprAt, isCopyRepr, nativeRepr, boxed }\nimport emitter.rust_text { rustStr }\n\nexport function childTypes(atoms: Array<PreviewTypeAtom>, parent: int) -> Array<int> {\n  let mut out: Array<int> = []\n  let mut index = 0\n  for atom in atoms {\n    if atom.parent == parent { out.push(index) }\n    index += 1\n  }\n  out\n}\n\n// Semantic atoms preserve alias expansion, structural fields and nominal\n// identities. Tests inspect the value; a container's outer tag is insufficient.\nfunction typeTestInner(table: Table, scopeId: string, atoms: Array<PreviewTypeAtom>, index: int, access: string, repr: Repr, active: Map<string, string>) -> Result<string, string> {\n  if index >= atoms.length { return Err(\"unsupported: missing pattern type\") }\n  let atom = atoms[index]\n  let subs = childTypes(atoms, index)\n  if atom.kind == \"newtype\" && atom.identity == \"builtin:Length\" && atom.origin == \"\" {\n    if subs.length != 1 {return Err(\"unsupported: Length unit argument\")}\n    let marker=atoms[subs[0]]\n    let unit=marker.identity.replace(\"builtin:\",\"\")\n    if marker.kind != \"newtype\" || marker.origin != \"\" || marker.identity != \"builtin:{unit}\" || (unit != \"Pt\" && unit != \"Mm\" && unit != \"Cm\" && unit != \"In\" && unit != \"Em\") {return Err(\"unsupported: Length unit marker\")}\n    return Ok(\"length_from_value(&({access})).is_some_and(|v| v.unit == LengthUnit::{unit})\")\n  }\n  if atom.kind == \"union\" {\n    let mut tests: Array<string> = []\n    for sub in subs { tests.push(\"({typeTestInner(table, scopeId, atoms, sub, access, repr, active)?})\") }\n    return Ok(if tests.length == 0 { \"false\" } else { tests.join(\" || \") })\n  }\n  if atom.kind == \"unknown\" || atom.kind == \"type-parameter\" { return Ok(\"true\") }\n  if atom.kind == \"rigid\" {\n    match runtimeBoundType(table, scopeId, atom.name)? {\n      case Some(body) => return typeTestInner(table, scopeId, body, 0, access, repr, active)\n      case None => return Ok(\"true\")\n    }\n  }\n  if isCopyRepr(repr) {\n    if reprAt(atoms, index) != repr { return Ok(\"false\") }\n    if atom.kind != \"literal\" { return Ok(\"true\") }\n    return Ok(\"({access}) == {atom.value}\")\n  }\n  let value = \"&({access})\"\n  if atom.kind == \"primitive\" || atom.kind == \"literal\" {\n    let variant = match atom.name {\n      case \"int\" => \"Int\"\n      case \"float\" => \"Float\"\n      case \"bool\" => \"Bool\"\n      case \"string\" => \"Str\"\n      case \"unit\" => return Ok(\"matches!({value}, Value::Unit)\")\n      case \"null\" => return Ok(\"matches!({value}, Value::Null)\")\n      case \"never\" => return Ok(\"false\")\n      case _ => return Err(\"unsupported: pattern type {atom.name}\")\n    }\n    if atom.kind == \"literal\" {\n      let test = if atom.name == \"string\" { \"__v.as_ref() == {rustStr(atom.value)}\" } else { \"*__v == {atom.value}\" }\n      return Ok(\"matches!({value}, Value::{variant}(__v) if {test})\")\n    }\n    return Ok(\"matches!({value}, Value::{variant}(_))\")\n  }\n  if atom.kind == \"function\" {\n    let mut count = 0\n    let mut variadic = false\n    for sub in subs {\n      if atoms[sub].field == \"parameters\" { count += 1 }\n      if atoms[sub].field == \"variadic\" { variadic = true }\n    }\n    return Ok(\"callable_shape_matches({value}, {count}, {variadic})\")\n  }\n  if atom.kind == \"record\" {\n    let mut checks: Array<string> = []\n    for sub in subs {\n      let test = typeTestInner(table, scopeId, atoms, sub, \"(*__v)\", Repr.Value, active)?\n      checks.push(\"(match __rec.get({rustStr(atoms[sub].edgeName)}) \\{ Some(__v) => {test}, None => false \\})\")\n    }\n    let rest = if checks.length == 0 { \"\" } else { \" && {checks.join(\" && \")}\" }\n    return Ok(\"match {value} \\{ Value::Record(__rec) => __rec.len() == {subs.length}{rest}, _ => false \\}\")\n  }\n  if atom.kind == \"constructor\" {\n    if atom.name == \"Option\" && subs.length == 1 {\n      let test = typeTestInner(table, scopeId, atoms, subs[0], \"(**__v)\", Repr.Value, active)?\n      return Ok(\"match {value} \\{ Value::None => true, Value::Some(__v) => {test}, _ => false \\}\")\n    }\n    if atom.name == \"Result\" && subs.length == 2 {\n      let yes = typeTestInner(table, scopeId, atoms, subs[0], \"(**__v)\", Repr.Value, active)?\n      let no = typeTestInner(table, scopeId, atoms, subs[1], \"(**__v)\", Repr.Value, active)?\n      return Ok(\"match {value} \\{ Value::Ok(__v) => {yes}, Value::Err(__v) => {no}, _ => false \\}\")\n    }\n    if (atom.name == \"Array\" || atom.name == \"Set\") && subs.length == 1 {\n      if atom.name == \"Array\" {\n        let stable = stableArrayElement(table, atoms, subs[0])\n        if stable != \"\" { return Ok(\"array_elements_match(&({access}), {stable})\") }\n      }\n      let test = typeTestInner(table, scopeId, atoms, subs[0], \"(*__v)\", Repr.Value, active)?\n      let items = if atom.name == \"Set\" { \".items()\" } else { \"\" }\n      return Ok(\"match {value} \\{ Value::{atom.name}(__xs) => __xs.borrow(){items}.iter().all(|__v| {test}), _ => false \\}\")\n    }\n    if atom.name == \"Map\" && subs.length == 2 {\n      let key = typeTestInner(table, scopeId, atoms, subs[0], \"__key\", Repr.Value, active)?\n      let val = typeTestInner(table, scopeId, atoms, subs[1], \"__val\", Repr.Value, active)?\n      return Ok(\"match {value} \\{ Value::Map(__xs) => __xs.borrow().pairs().into_iter().all(|(__key, __val)| ({key}) && ({val})), _ => false \\}\")\n    }\n  }\n  if atom.kind == \"enum\" || atom.kind == \"nominal-record\" || atom.kind == \"newtype\" {\n    return nominalTest(table, scopeId, atoms, index, access, active)\n  }\n  let variant = match atom.kind {\n    case \"json-value\" => \"Json\"\n    case \"toml-value\" => \"Toml\"\n    case \"url\" => \"Url\"\n    case \"match\" => \"RegexMatch\"\n    case \"bytes\" => \"Bytes\"\n    case \"byte-buffer\" => \"ByteBuffer\"\n    case \"path\" => \"Path\"\n    case \"regex\" => \"Regex\"\n    case \"date\" => \"Date\"\n    case \"big-int\" => \"BigInt\"\n    case \"decimal\" => \"Decimal\"\n    case \"rounding-mode\" => return Ok(\"matches!({value}, Value::Enum \\{ enum_id, .. \\} if enum_id.as_ref() == \\\"RoundingMode\\\")\")\n    case _ => \"\"\n  }\n  if variant != \"\" { return Ok(\"matches!({value}, Value::{variant}(_))\") }\n  return Err(\"unsupported: pattern type {atom.kind}/{atom.name}/{atom.identity}\")\n}\n\nexport function nominalIdentity(atom: PreviewTypeAtom) -> string {\n  if atom.identity.contains(\"::\") || atom.origin == \"\" { atom.identity }\n  else { \"{atom.origin}::{atom.identity}\" }\n}\n\n// Nested mutable contents are deliberately excluded: their tests must observe\n// mutations through aliases even when the containing array has not changed.\nfunction stableArrayElement(table: Table, atoms: Array<PreviewTypeAtom>, index: int) -> string {\n  let atom = atoms[index]\n  if atom.kind == \"primitive\" {\n    let variant = match atom.name {\n      case \"int\" => \"Int\"\n      case \"float\" => \"Float\"\n      case \"bool\" => \"Bool\"\n      case \"string\" => \"String\"\n      case \"unit\" => \"Unit\"\n      case \"null\" => \"Null\"\n      case _ => \"\"\n    }\n    return if variant == \"\" { \"\" } else { \"StableArrayElement::{variant}\" }\n  }\n  if atom.kind != \"nominal-record\" && atom.kind != \"enum\" && atom.kind != \"newtype\" { return \"\" }\n  if childTypes(atoms, index).length != 0 { return \"\" }\n  let identity = nominalIdentity(atom)\n  let declaration = match table.nominals.get(identity) {\n    case Some(found) => found\n    case None => return \"\"\n  }\n  for part in declaration {\n    if part.parent == 0 && part.field == \"typeParameters\" { return \"\" }\n  }\n  let variant = if atom.kind == \"nominal-record\" { \"NominalRecord\" }\n    else if atom.kind == \"enum\" { \"Enum\" } else { \"Newtype\" }\n  \"StableArrayElement::{variant}({rustStr(identity)})\"\n}\n\nexport function subtree(atoms: Array<PreviewTypeAtom>, root: int) -> Array<PreviewTypeAtom> {\n  let mut out: Array<PreviewTypeAtom> = []\n  let mut indexes: Map<int, int> = map {}\n  let mut index = root\n  while index < atoms.length {\n    let atom = atoms[index]\n    if index > root && atom.parent < root { break }\n    let parent = if index == root { -1 } else { indexes.get(atom.parent) ?? -1 }\n    indexes.insert(index, out.length)\n    out.push(PreviewTypeAtom { ...atom, parent: parent,\n      field: if index == root { \"root\" } else { atom.field },\n      index: if index == root { 0 } else { atom.index },\n      edgeName: if index == root { \"\" } else { atom.edgeName } })\n    index += 1\n  }\n  out\n}\n\nexport function substitute(atoms: Array<PreviewTypeAtom>, params: Map<string, Array<PreviewTypeAtom>>) -> Array<PreviewTypeAtom> {\n  let mut out: Array<PreviewTypeAtom> = []\n  let mut indexes: Map<int, int> = map {}\n  let mut index = 0\n  for atom in atoms {\n    let parent = if atom.parent < 0 { -1 } else { indexes.get(atom.parent) ?? -1 }\n    indexes.insert(index, out.length)\n    let actual = if atom.kind == \"type-parameter\" || atom.kind == \"rigid\" { params.get(atom.name) } else { None }\n    match actual {\n      case Some(types) => {\n        let offset = out.length\n        for t in types {\n          out.push(PreviewTypeAtom { ...t,\n            parent: if t.parent < 0 { parent } else { t.parent + offset },\n            field: if t.parent < 0 { atom.field } else { t.field },\n            index: if t.parent < 0 { atom.index } else { t.index },\n            edgeName: if t.parent < 0 { atom.edgeName } else { t.edgeName } })\n        }\n      }\n      case None => out.push(PreviewTypeAtom { ...atom, parent: parent })\n    }\n    index += 1\n  }\n  out\n}\n\nfunction nominalTest(table: Table, scopeId: string, atoms: Array<PreviewTypeAtom>, index: int, access: string,\n  active: Map<string, string>) -> Result<string, string> {\n  let atom = atoms[index]\n  let identity = nominalIdentity(atom)\n  let declaration = match table.nominals.get(identity) {\n    case Some(found) => found\n    case None => return Err(\"unsupported: nominal type declaration {identity}\")\n  }\n  let types = subtree(atoms, index)\n  let key = jsonBoundary.stringify(types)?\n  match active.get(key) {\n    case Some(helper) => return Ok(\"{helper}(&({access}))\")\n    case None => ()\n  }\n  let helper = \"__nominal_type_{active.length}\"\n  let mut next: Map<string, string> = map {}\n  for pair in active.entries { next.insert(pair.key, pair.value) }\n  next.insert(key, helper)\n  let mut params: Map<string, Array<PreviewTypeAtom>> = map {}\n  let args = childTypes(atoms, index)\n  let mut count = 0\n  for parameter in declaration {\n    if parameter.parent == 0 && parameter.field == \"typeParameters\" {\n      if count >= args.length { return Err(\"unsupported: nominal type argument arity {identity}\") }\n      params.insert(parameter.name, subtree(atoms, args[count]))\n      count += 1\n    }\n  }\n  if count != args.length { return Err(\"unsupported: nominal type argument arity {identity}\") }\n  if count == 0 {\n    let id = rustStr(identity)\n    if atom.kind == \"nominal-record\" { return Ok(\"({access}).is_nominal_record_declaration({id})\") }\n    if atom.kind == \"newtype\" { return Ok(\"({access}).is_newtype_declaration({id})\") }\n    return Ok(\"matches!(&({access}), Value::Enum \\{ enum_id, declaration_identity, .. \\} if nominal_declaration_identity(enum_id.as_ref(), declaration_identity.as_deref()) == {id})\")\n  }\n  let definition = substitute(declaration, params)\n  let roots = childTypes(definition, 0)\n  let mut checks: Array<string> = []\n  let id = rustStr(identity)\n  let mut body = \"false\"\n  if atom.kind == \"nominal-record\" {\n    for field in roots {\n      if definition[field].field != \"fields\" { continue }\n      let test = typeTestInner(table, scopeId, definition, field, \"(*__field)\", Repr.Value, next)?\n      checks.push(\"__fields.iter().find(|(n, _)| n.as_ref() == {rustStr(definition[field].edgeName)}).map(|(_, __field)| {test}).unwrap_or(false)\")\n    }\n    let fields = if checks.length == 0 { \"true\" } else { checks.join(\" && \") }\n    body = \"match __value \\{ Value::NominalRecord \\{ record_id, declaration_identity, fields: __fields, .. \\} if nominal_declaration_identity(record_id.as_ref(), declaration_identity.as_deref()) == {id} => {fields}, _ => false \\}\"\n  } else if atom.kind == \"newtype\" {\n    for field in roots {\n      if definition[field].field != \"base\" { continue }\n      let test = typeTestInner(table, scopeId, definition, field, \"(**inner)\", Repr.Value, next)?\n      body = \"match __value \\{ Value::Newtype \\{ newtype_id, declaration_identity, inner, .. \\} if nominal_declaration_identity(newtype_id.as_ref(), declaration_identity.as_deref()) == {id} => {test}, _ => false \\}\"\n    }\n    ()\n  } else {\n    for variant in roots {\n      if definition[variant].field != \"variants\" { continue }\n      let payload = childTypes(definition, variant)\n      let mut tests = [\"payloads.len() == {payload.length}\"]\n      let mut position = 0\n      for field in payload {\n        let test = typeTestInner(table, scopeId, definition, field, \"payloads[{position}]\", Repr.Value, next)?\n        tests.push(\"({test})\")\n        position += 1\n      }\n      checks.push(\"{rustStr(definition[variant].name)} if {tests.join(\" && \")} => true\")\n    }\n    body = \"match __value \\{ Value::Enum \\{ enum_id, declaration_identity, variant, payloads, .. \\} if nominal_declaration_identity(enum_id.as_ref(), declaration_identity.as_deref()) == {id} => match variant.as_ref() \\{ {checks.join(\", \")}, _ => false \\}, _ => false \\}\"\n  }\n  Ok(\"\\{ fn {helper}(__value: &Value) -> bool \\{ {body} \\} {helper}(&({access})) \\}\")\n}\n\nexport function typeTest(table: Table, scopeId: string, atoms: Array<PreviewTypeAtom>, index: int, access: string, repr: Repr) -> Result<string, string> {\n  let active: Map<string, string> = map {}\n  if nativeRepr(repr) || repr == Repr.Text || repr == Repr.Json || isOption(repr) || isResult(repr) || isArray(repr) || repr == Repr.BigInt { return typeTestInner(table, scopeId, atoms, index, boxed(\"({access}).clone()\", repr), Repr.Value, active) }\n  typeTestInner(table, scopeId, atoms, index, access, repr, active)\n}\n\n// Named runtime types take precedence over erasing a generic parameter.\nfunction runtimeBoundType(table: Table, scopeId: string, name: string) -> Result<Option<Array<PreviewTypeAtom>>, string> {\n  let declaration = match typeDeclaration(table, scopeId, name)? {\n    case Some(found) => found\n    case None => return Ok(None)\n  }\n  if declaration.kind != \"type-alias\" { return Ok(Some([declaration.typeDefinition[0]])) }\n  let mut index = 0\n  for atom in declaration.typeDefinition {\n    if atom.parent == 0 && atom.field == \"typeParameters\" {\n      return Err(\"unsupported: generic alias arity {name}\")\n    }\n    if atom.parent == 0 && atom.field == \"base\" {\n      return Ok(Some(subtree(declaration.typeDefinition, index)))\n    }\n    index += 1\n  }\n  Err(\"unsupported: alias definition {name}\")\n}\n",
      "sourceSha256": "c363a0188540d395c08f9295328bed196aef2d83b76f1d8b1ba399f6f9b95a44"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/layout.tpz",
      "language": "topaz",
      "bytes": 13597,
      "sha256": "845743615e1d0629310897b57310c6a63bab7051bfaca2a9b5d250d5608a2339",
      "content": "import types { LayoutResult, PreviewDiagnostic, PreviewToken }\n\nfunction token(kind: string, lo: int, hi: int, synthetic: bool) -> PreviewToken {\n  PreviewToken {\n    kind: kind,\n    lo: lo,\n    hi: hi,\n    stream: \"layout\",\n    synthetic: synthetic,\n  }\n}\n\nfunction copyToken(value: PreviewToken) -> PreviewToken {\n  token(value.kind, value.lo, value.hi, value.synthetic)\n}\n\nfunction diagnostic(code: string, message: string, lo: int, hi: int) -> PreviewDiagnostic {\n  PreviewDiagnostic { code: code, message: message, lo: lo, hi: hi, notes: [] }\n}\n\nfunction lastTokenKind(values: Array<PreviewToken>) -> string {\n  values[values.length - 1].kind\n}\n\nfunction text(bytes: Bytes, lo: int, hi: int) -> string {\n  match bytes.slice(lo, hi).decodeUtf8() {\n    case Ok(value) => value\n    case Err(_) => \"\"\n  }\n}\n\nfunction isCloser(kind: string) -> bool {\n  kind == \"right-paren\" ||\n    kind == \"right-bracket\" ||\n    kind == \"right-brace\" ||\n    kind == \"interpolation-end\"\n}\n\nfunction isKeyword(kind: string) -> bool {\n  kind.startsWith(\"keyword/\")\n}\n\nenum LineContinuation {\n  Leading,\n  Trailing,\n  Both,\n}\n\nfunction lineContinuation(kind: string) -> Option<LineContinuation> {\n  if kind == \"gt\" || kind == \"gt-gt\" || kind == \"keyword/else\" {\n    Some(LineContinuation.Leading)\n  } else if kind == \"plus\" || kind == \"minus\" || kind == \"bang\" ||\n    kind == \"tilde\" || kind == \"comma\" || kind == \"fat-arrow\" ||\n    kind == \"left-paren\" || kind == \"left-bracket\" {\n    Some(LineContinuation.Trailing)\n  } else if kind == \"star-star\" || kind == \"star\" || kind == \"slash\" ||\n    kind == \"percent\" || kind == \"dot-dot\" || kind == \"dot-dot-lt\" ||\n    kind == \"lt\" || kind == \"le\" || kind == \"ge\" || kind == \"eq-eq\" ||\n    kind == \"not-eq\" || kind == \"keyword/in\" || kind == \"and-and\" ||\n    kind == \"or-or\" || kind == \"question-question\" || kind == \"pipe-gt\" ||\n    kind == \"eq\" || kind == \"plus-eq\" || kind == \"minus-eq\" ||\n    kind == \"star-eq\" || kind == \"slash-eq\" || kind == \"percent-eq\" ||\n    kind == \"question-question-eq\" || kind == \"dot\" ||\n    kind == \"question-dot\" || kind == \"keyword/by\" {\n    Some(LineContinuation.Both)\n  } else {\n    None\n  }\n}\n\nfunction isTrailing(kind: string) -> bool {\n  match lineContinuation(kind) {\n    case Some(Trailing) => true\n    case Some(Both) => true\n    case _ => false\n  }\n}\n\nfunction previousIs(previous: Option<string>, kind: string) -> bool {\n  match previous {\n    case Some(value) => value == kind\n    case None => false\n  }\n}\n\nfunction previousIsTrailing(previous: Option<string>) -> bool {\n  match previous {\n    case Some(kind) => isTrailing(kind)\n    case None => false\n  }\n}\n\nfunction isLeading(kind: string) -> bool {\n  match lineContinuation(kind) {\n    case Some(Leading) => true\n    case Some(Both) => true\n    case _ => false\n  }\n}\n\nfunction startsRecordField(tokens: Array<PreviewToken>, start: int) -> bool {\n  let mut index = start\n  let mut first: Option<string> = None\n  while index < tokens.length {\n    let kind = tokens[index].kind\n    index += 1\n    if kind == \"newline\" {\n      continue\n    }\n    match first {\n      case Some(head) => return (head == \"identifier\" || isKeyword(head)) &&\n        kind == \"colon\"\n      case None => {\n        first = Some(kind)\n      }\n    }\n  }\n  false\n}\n\nfunction keywordHasFieldRole(\n  state: LayoutState,\n  tokens: Array<PreviewToken>,\n  index: int,\n  current: PreviewToken,\n) -> bool {\n  if !isKeyword(current.kind) {\n    return false\n  }\n  if previousIs(state.previous, \"dot\") || previousIs(state.previous, \"question-dot\") {\n    return true\n  }\n  let mut next = index + 1\n  while next < tokens.length {\n    let kind = tokens[next].kind\n    next += 1\n    if kind != \"newline\" {\n      return kind == \"colon\"\n    }\n  }\n  false\n}\n\nenum LayoutPatternKind {\n  Binding,\n  Case,\n  For,\n}\n\nrecord LayoutPattern {\n  depth: int,\n  kind: LayoutPatternKind,\n}\n\nfunction patternIsActive(pattern: Option<LayoutPattern>) -> bool {\n  match pattern {\n    case Some(_) => true\n    case None => false\n  }\n}\n\nfunction patternContinuesAt(pattern: Option<LayoutPattern>, depth: int) -> bool {\n  match pattern {\n    case Some(value) => value.depth == depth\n    case None => false\n  }\n}\n\nenum LayoutMode {\n  Separator,\n  Continuation,\n}\n\nenum LayoutOpener {\n  Program,\n  Paren,\n  Bracket,\n  Brace,\n  Interpolation,\n}\n\nfunction classifyBrace(\n  state: LayoutState,\n  tokens: Array<PreviewToken>,\n  index: int,\n  frameDepth: int,\n) -> LayoutMode {\n  if state.moduleItem || patternIsActive(state.pattern) {\n    return LayoutMode.Continuation\n  }\n  let mut concurrentDepths = state.concurrentDepths\n  if concurrentDepths.length > 0 &&\n    concurrentDepths[concurrentDepths.length - 1] == frameDepth {\n    concurrentDepths.pop()\n    return LayoutMode.Separator\n  }\n  if startsRecordField(tokens, index + 1) {\n    LayoutMode.Continuation\n  } else {\n    LayoutMode.Separator\n  }\n}\n\nrecord LayoutFrame {\n  mode: LayoutMode,\n  opener: LayoutOpener,\n  hasItem: bool,\n}\n\nfunction topFrame(frames: Array<LayoutFrame>) -> LayoutFrame {\n  frames[frames.length - 1]\n}\n\nrecord LayoutState {\n  output: Array<PreviewToken>,\n  diagnostics: Array<PreviewDiagnostic>,\n  frames: Array<LayoutFrame>,\n  pending: Option<PreviewToken>,\n  previous: Option<string>,\n  pattern: Option<LayoutPattern>,\n  concurrentDepths: Array<int>,\n  moduleItem: bool,\n}\n\nfunction markFrameItem(state: LayoutState) -> () {\n  let mut frames = state.frames\n  let frame = topFrame(frames)\n  frames.pop()\n  frames.push(LayoutFrame { ...frame, hasItem: true })\n}\n\nfunction clearConcurrentAtDepth(state: LayoutState, depth: int) -> () {\n  let mut depths = state.concurrentDepths\n  while depths.length > 0 && depths[depths.length - 1] == depth {\n    depths.pop()\n  }\n  ()\n}\n\nfunction resetStatementContext(state: LayoutState, frameDepth: int) -> LayoutState {\n  clearConcurrentAtDepth(state, frameDepth)\n  LayoutState { ...state, moduleItem: false, pattern: None }\n}\n\nfunction observeNewline(\n  state: LayoutState,\n  current: PreviewToken,\n  frameDepth: int,\n) -> LayoutState {\n  let pipeContinues = previousIs(state.previous, \"pipe\") &&\n    patternContinuesAt(state.pattern, frameDepth)\n  let frame = topFrame(state.frames)\n  if frame.mode == LayoutMode.Separator && frame.hasItem &&\n    lastTokenKind(state.output) != \"separator\" && !previousIsTrailing(state.previous) &&\n    !pipeContinues {\n    match state.pending {\n      case Some(_) => ()\n      case None => return LayoutState {\n        ...state,\n        pending: Some(current),\n      }\n    }\n  }\n  state\n}\n\nfunction consumeSemicolon(\n  state: LayoutState,\n  current: PreviewToken,\n  frameDepth: int,\n) -> LayoutState {\n  if topFrame(state.frames).mode == LayoutMode.Continuation {\n    let mut diagnostics = state.diagnostics\n    diagnostics.push(diagnostic(\n      \"TPZ1001\",\n      \"`;` does not separate items inside a delimiter list; use `,`\",\n      current.lo,\n      current.hi,\n    ))\n    LayoutState { ...state, previous: Some(\"semicolon\") }\n  } else {\n    let mut output = state.output\n    output.push(token(\"separator\", current.lo, current.hi, false))\n    let next = resetStatementContext(\n      LayoutState { ...state, pending: None },\n      frameDepth,\n    )\n    LayoutState { ...next, previous: Some(\"semicolon\") }\n  }\n}\n\nfunction flushPendingSeparator(\n  state: LayoutState,\n  current: PreviewToken,\n  frameDepth: int,\n) -> LayoutState {\n  let pending = match state.pending {\n    case Some(value) => value\n    case None => return state\n  }\n  let currentPipeContinues = current.kind == \"pipe\" &&\n    patternContinuesAt(state.pattern, frameDepth)\n  let mut next = state\n  if !isLeading(current.kind) && !currentPipeContinues &&\n    !isCloser(current.kind) && current.kind != \"eof\" {\n    let mut output = state.output\n    output.push(token(\n      \"separator\",\n      pending.lo,\n      pending.hi,\n      true,\n    ))\n    next = resetStatementContext(state, frameDepth)\n  }\n  LayoutState { ...next, pending: None }\n}\n\nfunction recognizeModuleItem(\n  state: LayoutState,\n  tokens: Array<PreviewToken>,\n  bytes: Bytes,\n  index: int,\n  current: PreviewToken,\n  frameDepth: int,\n) -> LayoutState {\n  if frameDepth != 1 || current.kind != \"identifier\" ||\n    (state.output.length > 0 && lastTokenKind(state.output) != \"separator\") ||\n    text(bytes, current.lo, current.hi) != \"import\" {\n    return state\n  }\n  if index + 1 < tokens.length && tokens[index + 1].kind == \"identifier\" {\n    LayoutState { ...state, moduleItem: true }\n  } else {\n    state\n  }\n}\n\nfunction closePatternIfTerminated(\n  state: LayoutState,\n  current: PreviewToken,\n  frameDepth: int,\n) -> LayoutState {\n  let pattern = match state.pattern {\n    case Some(value) => value\n    case None => return state\n  }\n  if pattern.depth != frameDepth { return state }\n  let terminates = match pattern.kind {\n    case Binding => current.kind == \"eq\" || current.kind == \"colon\"\n    case Case =>\n      current.kind == \"fat-arrow\" || current.kind == \"keyword/if\"\n    case For => current.kind == \"keyword/in\"\n  }\n  if terminates {\n    LayoutState { ...state, pattern: None }\n  } else {\n    state\n  }\n}\n\nfunction openerKind(kind: string) -> LayoutOpener {\n  if kind == \"left-paren\" || kind == \"right-paren\" {\n    LayoutOpener.Paren\n  } else if kind == \"left-bracket\" || kind == \"right-bracket\" {\n    LayoutOpener.Bracket\n  } else if kind == \"left-brace\" || kind == \"right-brace\" {\n    LayoutOpener.Brace\n  } else {\n    LayoutOpener.Interpolation\n  }\n}\n\nfunction openContinuationFrame(state: LayoutState, current: PreviewToken) -> () {\n  markFrameItem(state)\n  let mut frames = state.frames\n  frames.push(LayoutFrame {\n    mode: LayoutMode.Continuation,\n    opener: openerKind(current.kind),\n    hasItem: false,\n  })\n  ()\n}\n\nfunction openBraceFrame(\n  state: LayoutState,\n  tokens: Array<PreviewToken>,\n  index: int,\n  frameDepth: int,\n) -> () {\n  markFrameItem(state)\n  let mode = classifyBrace(\n    state,\n    tokens,\n    index,\n    frameDepth,\n  )\n  let mut frames = state.frames\n  frames.push(LayoutFrame { mode: mode, opener: LayoutOpener.Brace, hasItem: false })\n  ()\n}\n\nfunction closeFrame(state: LayoutState, current: PreviewToken) -> LayoutState {\n  let mut next = state\n  if topFrame(state.frames).opener == openerKind(current.kind) {\n    let mut frames = state.frames\n    let mut concurrentDepths = state.concurrentDepths\n    frames.pop()\n    let newDepth = frames.length\n    let mut trimming = true\n    while concurrentDepths.length > 0 && trimming {\n      if concurrentDepths[concurrentDepths.length - 1] > newDepth {\n        concurrentDepths.pop()\n      } else {\n        trimming = false\n      }\n    }\n    match state.pattern {\n      case Some(pattern) => {\n        if pattern.depth > newDepth {\n          next = LayoutState { ...state, pattern: None }\n        }\n      }\n      case None => ()\n    }\n  }\n  markFrameItem(next)\n  next\n}\n\nfunction beginPattern(\n  state: LayoutState,\n  kind: LayoutPatternKind,\n  frameDepth: int,\n) -> LayoutState {\n  markFrameItem(state)\n  LayoutState {\n    ...state,\n    pattern: Some(LayoutPattern { depth: frameDepth, kind: kind }),\n  }\n}\n\nfunction observeTokenStructure(\n  state: LayoutState,\n  tokens: Array<PreviewToken>,\n  index: int,\n  current: PreviewToken,\n  frameDepth: int,\n) -> LayoutState {\n  let keywordField = keywordHasFieldRole(state, tokens, index, current)\n  if current.kind == \"left-paren\" || current.kind == \"left-bracket\" ||\n    current.kind == \"interpolation-start\" {\n    openContinuationFrame(state, current)\n    state\n  } else if current.kind == \"left-brace\" {\n    openBraceFrame(state, tokens, index, frameDepth)\n    state\n  } else if isCloser(current.kind) {\n    closeFrame(state, current)\n  } else if current.kind == \"keyword/concurrent\" && !keywordField {\n    let mut concurrentDepths = state.concurrentDepths\n    concurrentDepths.push(frameDepth)\n    markFrameItem(state)\n    state\n  } else if (current.kind == \"keyword/let\" || current.kind == \"keyword/const\") &&\n    !keywordField {\n    beginPattern(state, LayoutPatternKind.Binding, frameDepth)\n  } else if current.kind == \"keyword/case\" && !keywordField {\n    beginPattern(state, LayoutPatternKind.Case, frameDepth)\n  } else if current.kind == \"keyword/for\" && !keywordField {\n    beginPattern(state, LayoutPatternKind.For, frameDepth)\n  } else {\n    markFrameItem(state)\n    state\n  }\n}\n\nexport function normalize(tokens: Array<PreviewToken>, source: string) -> LayoutResult {\n  let bytes = (source).encodeUtf8()\n  let mut state = LayoutState {\n    output: [],\n    diagnostics: [],\n    frames: [LayoutFrame {\n      mode: LayoutMode.Separator,\n      opener: LayoutOpener.Program,\n      hasItem: false,\n    }],\n    pending: None,\n    previous: None,\n    pattern: None,\n    concurrentDepths: [],\n    moduleItem: false,\n  }\n  let mut index = 0\n  while index < tokens.length {\n    let current = tokens[index]\n    let frameDepth = state.frames.length\n    if current.kind == \"newline\" {\n      state = observeNewline(state, current, frameDepth)\n      index += 1\n      continue\n    }\n    if current.kind == \"semicolon\" {\n      state = consumeSemicolon(state, current, frameDepth)\n      index += 1\n      continue\n    }\n    state = flushPendingSeparator(state, current, frameDepth)\n    state = recognizeModuleItem(state, tokens, bytes, index, current, frameDepth)\n    state = closePatternIfTerminated(state, current, frameDepth)\n    state = observeTokenStructure(state, tokens, index, current, frameDepth)\n    let mut output = state.output\n    output.push(copyToken(current))\n    state = LayoutState { ...state, previous: Some(current.kind) }\n    index += 1\n  }\n  LayoutResult { tokens: state.output, diagnostics: state.diagnostics }\n}\n",
      "sourceSha256": "845743615e1d0629310897b57310c6a63bab7051bfaca2a9b5d250d5608a2339"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/length.tpz",
      "language": "topaz",
      "bytes": 6186,
      "sha256": "aa8700ff914f963437abac3cf0b8b39bbd193cb62b32775274ef295b99437e88",
      "content": "import literal { validDecimalLiteral }\nimport types { SyntaxNode }\n// Compiler numeric operations. Exact integers/rationals use the existing BigInt\n// runtime. This is shared by K literal formation, constant folding and emission.\nexport record LengthGrid { unit: string, ticks: int }\nconst OVERFLOW = \"Length result is not representable\"\nconst ZERO = \"Length division by zero\"\nexport function unitName(suffix: string) -> string {\n  match suffix { case \"pt\" => \"Pt\"; case \"mm\" => \"Mm\"; case \"cm\" => \"Cm\"; case \"in\" => \"In\"; case \"em\" => \"Em\"; case _ => \"\" }\n}\nfunction bi(n: int) -> BigInt { n.toBigInt() }\nfunction abs(n: BigInt) -> BigInt { if n < bi(0) { -n } else { n } }\nfunction powerTwo(n: int) -> BigInt {\n  let mut value = bi(1)\n  let mut i = 0\n  while i < n { value = value * bi(2); i += 1 }\n  value\n}\nexport function roundFraction(n: BigInt, d: BigInt) -> Result<int, string> {\n  if d == bi(0) { return Err(ZERO) }\n  let negative = (n < bi(0)) != (d < bi(0))\n  let numerator = abs(n)\n  let denominator = abs(d)\n  let mut q = numerator.div(denominator)?\n  let r = numerator.mod(denominator)?\n  if r * bi(2) > denominator || (r * bi(2) == denominator && q.mod(bi(2))? != bi(0)) { q = q + bi(1) }\n  let signed = if negative { -q } else { q }\n  match signed.toInt() { case Some(value) => Ok(value); case None => Err(OVERFLOW) }\n}\nfunction digit(b: int) -> bool { b >= 48 && b <= 57 }\nexport function validLiteral(spelling: string) -> bool {\n  let bytes = spelling.encodeUtf8()\n  if bytes.length() < 3 { return false }\n  let suffix = match bytes.slice(bytes.length()-2, bytes.length()).decodeUtf8() { case Ok(s) => s; case Err(_) => return false }\n  if unitName(suffix) == \"\" { return false }\n  let number = match bytes.slice(0,bytes.length()-2).decodeUtf8() { case Ok(s) => s; case Err(_) => return false }\n  validDecimalLiteral(number)\n}\n\nexport function decodeLength(spelling: string, negative: bool) -> Result<LengthGrid, string> {\n  if !validLiteral(spelling) { return Err(\"malformed Length literal\") }\n  let size = spelling.encodeUtf8().length()\n  let number = spelling.slice(0, size - 2).replace(\"_\", \"\")\n  let unit = unitName(spelling.slice(size - 2, size))\n  let mut magnitude = bi(0)\n  let mut denominator = bi(1)\n  let mut fraction = false\n  for b in number.encodeUtf8().toArray() {\n    if b == 46 { fraction = true } else {\n      magnitude = magnitude * bi(10) + bi(b - 48)\n      if fraction { denominator = denominator * bi(10) }\n    }\n  }\n  let multiplier = match unit { case \"In\" => 4718592; case \"Mm\" => 23592960; case \"Cm\" => 235929600; case _ => 65536 }\n  if unit == \"Mm\" || unit == \"Cm\" { denominator = denominator * bi(127) }\n  let signed = if negative { -magnitude } else { magnitude }\n  Ok(LengthGrid { unit: unit, ticks: roundFraction(signed * bi(multiplier), denominator)? })\n}\nexport function lengthFloatMultiply(ticks: int, scalar: float) -> Result<int, string> {\n  if !scalar.isFinite() { return Err(OVERFLOW) }\n  if scalar == 0.0 || ticks == 0 { return Ok(0) }\n  let mut value = scalar.abs()\n  let mut exponent = 0\n  // Powers of two are exact, including the subnormal-to-normal transition.\n  while value < 1.0 { value = value * 2.0; exponent -= 1 }\n  while value >= 2.0 { value = value / 2.0; exponent += 1 }\n  let mantissa = value * 4503599627370496.0\n  let high = (mantissa / 4294967296.0).floor().toFloat()\n  let low = mantissa - high * 4294967296.0\n  let highInt = match \"{high}\".replace(\".0\", \"\").toInt() { case Some(n) => n; case None => return Err(OVERFLOW) }\n  let lowInt = match \"{low}\".replace(\".0\", \"\").toInt() { case Some(n) => n; case None => return Err(OVERFLOW) }\n  let significand = bi(highInt) * bi(4294967296) + bi(lowInt)\n  let mut numerator = bi(ticks) * significand\n  if scalar < 0.0 { numerator = -numerator }\n  let shift = exponent - 52\n  if shift >= 0 { roundFraction(numerator * powerTwo(shift), bi(1)) } else { roundFraction(numerator, powerTwo(-shift)) }\n}\nexport function lengthRatio(left: int, right: int) -> Result<float, string> {\n  if right == 0 { return Err(ZERO) }\n  if left == 0 { return Ok(if right < 0 { -0.0 } else { 0.0 }) }\n  let mut n = abs(bi(left))\n  let mut d = abs(bi(right))\n  let mut exponent = 0\n  while n < d { n = n * bi(2); exponent -= 1 }\n  while n >= d * bi(2) { d = d * bi(2); exponent += 1 }\n  let significand = roundFraction(n * powerTwo(52), d)?\n  let mut result = significand.toFloat()\n  let shift = exponent - 52\n  let mut i = 0\n  while i < shift { result = result * 2.0; i += 1 }\n  while i > shift { result = result / 2.0; i -= 1 }\n  Ok(if (left < 0) != (right < 0) { -result } else { result })\n}\nexport function lengthResolve(ticks: int, font: int) -> Result<int, string> {\n  if font <= 0 { return Err(\"Length.resolve font size must be positive\") }\n  roundFraction(bi(ticks) * bi(font), bi(65536))\n}\nexport function fromMilliPoints(value: int) -> Result<int, string> { roundFraction(bi(value) * bi(65536), bi(1000)) }\nexport function toMilliPoints(value: int) -> Result<int, string> { roundFraction(bi(value) * bi(1000), bi(65536)) }\n\nexport record LengthLiteralInput { spelling: string, negative: bool }\nfunction operandOf(node: SyntaxNode) -> Option<SyntaxNode> {\n  for value in node.children { if value.field == \"operand\" { return Some(value) } }\n  None\n}\nfunction operatorOf(node: SyntaxNode) -> string {\n  for value in node.attributes { if value.name == \"operator\" { return value.value } }\n  \"\"\n}\nexport function signedLengthInput(node: SyntaxNode, source: Bytes) -> Option<LengthLiteralInput> {\n  let mut value = node\n  while value.kind == \"expression/parenthesized\" {\n    value = match operandOf(value) {case Some(v)=>v;case None=>return None}\n  }\n  let negative = value.kind == \"expression/unary\" && operatorOf(value) == \"minus\"\n  if negative {\n    value = match operandOf(value) {case Some(v)=>v;case None=>return None}\n    while value.kind == \"expression/parenthesized\" { value = match operandOf(value) {case Some(v)=>v;case None=>return None} }\n  }\n  if value.kind != \"expression/length\" { return None }\n  let spelling = match source.slice(value.lo,value.hi).decodeUtf8() {case Ok(v)=>v;case Err(_)=>return None}\n  Some(LengthLiteralInput {spelling:spelling,negative:negative})\n}\n",
      "sourceSha256": "ae2e8615580c8f7512327e369e6a56575c4ad6ec0adcf30fa0fc577cb8c4a34a"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/literal.tpz",
      "language": "topaz",
      "bytes": 14052,
      "sha256": "e9887081f1a848d6e10434dab87c9efc283ee17302b8dd27764f13a27d2def77",
      "content": "// Source literal grammar and parser-close cooking. Coordinates are UTF-8 bytes.\nimport types { SyntaxNode, PreviewAstAttribute }\n\nfunction byteAt(bytes: Bytes, at: int) -> int { bytes.get(at) ?? -1 }\nfunction slice(bytes: Bytes, lo: int, hi: int) -> string {\n  match bytes.slice(lo, hi).decodeUtf8() { case Ok(text) => text; case Err(_) => \"\" }\n}\nfunction digit(value: int) -> int {\n  if value >= 48 && value <= 57 { value - 48 }\n  else if value >= 65 && value <= 70 { value - 65 + 10 }\n  else if value >= 97 && value <= 102 { value - 97 + 10 }\n  else { -1 }\n}\nexport function validDigitRun(bytes: Bytes, lo: int, hi: int, radix: int) -> bool {\n  if lo == hi { return false }\n  let mut at = lo\n  while at < hi {\n    let b = byteAt(bytes, at)\n    let d = digit(b)\n    if d < 0 || d >= radix {\n      if b != 95 || at == lo || at + 1 == hi { return false }\n      let before = digit(byteAt(bytes, at - 1))\n      let after = digit(byteAt(bytes, at + 1))\n      if before < 0 || before >= radix || after < 0 || after >= radix { return false }\n    }\n    at += 1\n  }\n  true\n}\nexport function integerRadix(spelling: string) -> int {\n  if spelling.startsWith(\"0x\") || spelling.startsWith(\"0X\") { 16 }\n  else if spelling.startsWith(\"0b\") || spelling.startsWith(\"0B\") { 2 }\n  else { 10 }\n}\nexport function validIntegerLiteral(spelling: string) -> bool {\n  let bytes = spelling.encodeUtf8()\n  let radix = integerRadix(spelling)\n  validDigitRun(bytes, if radix == 10 { 0 } else { 2 }, bytes.length(), radix)\n}\nexport function validDecimalLiteral(spelling: string) -> bool {\n  let parts = spelling.split(\".\")\n  if parts.length == 0 || parts.length > 2 { return false }\n  for part in parts {\n    let bytes = part.encodeUtf8()\n    if !validDigitRun(bytes, 0, bytes.length(), 10) { return false }\n  }\n  true\n}\nexport function integerMagnitude(spelling: string) -> Option<BigInt> {\n  if !validIntegerLiteral(spelling) { return None }\n  let bytes = spelling.encodeUtf8()\n  let radix = integerRadix(spelling)\n  let mut at = if radix == 10 { 0 } else { 2 }\n  let mut value = match BigInt.parse(\"0\", 10) { case Some(value) => value; case None => return None }\n  let base = match BigInt.parse(\"{radix}\", 10) { case Some(value) => value; case None => return None }\n  while at < bytes.length() {\n    if byteAt(bytes, at) != 95 {\n      let d = digit(byteAt(bytes, at))\n      let next = match BigInt.parse(\"{d}\", 10) { case Some(value) => value; case None => return None }\n      value = value * base + next\n    }\n    at += 1\n  }\n  Some(value)\n}\nexport function decodeIntegerLiteral(spelling: string, negative: bool) -> Option<int> {\n  let value = match integerMagnitude(spelling) { case Some(value) => value; case None => return None }\n  if negative { (-value).toInt() } else { value.toInt() }\n}\nexport function decodeDurationMilliseconds(spelling: string) -> Option<string> {\n  let bytes = spelling.encodeUtf8()\n  let unitSize = if spelling.endsWith(\"ms\") { 2 } else { 1 }\n  if bytes.length() <= unitSize { return None }\n  let unit = slice(bytes, bytes.length() - unitSize, bytes.length())\n  let magnitude = slice(bytes, 0, bytes.length() - unitSize)\n  if unit != \"ms\" && unit != \"s\" && unit != \"m\" { return None }\n  if integerRadix(magnitude) != 10 || !validIntegerLiteral(magnitude) { return None }\n  let value = match integerMagnitude(magnitude) { case Some(value) => value; case None => return None }\n  let factor = match BigInt.parse(if unit == \"ms\" { \"1\" } else if unit == \"s\" { \"1000\" } else { \"60000\" }, 10) { case Some(value) => value; case None => return None }\n  let maximum = match BigInt.parse(\"18446744073709551615\", 10) { case Some(value) => value; case None => return None }\n  let milliseconds = value * factor\n  if milliseconds > maximum { None } else { Some(milliseconds.toString(10)) }\n}\nexport function decodeDecimalFloatLiteral(spelling: string) -> Option<float> {\n  if !validDecimalLiteral(spelling) || !spelling.contains(\".\") { return None }\n  let canonical = spelling.replace(\"_\", \"\")\n  match canonical.parseFloat() { case Ok(value) => Some(value); case Err(_) => Some(1.0 / 0.0) }\n}\nfunction hexWord(value: int) -> string {\n  let integer = match BigInt.parse(\"{value}\", 10) { case Some(value) => value; case None => return \"\" }\n  let mut text = integer.toString(16)\n  while text.encodeUtf8().length() < 8 { text = \"0{text}\" }\n  text\n}\n// Resolve a positive source float to IEEE bits before IR/backend boundaries.\nexport function floatLiteralBits(spelling: string) -> string {\n  match decodeDecimalFloatLiteral(spelling) { case Some(value) => floatValueBits(value); case None => \"\" }\n}\nfunction floatValueBits(input: float) -> string {\n  if input.isNaN() { return \"7ff8000000000000\" }\n  let negative = input < 0.0 || 1.0 / input == -1.0 / 0.0\n  let sign = if negative { 2147483648 } else { 0 }\n  let mut value = if negative { -input } else { input }\n  if value == 1.0 / 0.0 { return \"{hexWord(sign + 2146435072)}00000000\" }\n  if value == 0.0 { return \"{hexWord(sign)}00000000\" }\n  let mut exponent = 1023\n  while value >= 2.0 { value /= 2.0; exponent += 1 }\n  while value < 1.0 && exponent > 1 { value *= 2.0; exponent -= 1 }\n  let significand = if value < 1.0 { value * 4503599627370496.0 }\n    else { (value - 1.0) * 4503599627370496.0 }\n  if value < 1.0 { exponent = 0 }\n  // Binary64 scaling leaves an exact integer in [0, 2^52); trunc is in range.\n  let mantissa = significand.trunc()\n  let high = sign + exponent * 1048576 + mantissa / 4294967296\n  let low = mantissa % 4294967296\n  \"{hexWord(high)}{hexWord(low)}\"\n}\nfunction escapeValue(bytes: Bytes, at: int, width: int) -> string {\n  match byteAt(bytes, at) {\n    case 110 => \"\\n\"; case 114 => \"\\r\"; case 116 => \"\\t\"\n    case _ => slice(bytes, at, at + width)\n  }\n}\n// Historical IR is decoded at its input boundary, before any backend consumes it.\nexport function normalizeLegacyIrDetail(kind: string, detail: string, languageMode: string) -> Result<string, string> {\n  if kind == \"expression/float\" {\n    if detail == \"\" { return Err(\"invalid legacy float literal\") }\n    for scalar in detail.scalars() {\n      if !\"0123456789._eE+-\".contains(scalar) { return Err(\"invalid legacy float literal\") }\n    }\n    let normalized = detail.replace(\"_\", \"\")\n    match normalized.parseFloat() {\n      case Ok(value) => return Ok(floatValueBits(value))\n      case Err(_) => ()\n    }\n    // Source literal overflow was IEEE infinity in the legacy compiler too.\n    if languageMode == \"topaz-5.21\" && detail.contains(\".\") && validDecimalLiteral(detail) && validDecimalLiteral(normalized) { return Ok(\"7ff0000000000000\") }\n    return Err(\"invalid legacy float literal\")\n  }\n  if kind == \"expression/duration\" {\n    let bytes = detail.encodeUtf8()\n    let end = bytes.length() - (if detail.endsWith(\"ms\") { 2 } else { 1 })\n    if end <= 0 { return Err(\"invalid legacy duration literal\") }\n    let mut at = 0\n    while at < end {\n      let b = byteAt(bytes, at)\n      if b < 48 || b > 57 { return Err(\"invalid legacy duration literal\") }\n      at += 1\n    }\n    return match decodeDurationMilliseconds(detail) { case Some(value) => Ok(value); case None => Err(\"invalid legacy duration literal\") }\n  }\n  if kind != \"expression/string-text\" { return Ok(detail) }\n  let bytes = detail.encodeUtf8()\n  let mut at = 0\n  let mut out: Array<string> = []\n  while at < bytes.length() {\n    let b = byteAt(bytes, at)\n    if b == 92 {\n      at += 1\n      let escaped = byteAt(bytes, at)\n      if escaped != 110 && escaped != 114 && escaped != 116 && escaped != 92 && escaped != 34 && escaped != 123 && escaped != 125 { return Err(\"invalid legacy string escape\") }\n      out.push(escapeValue(bytes, at, 1))\n      at += 1\n    } else {\n      let width = if b < 128 { 1 } else if b < 224 { 2 } else if b < 240 { 3 } else { 4 }\n      out.push(slice(bytes, at, at + width))\n      at += width\n    }\n  }\n  Ok(out.join(\"\"))\n}\nexport record IntegerLiteralInput { spelling: string, negative: bool }\nexport function literalAttribute(node: SyntaxNode, name: string) -> string {\n  for attr in node.attributes {\n    if attr.name == name {\n      return attr.value\n    }\n  }\n  \"\"\n}\nfunction unparen(node: SyntaxNode) -> SyntaxNode {\n  let mut current = node\n  while current.kind == \"expression/parenthesized\" && current.children.length == 1 { current = current.children[0] }\n  current\n}\nexport function signedIntegerInput(node: SyntaxNode, source: Bytes) -> Option<IntegerLiteralInput> {\n  let mut value = unparen(node)\n  let mut negative = false\n  if value.kind == \"expression/unary\" {\n    let op = literalAttribute(value, \"operator\")\n    if op != \"minus\" && op != \"plus\" { return None }\n    negative = op == \"minus\"\n    if value.children.length != 1 { return None }\n    value = unparen(value.children[0])\n  }\n  if value.kind != \"expression/integer\" { return None }\n  Some(IntegerLiteralInput { spelling: slice(source, value.lo, value.hi), negative: negative })\n}\n\nexport record LiteralRange { lo: int, hi: int }\nexport record StringLayout { removed: Array<LiteralRange>, offending: Array<LiteralRange> }\nexport function stringLayout(bytes: Bytes, openingEnd: int, closing: int, lines: Array<int>) -> StringLayout {\n  let mut removed: Array<LiteralRange> = []\n  let mut offending: Array<LiteralRange> = []\n  let openingBreak = if byteAt(bytes, openingEnd) == 13 && byteAt(bytes, openingEnd + 1) == 10 { 2 }\n    else if byteAt(bytes, openingEnd) == 10 { 1 } else { 0 }\n  if openingBreak > 0 { removed.push(LiteralRange { lo: openingEnd, hi: openingEnd + openingBreak }) }\n  let mut closeLine = closing\n  while closeLine > 0 && byteAt(bytes, closeLine - 1) != 10 { closeLine -= 1 }\n  let indent = closing - closeLine\n  let mut at = closeLine\n  while at < closing {\n    let b = byteAt(bytes, at)\n    if b != 32 && b != 9 { return StringLayout { removed: removed, offending: offending } }\n    at += 1\n  }\n  for line in lines {\n    if line >= closeLine || line < openingEnd + openingBreak { continue }\n    let mut end = line\n    while end < closing && byteAt(bytes, end) != 10 { end += 1 }\n    if end > line && byteAt(bytes, end - 1) == 13 { end -= 1 }\n    let mut blank = true\n    at = line\n    while at < end {\n      let b = byteAt(bytes, at)\n      if b != 32 && b != 9 { blank = false }\n      at += 1\n    }\n    if blank { continue }\n    let mut matchesIndent = end - line >= indent\n    at = 0\n    while matchesIndent && at < indent {\n      if byteAt(bytes, line + at) != byteAt(bytes, closeLine + at) { matchesIndent = false }\n      at += 1\n    }\n    if matchesIndent {\n      if indent > 0 { removed.push(LiteralRange { lo: line, hi: line + indent }) }\n    } else { offending.push(LiteralRange { lo: line, hi: end }) }\n  }\n  // Keep removed ranges in source order for the cooking cursor.\n  if indent > 0 { removed.push(LiteralRange { lo: closeLine, hi: closing }) }\n  StringLayout { removed: removed, offending: offending }\n}\nfunction textAttribute(name: string, value: string) -> PreviewAstAttribute {\n  PreviewAstAttribute { name: name, kind: \"string\", value: value }\n}\nexport function cookStringParts(bytes: Bytes, openingEnd: int, closing: int, multiline: bool, parts: Array<SyntaxNode>) -> Array<SyntaxNode> {\n  let mut lines: Array<int> = []\n  if multiline {\n    if byteAt(bytes, openingEnd) != 10 && !(byteAt(bytes, openingEnd) == 13 && byteAt(bytes, openingEnd + 1) == 10) { lines.push(openingEnd) }\n    for part in parts {\n      if part.kind != \"string-part/text\" { continue }\n      let mut at = part.lo\n      while at < part.hi {\n        if byteAt(bytes, at) == 10 { lines.push(at + 1) }\n        at += 1\n      }\n    }\n    ()\n  }\n  let layout = if multiline { stringLayout(bytes, openingEnd, closing, lines) } else { StringLayout { removed: [], offending: [] } }\n  let mut result: Array<SyntaxNode> = []\n  let mut removedIndex = 0\n  for part in parts {\n    if part.kind != \"string-part/text\" { result.push(part); continue }\n    let mut out: Array<string> = []\n    let mut runs: Array<string> = []\n    let mut offset = 0\n    let mut at = part.lo\n    while at < part.hi {\n      let start = at\n      while removedIndex < layout.removed.length && layout.removed[removedIndex].hi <= at { removedIndex += 1 }\n      let nextRemoved = if removedIndex < layout.removed.length { layout.removed[removedIndex].lo } else { part.hi }\n      let removed = if nextRemoved <= at && removedIndex < layout.removed.length { layout.removed[removedIndex].hi.atMost(part.hi) } else { at }\n      if removed > at {\n        runs.push(\"{offset}:{offset}:{at}:{removed}\")\n        at = removed\n        continue\n      }\n      let b = byteAt(bytes, at)\n      let mut value = \"\"\n      if multiline && b == 13 && byteAt(bytes, at + 1) == 10 {\n        value = \"\\n\"; at += 2\n      } else if b == 92 {\n        at += 1\n        if at < part.hi {\n          let escaped = byteAt(bytes, at)\n          let width = if escaped < 128 { 1 } else if escaped < 224 { 2 } else if escaped < 240 { 3 } else { 4 }\n          value = escapeValue(bytes, at, width)\n          at += width\n        }\n      } else {\n        // Copy unchanged UTF-8 once per run. Preserve every scalar's map entry:\n        // consumers also observe zero-width removals and escape boundaries.\n        while at < part.hi && at < nextRemoved {\n          let plain = byteAt(bytes, at)\n          if plain == 92 || (multiline && plain == 13 && byteAt(bytes, at + 1) == 10) { break }\n          let width = if plain < 128 { 1 } else if plain < 224 { 2 } else if plain < 240 { 3 } else { 4 }\n          let end = offset + width\n          runs.push(\"{offset}:{end}:{at}:{at + width}\")\n          offset = end\n          at += width\n        }\n        out.push(slice(bytes, start, at))\n        continue\n      }\n      out.push(value)\n      let end = offset + value.encodeUtf8().length()\n      runs.push(\"{offset}:{end}:{start}:{at}\")\n      offset = end\n    }\n    result.push(SyntaxNode {\n      kind: part.kind, lo: part.lo, hi: part.hi, field: part.field, index: part.index,\n      attributes: [textAttribute(\"cooked\", out.join(\"\")), textAttribute(\"sourceMap\", runs.join(\";\"))], children: part.children,\n    })\n  }\n  result\n}\n",
      "sourceSha256": "e9887081f1a848d6e10434dab87c9efc283ee17302b8dd27764f13a27d2def77"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/lowering.tpz",
      "language": "topaz",
      "bytes": 92278,
      "sha256": "fc49410b19617623c0db6c92532542844fd640824a449861d15b0eb94cd75f25",
      "content": "import std.json as jsonBoundary\nimport query.database { Database, newDatabase }\n\nimport literal { IntegerLiteralInput, decodeIntegerLiteral, floatLiteralBits, decodeDurationMilliseconds }\nimport length { LengthLiteralInput, decodeLength }\nimport stage1_types {\n  LoweringOutput,\n  STAGE1_EXCHANGE_SCHEMA,\n  STAGE1_IR_SCHEMA,\n  Stage1Module,\n  Stage1Operation,\n  Stage1Response,\n  compilerProvenance,\n}\nimport types {\n  LowerBridgeRequest,\n  decodeLowerBridgeRequest,\n  PreviewAstNode,\n  PreviewImportEdge,\n  PreviewCallArgument,\n  PreviewCallEvaluation,\n  PreviewModuleResult,\n  PreviewResolvedDeclaration,\n  PreviewResolvedReference,\n  PreviewTypeAtom,\n  PreviewTypedCall,\n  PreviewTypedCapture,\n  PreviewTypedNode,\n}\n\n// Prepared Lispex rules are runtime handles, so lowering preserves their resolved identity.\nconst LISPEX_RULE_HANDLE_PREFIX = \"topaz.lispex-rule-handle/v1:\"\n\nrecord LowerKindPlan {\n  name: string,\n  tag: string,\n  roleName: string,\n  runtimeLeaf: string,\n}\n\nfunction lowerKind(\n  name: string,\n  tagName: string,\n  roleName: string,\n  runtimeLeaf: string,\n) -> LowerKindPlan {\n  LowerKindPlan {\n    name: name,\n    tag: tagName,\n    roleName: roleName,\n    runtimeLeaf: runtimeLeaf,\n  }\n}\n\nfunction statementKind(name: string, tagName: string) -> LowerKindPlan {\n  lowerKind(name, tagName, \"statement\", \"\")\n}\n\nfunction expressionKind(name: string, tagName: string) -> LowerKindPlan {\n  lowerKind(name, tagName, \"expression\", \"\")\n}\n\nfunction runtimeExpressionKind(\n  name: string,\n  tagName: string,\n  runtimeLeaf: string,\n) -> LowerKindPlan {\n  lowerKind(name, tagName, \"expression\", runtimeLeaf)\n}\n\nfunction patternKind(name: string, tagName: string) -> LowerKindPlan {\n  lowerKind(name, tagName, \"pattern\", \"pattern\")\n}\n\nfunction lowerKindPlan(kind: string) -> LowerKindPlan {\n  match kind {\n    case \"program\" => lowerKind(\"module\", \"module\", \"module-initialization\", \"\")\n    case \"block\" => expressionKind(\"expression/block\", \"block\")\n    case \"string-part/text\" => runtimeExpressionKind(\"expression/string-text\", \"string-text\", \"string\")\n    case \"parameter\" => lowerKind(\"binding/parameter\", \"parameter\", \"binding\", \"\")\n    case \"lambda-parameter\" => lowerKind(\"binding/parameter\", \"parameter\", \"binding\", \"\")\n    case \"function-declaration\" => lowerKind(\"function\", \"function\", \"declaration\", \"\")\n    case \"statement/import\" => statementKind(\"import\", \"import\")\n    case \"statement/export\" => statementKind(\"export\", \"export\")\n    case \"statement/function\" => statementKind(\"function\", \"function\")\n    case \"statement/type-alias\" => statementKind(\"type-alias\", \"type-alias\")\n    case \"statement/enum\" => statementKind(\"enum\", \"enum\")\n    case \"statement/record\" => statementKind(\"record\", \"record\")\n    case \"statement/newtype\" => statementKind(\"newtype\", \"newtype\")\n    case \"statement/impl\" => statementKind(\"implementation\", \"implementation\")\n    case \"statement/protocol\" => statementKind(\"protocol\", \"protocol\")\n    case \"statement/let\" => statementKind(\"let\", \"let\")\n    case \"statement/const\" => statementKind(\"constant\", \"constant\")\n    case \"statement/assign\" => statementKind(\"assignment\", \"assignment\")\n    case \"statement/return\" => statementKind(\"return\", \"return\")\n    case \"statement/defer\" => lowerKind(\"defer\", \"defer\", \"cleanup\", \"\")\n    case \"statement/using\" => statementKind(\"using\", \"using\")\n    case \"statement/while\" => statementKind(\"while\", \"while\")\n    case \"statement/break\" => statementKind(\"break\", \"break\")\n    case \"statement/continue\" => statementKind(\"continue\", \"continue\")\n    case \"statement/expression\" => statementKind(\"expression/block\", \"expression-statement\")\n    case \"expression/integer\" => expressionKind(\"expression/integer\", \"integer\")\n    case \"expression/float\" => expressionKind(\"expression/float\", \"float\")\n    case \"expression/length\" => expressionKind(\"expression/length\", \"length\")\n    case \"expression/duration\" => expressionKind(\"expression/duration\", \"duration\")\n    case \"expression/boolean\" => expressionKind(\"expression/boolean\", \"boolean\")\n    case \"expression/null\" => expressionKind(\"expression/null\", \"null\")\n    case \"expression/unit\" => expressionKind(\"expression/unit\", \"unit\")\n    case \"expression/string\" => runtimeExpressionKind(\"expression/string\", \"string\", \"string\")\n    case \"expression/template\" => runtimeExpressionKind(\"expression/string\", \"string\", \"template\")\n    case \"expression/identifier\" => expressionKind(\"expression/identifier\", \"identifier\")\n    case \"expression/placeholder\" => expressionKind(\"expression/placeholder\", \"placeholder\")\n    case \"expression/parenthesized\" => expressionKind(\"expression/parenthesized\", \"parenthesized\")\n    case \"expression/block\" => expressionKind(\"expression/block\", \"block-expression\")\n    case \"expression/if\" => expressionKind(\"expression/if\", \"if\")\n    case \"expression/match\" => expressionKind(\"expression/match\", \"match\")\n    case \"expression/for\" => expressionKind(\"expression/for\", \"for\")\n    case \"expression/loop\" => expressionKind(\"expression/loop\", \"loop\")\n    case \"expression/concurrent\" => runtimeExpressionKind(\"expression/concurrent\", \"concurrent\", \"concurrent\")\n    case \"expression/call\" => runtimeExpressionKind(\"expression/call\", \"call\", \"call\")\n    case \"expression/member\" => runtimeExpressionKind(\"expression/member\", \"member\", \"member\")\n    case \"expression/index\" => runtimeExpressionKind(\"expression/index\", \"index\", \"collection\")\n    case \"expression/optional-access\" => runtimeExpressionKind(\"expression/optional-member\", \"optional-member\", \"member\")\n    case \"expression/try\" => runtimeExpressionKind(\"expression/result-propagation\", \"result-propagation\", \"result\")\n    case \"expression/unary\" => runtimeExpressionKind(\"expression/unary\", \"unary\", \"unary\")\n    case \"expression/binary\" => runtimeExpressionKind(\"expression/binary\", \"binary\", \"binary\")\n    case \"expression/range\" => runtimeExpressionKind(\"expression/range\", \"range\", \"range\")\n    case \"expression/compose\" => runtimeExpressionKind(\"expression/compose\", \"compose\", \"callable\")\n    case \"expression/pipe\" => runtimeExpressionKind(\"expression/pipeline\", \"pipeline\", \"callable\")\n    case \"expression/lambda\" => runtimeExpressionKind(\"expression/lambda\", \"lambda\", \"callable\")\n    case \"expression/record-literal\" => runtimeExpressionKind(\"expression/record-literal\", \"record-literal\", \"record\")\n    case \"expression/record-update\" => runtimeExpressionKind(\"expression/record-update\", \"record-update\", \"record\")\n    case \"expression/array\" => runtimeExpressionKind(\"expression/array\", \"array\", \"array\")\n    case \"expression/set\" => runtimeExpressionKind(\"expression/set\", \"set\", \"set\")\n    case \"expression/map\" => runtimeExpressionKind(\"expression/map\", \"map\", \"map\")\n    case \"expression/comprehension\" => runtimeExpressionKind(\"expression/comprehension\", \"comprehension\", \"collection\")\n    case \"pattern/or\" => patternKind(\"pattern/alternatives\", \"alternatives\")\n    case \"pattern/binding\" => patternKind(\"pattern/binding\", \"binding\")\n    case \"pattern/wildcard\" => patternKind(\"pattern/wildcard\", \"wildcard\")\n    case \"pattern/literal\" => patternKind(\"pattern/literal\", \"literal\")\n    case \"pattern/range\" => patternKind(\"pattern/range\", \"range\")\n    case \"pattern/typed\" => patternKind(\"pattern/typed-binding\", \"typed-binding\")\n    case \"pattern/constructor\" => patternKind(\"pattern/constructor\", \"constructor\")\n    case \"pattern/list\" => patternKind(\"pattern/list\", \"list\")\n    case \"pattern/record\" => patternKind(\"pattern/record\", \"record\")\n    case \"pattern/nominal-record\" => patternKind(\"pattern/nominal-record\", \"nominal-record\")\n    case _ => lowerKind(\"\", \"\", \"\", \"\")\n  }\n}\n\nfunction admittedRole(\n  plan: LowerKindPlan,\n  sourceKind: string,\n  insideProtocol: bool,\n  parentKind: string,\n) -> string {\n  if insideProtocol && sourceKind != \"statement/protocol\" {\n    return \"\"\n  }\n  if sourceKind == \"function-declaration\" && parentKind != \"impl-method\" {\n    return \"\"\n  }\n  plan.roleName\n}\n\nfunction roleIdentity(roleName: string) -> string {\n  match roleName {\n    case \"module-initialization\" => \"ModuleInitialization\"\n    case \"statement\" => \"Statement\"\n    case \"expression\" => \"Expression\"\n    case \"pattern\" => \"Pattern\"\n    case \"binding\" => \"Binding\"\n    case \"declaration\" => \"Declaration\"\n    case \"cleanup\" => \"Cleanup\"\n    case _ => \"Unknown\"\n  }\n}\n\nfunction operationId(\n  module: string,\n  sourceOrdinal: int,\n  roleName: string,\n  tagName: string,\n  lo: int,\n  hi: int,\n) -> string {\n  \"op:{module}:{sourceOrdinal}:{lo}:{hi}:{roleIdentity(roleName)}:{tagName}\"\n}\n\nfunction sourceText(source: Bytes, lo: int, hi: int) -> string {\n  match source.slice(lo, hi).decodeUtf8() {\n    case Ok(value) => value\n    case Err(_) => \"\"\n  }\n}\n\nfunction attribute(\n  names: Array<string>,\n  values: Array<string>,\n  wanted: string,\n) -> string {\n  let mut index = 0\n  while index < names.length {\n    match names.get(index) {\n      case Some(name) => if name == wanted {\n        return match values.get(index) {\n          case Some(value) => value\n          case None => \"\"\n        }\n      }\n      case None => ()\n    }\n    index += 1\n  }\n  \"\"\n}\n\nfunction childText(\n  nodes: Array<PreviewAstNode>,\n  childIndexes: Map<string, int>,\n  parent: int,\n  field: string,\n  source: Bytes,\n) -> string {\n  match childIndexes.get(\"{parent}:{field}\") {\n    case Some(index) => match nodes.get(index) {\n      case Some(node) => return sourceText(source, node.lo, node.hi)\n      case None => ()\n    }\n    case None => ()\n  }\n  \"\"\n}\n\n\nfunction flatUnparen(nodes:Array<PreviewAstNode>,indexes:Map<string,int>,start:int)->int {\n  let mut i=start\n  while nodes[i].kind == \"expression/parenthesized\" {\n    i=match indexes.get(\"{i}:operand\") {case Some(v)=>v;case None=>return -1}\n  }\n  i\n}\nfunction flatScalarInput(nodes:Array<PreviewAstNode>,indexes:Map<string,int>,start:int,source:Bytes,kind:string)->Option<IntegerLiteralInput> {\n  let mut i=flatUnparen(nodes,indexes,start)\n  if i < 0 {return None}\n  let value=nodes[i]\n  let mut negative=false\n  if value.kind == \"expression/unary\" {\n    let op=attribute(value.attributeNames,value.attributeValues,\"operator\")\n    if op != \"minus\" && !(op == \"plus\" && kind == \"expression/integer\") {return None}\n    negative=op == \"minus\"\n    i=match indexes.get(\"{i}:operand\") {case Some(v)=>flatUnparen(nodes,indexes,v);case None=>return None}\n  }\n  if i < 0 || nodes[i].kind != kind {return None}\n  Some(IntegerLiteralInput {spelling:sourceText(source,nodes[i].lo,nodes[i].hi),negative:negative})\n}\nfunction flatLengthInput(nodes:Array<PreviewAstNode>,indexes:Map<string,int>,start:int,source:Bytes)->Option<LengthLiteralInput> {\n  match flatScalarInput(nodes,indexes,start,source,\"expression/length\") {\n    case Some(input)=>Some(LengthLiteralInput {spelling:input.spelling,negative:input.negative})\n    case None=>None\n  }\n}\nfunction scalarLiteralAncestor(nodes:Array<PreviewAstNode>,indexes:Map<string,int>,start:int,source:Bytes,kind:string)->bool {\n  let mut parent=nodes[start].parent\n  while parent >= 0 {\n    let node=nodes[parent]\n    if node.kind != \"expression/parenthesized\" && node.kind != \"expression/unary\" {return false}\n    match flatScalarInput(nodes,indexes,parent,source,kind) {case Some(_)=>return true;case None=>()}\n    parent=node.parent\n  }\n  false\n}\nfunction foldedScalarAncestor(nodes:Array<PreviewAstNode>,indexes:Map<string,int>,start:int,source:Bytes)->bool {\n  scalarLiteralAncestor(nodes,indexes,start,source,\"expression/length\") || scalarLiteralAncestor(nodes,indexes,start,source,\"expression/integer\")\n}\nfunction lengthDetail(nodes:Array<PreviewAstNode>,indexes:Map<string,int>,start:int,source:Bytes)->string {\n  let input=match flatLengthInput(nodes,indexes,start,source) {case Some(v)=>v;case None=>return \"invalid:Length literal shape\"}\n  match decodeLength(input.spelling,input.negative) {case Ok(value)=>\"{value.unit}:{value.ticks}\";case Err(message)=>\"invalid:{message}\"}\n}\nfunction integerDetail(nodes:Array<PreviewAstNode>,indexes:Map<string,int>,start:int,source:Bytes)->string {\n  let input=match flatScalarInput(nodes,indexes,start,source,\"expression/integer\") {case Some(v)=>v;case None=>return \"invalid:integer literal shape\"}\n  match decodeIntegerLiteral(input.spelling,input.negative) {case Some(value)=>\"{value}\";case None=>\"invalid:integer literal is out of range\"}\n}\nfunction detail(\n  nodes: Array<PreviewAstNode>,\n  childIndexes: Map<string, int>,\n  nodeIndex: int,\n  node: PreviewAstNode,\n  source: Bytes,\n) -> string {\n  match node.kind {\n    case \"expression/integer\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"valueDecimal\",\n    )\n    case \"expression/float\" => floatLiteralBits(sourceText(source, node.lo, node.hi))\n    case \"expression/duration\" => decodeDurationMilliseconds(sourceText(source, node.lo, node.hi)) ?? \"invalid:duration\"\n    case \"expression/boolean\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"value\",\n    )\n    case \"expression/identifier\" => sourceText(source, node.lo, node.hi)\n    case \"string-part/text\" => attribute(node.attributeNames,node.attributeValues,\"cooked\")\n    case \"statement/assign\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"operator\",\n    )\n    case \"expression/string\" => if sourceText(\n      source,\n      node.lo,\n      node.hi,\n    ).startsWith(\"\\\"\\\"\\\"\") {\n      \"multiline\"\n    } else {\n      \"single-line\"\n    }\n    case \"expression/template\" => {\n      let tag = childText(nodes, childIndexes, nodeIndex, \"tag\", source)\n      if sourceText(source, node.lo, node.hi).startsWith(\"{tag}\\\"\\\"\\\"\") {\n        \"{tag}|multiline\"\n      } else {\n        \"{tag}|single-line\"\n      }\n    }\n    case \"parameter\" => childText(nodes, childIndexes, nodeIndex, \"name\", source)\n    case \"lambda-parameter\" => childText(nodes, childIndexes, nodeIndex, \"name\", source)\n    case \"function-declaration\" => childText(nodes, childIndexes, nodeIndex, \"name\", source)\n    case \"statement/impl\" => {\n      let name = childText(nodes, childIndexes, nodeIndex, \"name\", source)\n      let target = childText(nodes, childIndexes, nodeIndex, \"target\", source)\n      if target == \"\" { name } else { \"{name}<{target}>\" }\n    }\n    case \"statement/protocol\" => childText(\n      nodes,\n      childIndexes,\n      nodeIndex,\n      \"name\",\n      source,\n    )\n    case \"expression/member\" => childText(nodes, childIndexes, nodeIndex, \"field\", source)\n    case \"expression/pipe\" => childText(nodes, childIndexes, nodeIndex, \"field\", source)\n    case \"expression/optional-access\" => childText(\n      nodes,\n      childIndexes,\n      nodeIndex,\n      \"field\",\n      source,\n    )\n    case \"pattern/binding\" => sourceText(source, node.lo, node.hi)\n    case \"pattern/typed\" => childText(nodes, childIndexes, nodeIndex, \"name\", source)\n    case \"pattern/constructor\" => childText(nodes, childIndexes, nodeIndex, \"name\", source)\n    case \"pattern/nominal-record\" => childText(nodes, childIndexes, nodeIndex, \"name\", source)\n    case \"expression/range\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"inclusive\",\n    )\n    case \"pattern/range\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"inclusive\",\n    )\n    case \"expression/comprehension\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"collection\",\n    )\n    case \"expression/unary\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"operator\",\n    )\n    case \"expression/binary\" => attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"operator\",\n    )\n    case _ => \"\"\n  }\n}\n\nfunction representationForType(value: string) -> string {\n  match value {\n    case \"int\" => \"i64\"\n    case \"float\" => \"f64\"\n    case \"bool\" => \"bool\"\n    case \"unit\" => \"unit\"\n    case \"Bytes\" => \"bytes-handle\"\n    case \"ByteBuffer\" => \"byte-buffer-handle\"\n    case _ => if value == \"\" { \"\" } else { \"boxed\" }\n  }\n}\n\nfunction spanKey(moduleIndex: int, lo: int, hi: int) -> string {\n  \"{moduleIndex}:{lo}:{hi}\"\n}\n\nfunction projectReferenceIdentity(reference: PreviewResolvedReference) -> string {\n  if reference.targetModule != \"\" && reference.targetName != \"\" {\n    return \"{reference.targetModule}::{reference.targetName}\"\n  }\n  if reference.targetModuleIndex >= 0 &&\n    reference.targetLo >= 0 &&\n    reference.targetHi >= reference.targetLo {\n    return \"source:{reference.targetModuleIndex}:{reference.targetLo}:{reference.targetHi}\"\n  }\n  \"builtin::{reference.name}\"\n}\n\n// References by span. Operations project their reference identity from it,\n// and the type fills and defer captures follow a reference to its declaration.\nfunction indexReferences(\n  values: Array<PreviewResolvedReference>,\n) -> Map<string, PreviewResolvedReference> {\n  let mut references: Map<string, PreviewResolvedReference> = map {}\n  for value in values {\n    references.insert(spanKey(value.moduleIndex, value.lo, value.hi), value)\n  }\n  references\n}\n\n// The reference at a span when it names a declaration in the program.\nfunction referenceTargetAt(\n  references: Map<string, PreviewResolvedReference>,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<PreviewResolvedReference> {\n  match references.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(found) => if found.targetModuleIndex >= 0 { Some(found) } else { None }\n    case None => None\n  }\n}\n\n// Resolver import edges grouped by importing module, each group in edge order.\nfunction indexImportEdges(values: Array<PreviewImportEdge>) -> Map<string, Array<string>> {\n  let mut edges: Map<string, Array<string>> = map {}\n  for value in values {\n    match edges.get(value.from) {\n      case Some(group) => {\n        let mut target = group\n        target.push(value.to)\n      }\n      case None => edges.insert(value.from, [value.to])\n    }\n  }\n  edges\n}\n\nfunction indexModuleIdentities(values: Array<PreviewModuleResult>) -> Map<string, int> {\n  let mut indexes: Map<string, int> = map {}\n  let mut index = 0\n  for value in values {\n    indexes.insert(value.identity, index)\n    index += 1\n  }\n  indexes\n}\n\nfunction indexDeclarationsBySpan(\n  values: Array<PreviewResolvedDeclaration>,\n) -> Map<string, PreviewResolvedDeclaration> {\n  let mut declarations: Map<string, PreviewResolvedDeclaration> = map {}\n  for value in values {\n    declarations.insert(spanKey(value.moduleIndex, value.lo, value.hi), value)\n  }\n  declarations\n}\n\nfunction declarationNameKey(moduleIndex: int, namespace: string, name: string) -> string {\n  \"{moduleIndex}:{namespace}:{name}\"\n}\n\nfunction indexDeclarationsByName(\n  values: Array<PreviewResolvedDeclaration>,\n) -> Map<string, PreviewResolvedDeclaration> {\n  let mut declarations: Map<string, PreviewResolvedDeclaration> = map {}\n  for value in values {\n    declarations.insert(declarationNameKey(value.moduleIndex, value.namespace, value.name), value)\n  }\n  declarations\n}\n\nfunction importEdgesOf(edges: Map<string, Array<string>>, identity: string) -> Array<string> {\n  match edges.get(identity) {\n    case Some(found) => found\n    case None => []\n  }\n}\n\nfunction referenceIdentity(\n  references: Map<string, PreviewResolvedReference>,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> string {\n  match references.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(found) => projectReferenceIdentity(found)\n    case None => \"\"\n  }\n}\n\nfunction mutableBinding(\n  nodes: Array<PreviewAstNode>,\n  node: PreviewAstNode,\n) -> bool {\n  if node.kind != \"pattern/binding\" || node.parent < 0 {\n    return false\n  }\n  match nodes.get(node.parent) {\n    case Some(parent) => parent.kind == \"statement/let\" && attribute(\n        parent.attributeNames,\n        parent.attributeValues,\n        \"mutable\",\n      ) == \"true\"\n    case None => false\n  }\n}\n\nfunction bindingStorage(kind: string) -> string {\n  if kind == \"parameter\" || kind == \"lambda-parameter\" {\n    return \"parameter\"\n  }\n  if kind == \"statement/const\" ||\n    kind == \"statement/function\" ||\n    kind == \"function-declaration\" {\n    return \"module\"\n  }\n  if kind == \"pattern/binding\" || kind == \"pattern/typed\" {\n    return \"local\"\n  }\n  if kind == \"statement/using\" {\n    return \"local\"\n  }\n  \"\"\n}\n\nrecord LowerBindingSource {\n  name: string,\n  lo: int,\n  hi: int,\n}\n\nfunction emptyBindingSource() -> LowerBindingSource {\n  LowerBindingSource {\n    name: \"\",\n    lo: 0,\n    hi: 0,\n  }\n}\n\nfunction bindingSourceAt(\n  nodes: Array<PreviewAstNode>,\n  index: int,\n  source: Bytes,\n) -> LowerBindingSource {\n  match nodes.get(index) {\n    case Some(node) => LowerBindingSource {\n      name: sourceText(source, node.lo, node.hi),\n      lo: node.lo,\n      hi: node.hi,\n    }\n    case None => emptyBindingSource()\n  }\n}\n\nfunction bindingSourceFor(\n  nodes: Array<PreviewAstNode>,\n  childIndexes: Map<string, int>,\n  nodeIndex: int,\n  node: PreviewAstNode,\n  effectiveKind: string,\n  source: Bytes,\n) -> LowerBindingSource {\n  if effectiveKind == \"pattern/binding\" && node.kind == \"identifier\" {\n    return bindingSourceAt(nodes, nodeIndex, source)\n  }\n  if node.kind == \"pattern/binding\" {\n    return LowerBindingSource {\n      name: sourceText(source, node.lo, node.hi),\n      lo: node.lo,\n      hi: node.hi,\n    }\n  }\n  let nameParent = if node.kind == \"pattern/typed\" ||\n    node.kind == \"parameter\" ||\n    node.kind == \"lambda-parameter\" ||\n    node.kind == \"function-declaration\" ||\n    node.kind == \"statement/const\" ||\n    node.kind == \"statement/using\" {\n    nodeIndex\n  } else if node.kind == \"statement/function\" {\n    match childIndexes.get(\"{nodeIndex}:declaration\") {\n      case Some(index) => index\n      case None => return emptyBindingSource()\n    }\n  } else {\n    return emptyBindingSource()\n  }\n  match childIndexes.get(\"{nameParent}:name\") {\n    case Some(index) => bindingSourceAt(nodes, index, source)\n    case None => emptyBindingSource()\n  }\n}\n\nrecord LowerControlPlan {\n  kind: string,\n  ownsTarget: bool,\n}\n\nfunction lowerControl(kind: string, ownsTarget: bool) -> LowerControlPlan {\n  LowerControlPlan {\n    kind: kind,\n    ownsTarget: ownsTarget,\n  }\n}\n\nfunction controlPlan(kind: string) -> LowerControlPlan {\n  match kind {\n    case \"expression/if\" => lowerControl(\"branch\", true)\n    case \"expression/match\" => lowerControl(\"match\", true)\n    case \"expression/for\" => lowerControl(\"loop\", true)\n    case \"expression/loop\" => lowerControl(\"loop\", true)\n    case \"statement/while\" => lowerControl(\"loop\", true)\n    case \"statement/break\" => lowerControl(\"break\", false)\n    case \"statement/continue\" => lowerControl(\"continue\", false)\n    case \"statement/return\" => lowerControl(\"return\", false)\n    case \"statement/defer\" => lowerControl(\"cleanup\", false)\n    case \"expression/try\" => lowerControl(\"propagate\", false)\n    case \"expression/concurrent\" => lowerControl(\"concurrent\", true)\n    case _ => lowerControl(\"\", false)\n  }\n}\n\nfunction loopControlTarget(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> string {\n  if node.kind != \"statement/break\" && node.kind != \"statement/continue\" {\n    return \"\"\n  }\n  let label = childText(\n    context.module.ast,\n    context.state.childIndexes,\n    astIndex,\n    \"label\",\n    context.state.source,\n  )\n  let mut ancestorIndex = node.parent\n  while ancestorIndex >= 0 {\n    match context.module.ast.get(ancestorIndex) {\n      case Some(ancestor) => {\n        let loopKind = ancestor.kind == \"expression/loop\" ||\n          ancestor.kind == \"expression/for\" ||\n          ancestor.kind == \"statement/while\"\n        let target = if label == \"\" {\n          loopKind\n        } else {\n          ancestor.kind == \"expression/loop\" && childText(\n            context.module.ast,\n            context.state.childIndexes,\n            ancestorIndex,\n            \"label\",\n            context.state.source,\n          ) == label\n        }\n        if target {\n          match context.state.operationIndexByAst.get(ancestorIndex) {\n            case Some(operationIndex) => return operationParentId(\n              context,\n              operationIndex,\n            )\n            case None => return \"\"\n          }\n        }\n        ancestorIndex = ancestor.parent\n      }\n      case None => return \"\"\n    }\n  }\n  \"\"\n}\n\nfunction runtimeLeaf(kindLeaf: string, callTarget: string) -> string {\n  if callTarget.startsWith(\"builtin::\") || callTarget.startsWith(\"std.\") ||\n    callTarget.startsWith(LISPEX_RULE_HANDLE_PREFIX) {\n    return callTarget\n  }\n  kindLeaf\n}\n\nrecord LowerCallPlan {\n  targetIdentity: string,\n  calleeKind: string,\n  method: string,\n  methodClass: string,\n  optional: bool,\n  shadowFirst: bool,\n  stageMethod: string,\n  arguments: Array<string>,\n  evaluations: Array<string>,\n}\n\nfunction callArgumentRows(values: Array<PreviewCallArgument>) -> Array<string> {\n  let mut rows: Array<string> = []\n  for argument in values {\n    let sourceIndex = match argument.sourceIndex {\n      case Some(index) => index\n      case None => -1\n    }\n    rows.push(\n      \"{argument.bindingKind}|{argument.bindingName}|{sourceIndex}|{argument.lo}|{argument.hi}\",\n    )\n  }\n  rows\n}\n\nfunction callEvaluationRows(values: Array<PreviewCallEvaluation>) -> Array<string> {\n  let mut rows: Array<string> = []\n  for evaluation in values {\n    rows.push(\"{evaluation.kind}|{evaluation.argumentIndex}\")\n  }\n  rows\n}\n\nfunction projectCall(value: PreviewTypedCall) -> LowerCallPlan {\n  LowerCallPlan {\n    targetIdentity: value.targetIdentity,\n    calleeKind: value.calleeKind,\n    method: value.method,\n    methodClass: value.methodClass,\n    optional: value.optional,\n    shadowFirst: value.shadowFirst,\n    stageMethod: value.stageMethod,\n    arguments: callArgumentRows(value.arguments),\n    evaluations: callEvaluationRows(value.evaluations),\n  }\n}\n\nfunction emptyCallPlan() -> LowerCallPlan {\n  LowerCallPlan {\n    targetIdentity: \"\",\n    calleeKind: \"\",\n    method: \"\",\n    methodClass: \"\",\n    optional: false,\n    shadowFirst: false,\n    stageMethod: \"\",\n    arguments: [],\n    evaluations: [],\n  }\n}\n\nfunction indexCallPlans(values: Array<PreviewTypedCall>) -> Map<string, LowerCallPlan> {\n  let mut plans: Map<string, LowerCallPlan> = map {}\n  for value in values {\n    plans.insert(spanKey(value.moduleIndex, value.lo, value.hi), projectCall(value))\n  }\n  plans\n}\n\nfunction callPlanFor(\n  plans: Map<string, LowerCallPlan>,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> LowerCallPlan {\n  match plans.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(found) => found\n    case None => emptyCallPlan()\n  }\n}\n\nrecord LowerTypePlan {\n  semanticType: string,\n  representation: string,\n  runtimeType: string,\n  atoms: Array<PreviewTypeAtom>,\n}\n\nfunction projectLowerType(value: Array<PreviewTypeAtom>) -> LowerTypePlan {\n  let semanticType = match value.get(0) {\n    case Some(found) => if found.name != \"\" { found.name } else { found.kind }\n    case None => \"\"\n  }\n  let runtimeType = if value.length == 0 {\n    \"\"\n  } else {\n    match jsonBoundary.stringify(value) {\n      case Ok(found) => found\n      case Err(_) => \"\"\n    }\n  }\n  LowerTypePlan {\n    semanticType: semanticType,\n    representation: representationForType(semanticType),\n    runtimeType: runtimeType,\n    atoms: value,\n  }\n}\n\nrecord LowerTypedNodePlan {\n  nodeKind: string,\n  typePlan: LowerTypePlan,\n}\n\nfunction projectTypedNode(value: PreviewTypedNode) -> LowerTypedNodePlan {\n  LowerTypedNodePlan {\n    nodeKind: value.nodeKind,\n    typePlan: projectLowerType(value.typeValue),\n  }\n}\n\nfunction emptyTypedNodePlan() -> LowerTypedNodePlan {\n  LowerTypedNodePlan {\n    nodeKind: \"\",\n    typePlan: projectLowerType([]),\n  }\n}\n\nfunction unitTypeAtom() -> PreviewTypeAtom {\n  PreviewTypeAtom {\n    parent: -1,\n    field: \"root\",\n    index: 0,\n    edgeName: \"\",\n    kind: \"primitive\",\n    name: \"unit\",\n    value: \"\",\n    identity: \"\",\n    origin: \"\",\n  }\n}\n\nfunction contextualLowerTypePlan(\n  kind: string,\n  parentKind: string,\n  observed: LowerTypePlan,\n) -> LowerTypePlan {\n  if kind == \"expression/for\" && parentKind == \"statement/expression\" {\n    return LowerTypePlan {\n      semanticType: \"unit\",\n      representation: representationForType(\"unit\"),\n      runtimeType: observed.runtimeType,\n      atoms: [unitTypeAtom()],\n    }\n  }\n  observed\n}\n\nfunction typedPatternLowerTypePlan(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n  observed: LowerTypePlan,\n) -> LowerTypePlan {\n  if node.kind != \"pattern/typed\" {\n    return observed\n  }\n  let nameIndex = match context.state.childIndexes.get(\"{astIndex}:name\") {\n    case Some(found) => found\n    case None => return observed\n  }\n  let nameNode = match context.module.ast.get(nameIndex) {\n    case Some(found) => found\n    case None => return observed\n  }\n  let binding = typedNodePlanFor(\n    context.input.typedNodePlans,\n    context.moduleIndex,\n    nameNode.lo,\n    nameNode.hi,\n  )\n  if binding.nodeKind != \"binding\" || binding.typePlan.runtimeType == \"\" {\n    return observed\n  }\n  LowerTypePlan {\n    semanticType: binding.typePlan.runtimeType,\n    representation: binding.typePlan.representation,\n    runtimeType: binding.typePlan.runtimeType,\n    atoms: binding.typePlan.atoms,\n  }\n}\n\nfunction unknownTypeAtom() -> PreviewTypeAtom {\n  PreviewTypeAtom {\n    parent: -1,\n    field: \"root\",\n    index: 0,\n    edgeName: \"\",\n    kind: \"unknown\",\n    name: \"\",\n    value: \"\",\n    identity: \"\",\n    origin: \"\",\n  }\n}\n\nrecord LowerDeclarationSite {\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n}\n\n// A reference names its declaration; a selected import is followed to the\n// module-scope declaration it imports, through re-exporting imports too.\nfunction declarationSite(\n  input: LoweringInput,\n  reference: PreviewResolvedReference,\n  namespace: string,\n) -> LowerDeclarationSite {\n  let mut site = LowerDeclarationSite {\n    moduleIndex: reference.targetModuleIndex,\n    lo: reference.targetLo,\n    hi: reference.targetHi,\n  }\n  let mut hops = 0\n  while hops < input.modules.length {\n    let declaration = match input.declarationsBySpan.get(spanKey(site.moduleIndex, site.lo, site.hi)) {\n      case Some(found) => found\n      case None => return site\n    }\n    if declaration.declarationKind != \"selected-import\" {\n      return site\n    }\n    let moduleIndex = match input.moduleIndexes.get(declaration.targetModule) {\n      case Some(found) => found\n      case None => return site\n    }\n    match input.declarationsByName.get(\n      declarationNameKey(moduleIndex, namespace, declaration.targetName),\n    ) {\n      case Some(found) => {\n        site = LowerDeclarationSite { moduleIndex: moduleIndex, lo: found.lo, hi: found.hi }\n      }\n      case None => return site\n    }\n    hops += 1\n  }\n  site\n}\n\n// The checker's binding type of a declaration, else its declaration type.\nfunction declaredTypeEntry(\n  context: ModuleLoweringContext,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<Array<PreviewTypeAtom>> {\n  match context.input.declaredTypes.get(declaredTypeKey(\"binding\", moduleIndex, lo, hi)) {\n    case Some(found) => return Some(found)\n    case None => ()\n  }\n  context.input.declaredTypes.get(declaredTypeKey(\"declaration\", moduleIndex, lo, hi))\n}\n\n// Appends the subtree of `atoms` rooted at `root` to `output`, re-rooted under\n// `parent`. Preorder keeps a subtree contiguous: it ends at the first atom\n// whose parent precedes the root.\nfunction appendTypeAtomSubtree(\n  output: Array<PreviewTypeAtom>,\n  atoms: Array<PreviewTypeAtom>,\n  root: int,\n  parent: int,\n  field: string,\n  index: int,\n  edgeName: string,\n) -> () {\n  let base = output.length\n  let mut target = output\n  let mut position = root\n  let mut scanning = true\n  while scanning {\n    match atoms.get(position) {\n      case Some(atom) => if position == root {\n        target.push(PreviewTypeAtom {\n          ...atom,\n          parent: parent,\n          field: field,\n          index: index,\n          edgeName: edgeName,\n        })\n        position += 1\n      } else if atom.parent < root {\n        scanning = false\n      } else {\n        target.push(PreviewTypeAtom { ...atom, parent: atom.parent - root + base })\n        position += 1\n      }\n      case None => {\n        scanning = false\n      }\n    }\n  }\n}\n\n// A structural record type's field, as its own atom list.\nfunction recordFieldAtoms(\n  atoms: Array<PreviewTypeAtom>,\n  fieldName: string,\n) -> Array<PreviewTypeAtom> {\n  let output: Array<PreviewTypeAtom> = []\n  match atoms.get(0) {\n    case Some(root) => if root.kind != \"record\" {\n      return output\n    }\n    case None => return output\n  }\n  let mut position = 0\n  for atom in atoms {\n    if atom.parent == 0 && atom.field == \"fields\" && atom.edgeName == fieldName {\n      appendTypeAtomSubtree(output, atoms, position, -1, \"root\", 0, \"\")\n      return output\n    }\n    position += 1\n  }\n  output\n}\n\nfunction stringIndex(values: Array<string>, wanted: string) -> int {\n  let mut index = 0\n  for value in values {\n    if value == wanted {\n      return index\n    }\n    index += 1\n  }\n  -1\n}\n\n// A generic record's declared field type with its type parameters replaced by\n// the arguments of the nominal type the pattern matched.\nfunction substituteRecordArguments(\n  declared: Array<PreviewTypeAtom>,\n  typeParameters: Array<string>,\n  nominal: Array<PreviewTypeAtom>,\n) -> Array<PreviewTypeAtom> {\n  if typeParameters.length == 0 {\n    return declared\n  }\n  let mut argumentRoots: Array<int> = []\n  let mut position = 0\n  for atom in nominal {\n    if atom.parent == 0 && atom.field == \"arguments\" {\n      argumentRoots.push(position)\n    }\n    position += 1\n  }\n  let output: Array<PreviewTypeAtom> = []\n  let mut mapped: Array<int> = []\n  for atom in declared {\n    let parent = if atom.parent < 0 {\n      -1\n    } else {\n      match mapped.get(atom.parent) {\n        case Some(found) => found\n        case None => -1\n      }\n    }\n    let parameter = if atom.kind == \"rigid\" {\n      stringIndex(typeParameters, atom.name)\n    } else {\n      -1\n    }\n    mapped.push(output.length)\n    match argumentRoots.get(parameter) {\n      case Some(argumentRoot) => appendTypeAtomSubtree(\n        output,\n        nominal,\n        argumentRoot,\n        parent,\n        atom.field,\n        atom.index,\n        atom.edgeName,\n      )\n      case None => {\n        let mut target = output\n        target.push(PreviewTypeAtom { ...atom, parent: parent })\n      }\n    }\n  }\n  output\n}\n\n// A nominal record's declared field type, found through the pattern head's\n// reference to the record declaration.\nfunction nominalRecordFieldAtoms(\n  context: ModuleLoweringContext,\n  patternIndex: int,\n  nominal: Array<PreviewTypeAtom>,\n  fieldName: string,\n) -> Array<PreviewTypeAtom> {\n  let nameNode = match context.state.childIndexes.get(\"{patternIndex}:name\") {\n    case Some(index) => match context.module.ast.get(index) {\n      case Some(found) => found\n      case None => return []\n    }\n    case None => return []\n  }\n  let reference = match referenceTargetAt(\n    context.input.referencesBySpan,\n    context.moduleIndex,\n    nameNode.lo,\n    nameNode.hi,\n  ) {\n    case Some(found) => found\n    case None => return []\n  }\n  let site = declarationSite(context.input, reference, \"type\")\n  let declaring = match context.input.modules.get(site.moduleIndex) {\n    case Some(found) => found\n    case None => return []\n  }\n  let source = if site.moduleIndex == context.moduleIndex {\n    context.state.source\n  } else {\n    (declaring.source).encodeUtf8()\n  }\n  let mut recordIndex = -1\n  let mut recordHi = -1\n  let mut typeParameters: Array<string> = []\n  let mut fieldIndex = -1\n  let mut fieldMatches = false\n  let mut typeLo = -1\n  let mut typeHi = -1\n  let mut index = 0\n  for node in declaring.ast {\n    if recordIndex < 0 {\n      if node.lo == site.lo && node.hi == site.hi &&\n        node.field == \"name\" && astParentKind(declaring.ast, node.parent) == \"statement/record\" {\n        recordIndex = node.parent\n        match declaring.ast.get(node.parent) {\n          case Some(record) => {\n            recordHi = record.hi\n          }\n          case None => return []\n        }\n      }\n    } else if node.lo > recordHi {\n      break\n    } else if node.parent == recordIndex && node.field == \"typeParameters\" {\n      typeParameters.push(sourceText(source, node.lo, node.hi))\n    } else if node.parent == recordIndex && node.field == \"fields\" {\n      fieldIndex = index\n      fieldMatches = false\n    } else if node.parent == fieldIndex && node.field == \"name\" {\n      fieldMatches = sourceText(source, node.lo, node.hi) == fieldName\n    } else if node.parent == fieldIndex && node.field == \"type\" && fieldMatches {\n      typeLo = node.lo\n      typeHi = node.hi\n      break\n    }\n    index += 1\n  }\n  if typeLo < 0 {\n    return []\n  }\n  let declared = typedNodePlanFor(\n    context.input.typedNodePlans,\n    site.moduleIndex,\n    typeLo,\n    typeHi,\n  )\n  substituteRecordArguments(declared.typePlan.atoms, typeParameters, nominal)\n}\n\n// A shorthand record pattern field binds its name to the field's type, which\n// the checker records only on the enclosing record pattern.\nfunction recordShorthandType(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n) -> Array<PreviewTypeAtom> {\n  let field = match context.module.ast.get(node.parent) {\n    case Some(found) => found\n    case None => return []\n  }\n  let pattern = match context.module.ast.get(field.parent) {\n    case Some(found) => found\n    case None => return []\n  }\n  let fieldName = sourceText(context.state.source, node.lo, node.hi)\n  let patternType = typedNodePlanFor(\n    context.input.typedNodePlans,\n    context.moduleIndex,\n    pattern.lo,\n    pattern.hi,\n  ).typePlan.atoms\n  let rootKind = match patternType.get(0) {\n    case Some(root) => root.kind\n    case None => \"\"\n  }\n  if rootKind == \"record\" {\n    recordFieldAtoms(patternType, fieldName)\n  } else if rootKind == \"nominal-record\" && pattern.kind == \"pattern/nominal-record\" {\n    nominalRecordFieldAtoms(context, field.parent, patternType, fieldName)\n  } else {\n    []\n  }\n}\n\n// A value identifier the checker leaves untyped (a forward reference such as\n// `() => config`) has the type of the binding it names.\nfunction forwardReferenceType(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n) -> Array<PreviewTypeAtom> {\n  match referenceTargetAt(context.input.referencesBySpan, context.moduleIndex, node.lo, node.hi) {\n    case Some(reference) => if reference.namespace == \"value\" {\n      let site = declarationSite(context.input, reference, \"value\")\n      match declaredTypeEntry(context, site.moduleIndex, site.lo, site.hi) {\n        case Some(found) => found\n        case None => []\n      }\n    } else {\n      []\n    }\n    case None => []\n  }\n}\n\n// Fills the full type of an operation the checker left untyped where lowering\n// can name it exactly: a value identifier and a shorthand record pattern field.\n// Only the atoms carry it; `semanticType` and `representation` stay the\n// checker's, because target facts pair every nominal `semanticType` with a\n// checker node at the same span.\nfunction untypedLowerTypePlan(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  recordShorthand: bool,\n  observed: LowerTypePlan,\n) -> LowerTypePlan {\n  if observed.semanticType != \"\" {\n    return observed\n  }\n  let atoms = if node.kind == \"expression/identifier\" {\n    forwardReferenceType(context, node)\n  } else if recordShorthand {\n    recordShorthandType(context, node)\n  } else {\n    return observed\n  }\n  if atoms.length == 0 {\n    return observed\n  }\n  LowerTypePlan { ...observed, atoms: atoms }\n}\n\nfunction indexTypedNodePlans(\n  values: Array<PreviewTypedNode>,\n) -> Map<string, LowerTypedNodePlan> {\n  let mut plans: Map<string, LowerTypedNodePlan> = map {}\n  for value in values {\n    plans.insert(spanKey(value.moduleIndex, value.lo, value.hi), projectTypedNode(value))\n  }\n  plans\n}\n\nfunction declaredTypeKey(nodeKind: string, moduleIndex: int, lo: int, hi: int) -> string {\n  \"{nodeKind}:{moduleIndex}:{lo}:{hi}\"\n}\n\n// Binding and declaration types keyed by checker node kind, because one span\n// can carry both and the span-only plan index keeps whichever came last.\nfunction indexDeclaredTypes(\n  values: Array<PreviewTypedNode>,\n) -> Map<string, Array<PreviewTypeAtom>> {\n  let mut types: Map<string, Array<PreviewTypeAtom>> = map {}\n  for value in values {\n    if value.nodeKind == \"binding\" || value.nodeKind == \"declaration\" {\n      types.insert(\n        declaredTypeKey(value.nodeKind, value.moduleIndex, value.lo, value.hi),\n        value.typeValue,\n      )\n    }\n  }\n  types\n}\n\nfunction typedNodePlanFor(\n  plans: Map<string, LowerTypedNodePlan>,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> LowerTypedNodePlan {\n  match plans.get(spanKey(moduleIndex, lo, hi)) {\n    case Some(found) => found\n    case None => emptyTypedNodePlan()\n  }\n}\n\nfunction hasString(values: Array<string>, wanted: string) -> bool {\n  for value in values {\n    if value == wanted {\n      return true\n    }\n  }\n  false\n}\n\nfunction transparentAstKind(kind: string) -> bool {\n  kind == \"identifier\" ||\n    kind.startsWith(\"type/\") ||\n    kind == \"array-element/spread\" ||\n    kind == \"call-argument/named\" ||\n    kind == \"call-argument/spread\" ||\n    kind == \"comprehension-clause/for\" ||\n    kind == \"comprehension-clause/if\" ||\n    kind == \"concurrent-arm\" ||\n    kind == \"enum-variant\" ||\n    kind == \"field-initializer\" ||\n    kind == \"function-declaration\" ||\n    kind == \"function-type-parameter\" ||\n    kind == \"impl-method\" ||\n    kind == \"import-item\" ||\n    kind == \"import-spec\" ||\n    kind == \"list-pattern/rest\" ||\n    kind == \"map-entry\" ||\n    kind == \"match-case\" ||\n    kind == \"match-case-return\" ||\n    kind == \"module-path\" ||\n    kind == \"record-field-declaration\" ||\n    kind == \"record-pattern-field\" ||\n    kind == \"record-type-field\" ||\n    kind == \"string-part/interpolation\" ||\n    kind == \"template-tag\"\n}\n\nfunction operandLabelSegment(\n  nodes: Array<PreviewAstNode>,\n  childIndexes: Map<string, int>,\n  astIndex: int,\n  node: PreviewAstNode,\n  source: Bytes,\n) -> string {\n  let segment = \"{node.field}:{node.index}\"\n  if !transparentAstKind(node.kind) {\n    return segment\n  }\n  let name = childText(nodes, childIndexes, astIndex, \"name\", source)\n  if name == \"\" {\n    \"{node.kind}[{node.index}]/{segment}\"\n  } else {\n    \"{node.kind}[{node.index}]={name}/{segment}\"\n  }\n}\n\nfunction indexOperandLabel(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> () {\n  let segment = operandLabelSegment(\n    context.module.ast,\n    context.state.childIndexes,\n    astIndex,\n    node,\n    context.state.source,\n  )\n  let label = if node.parent < 0 {\n    segment\n  } else {\n    match context.module.ast.get(node.parent) {\n      case Some(parent) => if transparentAstKind(parent.kind) {\n        match context.state.operandLabelsByAst.get(node.parent) {\n          case Some(prefix) => \"{prefix}/{segment}\"\n          case None => segment\n        }\n      } else {\n        segment\n      }\n      case None => segment\n    }\n  }\n  let mut labels = context.state.operandLabelsByAst\n  labels.push(label)\n  ()\n}\n\nfunction astParentKind(nodes: Array<PreviewAstNode>, parent: int) -> string {\n  if parent < 0 {\n    return \"\"\n  }\n  match nodes.get(parent) {\n    case Some(value) => value.kind\n    case None => \"\"\n  }\n}\n\nfunction namedChildHi(\n  nodes: Array<PreviewAstNode>,\n  childIndexes: Map<string, int>,\n  parent: int,\n  field: string,\n  fallback: int,\n) -> int {\n  match childIndexes.get(\"{parent}:{field}\") {\n    case Some(index) => match nodes.get(index) {\n      case Some(value) => return value.hi\n      case None => ()\n    }\n    case None => ()\n  }\n  fallback\n}\n\nfunction appendAstOperation(\n  operands: Array<string>,\n  operandLabels: Array<string>,\n  operationIndexByAst: Array<int>,\n  operandLabelsByAst: Array<string>,\n  operations: Array<Stage1Operation>,\n  astIndex: int,\n  parentOperationIndex: int,\n) -> () {\n  let operationIndex = match operationIndexByAst.get(astIndex) {\n    case Some(value) => value\n    case None => -1\n  }\n  if operationIndex < 0 || operationIndex == parentOperationIndex {\n    return\n  }\n  match operations.get(operationIndex) {\n    case Some(operation) => if !hasString(operands, operation.id) {\n      let mut target = operands\n      target.push(operation.id)\n      let mut labels = operandLabels\n      labels.push(match operandLabelsByAst.get(astIndex) {\n        case Some(value) => value\n        case None => \"\"\n      })\n    }\n    case None => ()\n  }\n}\n\nfunction rebuildComprehensionOperands(\n  nodes: Array<PreviewAstNode>,\n  childIndexes: Map<string, int>,\n  comprehensionChildIndexes: Map<string, Array<int>>,\n  operationIndexByAst: Array<int>,\n  operandLabelsByAst: Array<string>,\n  operations: Array<Stage1Operation>,\n  comprehensionAstIndex: int,\n) -> () {\n  let parentOperationIndex = match operationIndexByAst.get(\n    comprehensionAstIndex,\n  ) {\n    case Some(value) => value\n    case None => -1\n  }\n  if parentOperationIndex < 0 {\n    return\n  }\n  let parent = match operations.get(parentOperationIndex) {\n    case Some(value) => value\n    case None => return\n  }\n  let mut operands = parent.operands\n  let mut operandLabels = parent.operandLabels\n  match comprehensionChildIndexes.get(\"{comprehensionAstIndex}\") {\n    case Some(children) => for childIndex in children {\n      match nodes.get(childIndex) {\n        case Some(child) => if child.kind == \"comprehension-clause/for\" {\n          for wanted in [\"iterator\", \"pattern\"] {\n            match childIndexes.get(\"{childIndex}:{wanted}\") {\n              case Some(grandchildIndex) => appendAstOperation(\n                  operands,\n                  operandLabels,\n                  operationIndexByAst,\n                  operandLabelsByAst,\n                  operations,\n                  grandchildIndex,\n                  parentOperationIndex,\n                )\n              case None => ()\n            }\n          }\n        } else if child.kind == \"comprehension-clause/if\" {\n          match childIndexes.get(\"{childIndex}:condition\") {\n            case Some(grandchildIndex) => appendAstOperation(\n                operands,\n                operandLabels,\n                operationIndexByAst,\n                operandLabelsByAst,\n                operations,\n                grandchildIndex,\n                parentOperationIndex,\n              )\n            case None => ()\n          }\n        } else {\n          appendAstOperation(\n            operands,\n            operandLabels,\n            operationIndexByAst,\n            operandLabelsByAst,\n            operations,\n            childIndex,\n            parentOperationIndex,\n          )\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction rebuildForOperands(\n  nodes: Array<PreviewAstNode>,\n  childIndexes: Map<string, int>,\n  operationIndexByAst: Array<int>,\n  operandLabelsByAst: Array<string>,\n  operations: Array<Stage1Operation>,\n  forAstIndex: int,\n) -> () {\n  let parentOperationIndex = match operationIndexByAst.get(forAstIndex) {\n    case Some(value) => value\n    case None => -1\n  }\n  if parentOperationIndex < 0 {\n    return\n  }\n  let parent = match operations.get(parentOperationIndex) {\n    case Some(value) => value\n    case None => return\n  }\n  let mut operands = parent.operands\n  let mut operandLabels = parent.operandLabels\n  for wanted in [\"iterator\", \"pattern\", \"body\"] {\n    match childIndexes.get(\"{forAstIndex}:{wanted}\") {\n      case Some(childIndex) => {\n        appendAstOperation(\n          operands,\n          operandLabels,\n          operationIndexByAst,\n          operandLabelsByAst,\n          operations,\n          childIndex,\n          parentOperationIndex,\n        )\n      }\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction emptyResponse(request: LowerBridgeRequest) -> Stage1Response {\n  Stage1Response {\n    schema: STAGE1_EXCHANGE_SCHEMA,\n    status: request.frontEndStatus,\n    frontEnd: request.frontEnd,\n    loweredModules: [],\n    loweredOperations: [],\n    generatedRust: \"\",\n    unsupported: [],\n    provenance: compilerProvenance(\n      request.sourceSetId,\n      request.producer,\n      request.producerStage,\n    ),\n  }\n}\n\nrecord LoweringInput {\n  modules: Array<PreviewModuleResult>,\n  capturesByModule: Array<Array<PreviewTypedCapture>>,\n  references: Array<PreviewResolvedReference>,\n  referencesBySpan: Map<string, PreviewResolvedReference>,\n  importEdges: Map<string, Array<string>>,\n  moduleIndexes: Map<string, int>,\n  declarationsBySpan: Map<string, PreviewResolvedDeclaration>,\n  declarationsByName: Map<string, PreviewResolvedDeclaration>,\n  typedNodePlans: Map<string, LowerTypedNodePlan>,\n  declaredTypes: Map<string, Array<PreviewTypeAtom>>,\n  callPlans: Map<string, LowerCallPlan>,\n}\n\n\nrecord SpecialOperandRebuild {\n  astIndex: int,\n  comprehension: bool,\n}\n\nrecord DeferredOperand {\n  parentIndex: int,\n  operationIndex: int,\n  astIndex: int,\n}\n\nrecord ModuleLoweringState {\n  operationIds: Array<string>,\n  operationIdCounts: Map<string, int>,\n  deferredOperands: Array<DeferredOperand>,\n  functionDefaultOperands: Map<int, Array<DeferredOperand>>,\n  operationIndexByAst: Array<int>,\n  childIndexes: Map<string, int>,\n  comprehensionChildIndexes: Map<string, Array<int>>,\n  closureOperationIndexes: Map<int, Map<int, int>>,\n  protocolScopes: Array<bool>,\n  operandLabelsByAst: Array<string>,\n  specialOperandRebuilds: Array<SpecialOperandRebuild>,\n  captureBoundaryIndexes: Array<int>,\n  namespaceImports: Map<string, LowerBindingSource>,\n  source: Bytes,\n}\n\nrecord ModuleLoweringContext {\n  request: LowerBridgeRequest,\n  input: LoweringInput,\n  output: LoweringOutput,\n  module: PreviewModuleResult,\n  moduleIndex: int,\n  state: ModuleLoweringState,\n}\n\nrecord LowerBindingPlan {\n  name: string,\n  mutable: bool,\n  storage: string,\n  declarationIdentity: string,\n}\n\nfunction emptyBindingPlan() -> LowerBindingPlan {\n  LowerBindingPlan {\n    name: \"\",\n    mutable: false,\n    storage: \"\",\n    declarationIdentity: \"\",\n  }\n}\n\nfunction bindingPlanFor(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n  effectiveKind: string,\n) -> LowerBindingPlan {\n  let source = bindingSourceFor(\n    context.module.ast,\n    context.state.childIndexes,\n    astIndex,\n    node,\n    effectiveKind,\n    context.state.source,\n  )\n  if source.name == \"\" {\n    return emptyBindingPlan()\n  }\n  let resolved = referenceIdentity(\n    context.input.referencesBySpan,\n    context.moduleIndex,\n    source.lo,\n    source.hi,\n  )\n  LowerBindingPlan {\n    name: source.name,\n    mutable: mutableBinding(context.module.ast, node),\n    storage: bindingStorage(effectiveKind),\n    declarationIdentity: if resolved == \"\" {\n      \"source:{context.moduleIndex}:{source.lo}:{source.hi}\"\n    } else {\n      resolved\n    },\n  }\n}\n\nrecord LowerNodePlan {\n  admitted: bool,\n  roleName: string,\n  kindName: string,\n  operationHi: int,\n  parentOperationIndex: int,\n  parentId: string,\n  id: string,\n  typePlan: LowerTypePlan,\n  declaredType: Array<PreviewTypeAtom>,\n  call: LowerCallPlan,\n  binding: LowerBindingPlan,\n  control: LowerControlPlan,\n  controlTarget: string,\n  runtimeLeaf: string,\n}\n\nfunction groupCaptures(\n  moduleCount: int,\n  values: Array<PreviewTypedCapture>,\n) -> Array<Array<PreviewTypedCapture>> {\n  let mut groups: Array<Array<PreviewTypedCapture>> = []\n  let mut moduleIndex = 0\n  while moduleIndex < moduleCount {\n    let group: Array<PreviewTypedCapture> = []\n    groups.push(group)\n    moduleIndex += 1\n  }\n  for value in values {\n    if value.moduleIndex >= 0 && value.moduleIndex < moduleCount {\n      match groups.get(value.moduleIndex) {\n        case Some(group) => {\n          let mut target = group\n          target.push(value)\n        }\n        case None => ()\n      }\n    }\n  }\n  groups\n}\n\nfunction decodeLoweringInput(request: LowerBridgeRequest) -> Result<LoweringInput, string> {\n  let modules = request.modules\n  let references = request.references\n  let typedNodes = request.typedNodes\n  let typedCalls = request.typedCalls\n  Ok(LoweringInput {\n    modules: modules,\n    capturesByModule: groupCaptures(modules.length, request.typedCaptures),\n    references: references,\n    referencesBySpan: indexReferences(references),\n    importEdges: indexImportEdges(request.edges),\n    moduleIndexes: indexModuleIdentities(modules),\n    declarationsBySpan: indexDeclarationsBySpan(request.moduleDeclarations),\n    declarationsByName: indexDeclarationsByName(request.moduleDeclarations),\n    typedNodePlans: indexTypedNodePlans(typedNodes),\n    declaredTypes: indexDeclaredTypes(typedNodes),\n    callPlans: indexCallPlans(typedCalls),\n  })\n}\n\nfunction emptyLoweringOutput() -> LoweringOutput {\n  LoweringOutput {\n    modules: [],\n    operations: [],\n    unsupported: [],\n  }\n}\n\nrecord LowerAstChildIndexes {\n  named: Map<string, int>,\n  comprehension: Map<string, Array<int>>,\n}\n\nfunction indexAstChildren(nodes: Array<PreviewAstNode>) -> LowerAstChildIndexes {\n  let mut indexes: Map<string, int> = map {}\n  let mut comprehension: Map<string, Array<int>> = map {}\n  let mut index = 0\n  for child in nodes {\n    if child.parent >= 0 {\n      let key = \"{child.parent}:{child.field}\"\n      match indexes.get(key) {\n        case Some(_) => ()\n        case None => indexes.insert(key, index)\n      }\n      match nodes.get(child.parent) {\n        case Some(parent) => if parent.kind == \"expression/comprehension\" {\n          let parentKey = \"{child.parent}\"\n          match comprehension.get(parentKey) {\n            case Some(group) => {\n              let mut target = group\n              target.push(index)\n            }\n            case None => comprehension.insert(parentKey, [index])\n          }\n        }\n        case None => ()\n      }\n    }\n    index += 1\n  }\n  LowerAstChildIndexes {\n    named: indexes,\n    comprehension: comprehension,\n  }\n}\n\nfunction moduleLoweringContext(\n  request: LowerBridgeRequest,\n  input: LoweringInput,\n  output: LoweringOutput,\n  module: PreviewModuleResult,\n  moduleIndex: int,\n) -> ModuleLoweringContext {\n  let childIndexes = indexAstChildren(module.ast)\n  ModuleLoweringContext {\n    request: request,\n    input: input,\n    output: output,\n    module: module,\n    moduleIndex: moduleIndex,\n    state: ModuleLoweringState {\n      operationIds: [],\n      operationIdCounts: map {},\n      deferredOperands: [],\n      functionDefaultOperands: map {},\n      operationIndexByAst: [],\n      childIndexes: childIndexes.named,\n      comprehensionChildIndexes: childIndexes.comprehension,\n      closureOperationIndexes: map {},\n      protocolScopes: [],\n      operandLabelsByAst: [],\n      specialOperandRebuilds: [],\n      captureBoundaryIndexes: [],\n      namespaceImports: map {},\n      source: (module.source).encodeUtf8(),\n    },\n  }\n}\n\nfunction operationParentIndex(context: ModuleLoweringContext, parent: int) -> int {\n  if parent < 0 {\n    return -1\n  }\n  match context.state.operationIndexByAst.get(parent) {\n    case Some(value) => value\n    case None => -1\n  }\n}\n\nfunction nodeOperationParentIndex(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n) -> int {\n  if node.field == \"default\" && node.parent >= 0 {\n    match context.module.ast.get(node.parent) {\n      case Some(parent) => if parent.kind == \"parameter\" {\n        return operationParentIndex(context, parent.parent)\n      }\n      case None => ()\n    }\n  }\n  operationParentIndex(context, node.parent)\n}\n\nfunction operationParentId(context: ModuleLoweringContext, index: int) -> string {\n  if index < 0 {\n    return \"\"\n  }\n  match context.output.operations.get(index) {\n    case Some(value) => value.id\n    case None => \"\"\n  }\n}\n\n// Reserve the identity before any parent, operand or capture can refer to it.\n// Also reserve suffixed identities: a capture base can contain its parent's suffix.\nfunction reserveOperationId(context: ModuleLoweringContext, base: string) -> string {\n  let mut counts = context.state.operationIdCounts\n  let mut count = match counts.get(base) {\n    case Some(value) => value + 1\n    case None => 1\n  }\n  let mut id = if count == 1 { base } else { \"{base}#{count}\" }\n  while counts.containsKey(id) {\n    count += 1\n    id = \"{base}#{count}\"\n  }\n  counts.insert(base, count)\n  counts.insert(id, 1)\n  id\n}\n\nfunction planLowerNode(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n  insideProtocol: bool,\n) -> LowerNodePlan {\n  let typedNodePlan = typedNodePlanFor(\n    context.input.typedNodePlans,\n    context.moduleIndex,\n    node.lo,\n    node.hi,\n  )\n  let contextualEnumVariant = node.kind == \"pattern/binding\" &&\n    typedNodePlan.nodeKind == \"pattern\"\n  let recordShorthand = node.kind == \"identifier\" &&\n    node.field == \"name\" && node.parent >= 0 &&\n    astParentKind(context.module.ast, node.parent) == \"record-pattern-field\" &&\n    !context.state.childIndexes.containsKey(\"{node.parent}:pattern\")\n  let bareListRest = node.kind == \"list-pattern/rest\" &&\n    !context.state.childIndexes.containsKey(\"{astIndex}:binding\")\n  let bareCaseReturn = node.kind == \"match-case-return\" &&\n    !context.state.childIndexes.containsKey(\"{astIndex}:value\")\n  let foldedLength=flatLengthInput(context.module.ast,context.state.childIndexes,astIndex,context.state.source)\n  let effectiveKind = if foldedScalarAncestor(context.module.ast,context.state.childIndexes,astIndex,context.state.source) { \"\" }\n  else if foldedLength != None { \"expression/length\" }\n  else if flatScalarInput(context.module.ast,context.state.childIndexes,astIndex,context.state.source,\"expression/integer\") != None { \"expression/integer\" }\n  else if contextualEnumVariant {\n    \"pattern/constructor\"\n  } else if recordShorthand {\n    \"pattern/binding\"\n  } else if bareListRest {\n    \"pattern/wildcard\"\n  } else if bareCaseReturn {\n    \"expression/unit\"\n  } else {\n    node.kind\n  }\n  let parentKind = astParentKind(context.module.ast, node.parent)\n  let kindPlan = lowerKindPlan(effectiveKind)\n  let roleName = admittedRole(kindPlan, node.kind, insideProtocol, parentKind)\n  let parentOperationIndex = nodeOperationParentIndex(context, node)\n  if roleName == \"\" || kindPlan.name == \"\" {\n    return LowerNodePlan {\n      admitted: false,\n      roleName: roleName,\n      kindName: kindPlan.name,\n      operationHi: node.hi,\n      parentOperationIndex: parentOperationIndex,\n      parentId: \"\",\n      id: \"\",\n      typePlan: projectLowerType([]),\n      declaredType: [],\n      call: emptyCallPlan(),\n      binding: emptyBindingPlan(),\n      control: controlPlan(\"\"),\n      controlTarget: \"\",\n      runtimeLeaf: \"\",\n    }\n  }\n  let operationHi = if node.kind == \"function-declaration\" &&\n    parentKind == \"impl-method\" {\n    namedChildHi(context.module.ast, context.state.childIndexes, astIndex, \"name\", node.hi)\n  } else {\n    node.hi\n  }\n  let foundCall = callPlanFor(\n    context.input.callPlans,\n    context.moduleIndex,\n    node.lo,\n    node.hi,\n  )\n  let baseId = operationId(\n    context.module.identity,\n    context.module.sourceOrdinal,\n    roleName,\n    kindPlan.tag,\n    node.lo,\n    operationHi,\n  )\n  let id = reserveOperationId(context, baseId)\n  let control = controlPlan(node.kind)\n  LowerNodePlan {\n    admitted: true,\n    roleName: roleName,\n    kindName: if kindPlan.name == \"binding/parameter\" && attribute(\n      node.attributeNames,\n      node.attributeValues,\n      \"variadic\",\n    ) == \"true\" {\n      \"binding/variadic-parameter\"\n    } else {\n      kindPlan.name\n    },\n    operationHi: operationHi,\n    parentOperationIndex: parentOperationIndex,\n    parentId: operationParentId(context, parentOperationIndex),\n    id: id,\n    typePlan: untypedLowerTypePlan(\n      context,\n      node,\n      recordShorthand,\n      typedPatternLowerTypePlan(\n        context,\n        node,\n        astIndex,\n        contextualLowerTypePlan(\n          effectiveKind,\n          parentKind,\n          if bareCaseReturn { projectLowerType([unitTypeAtom()]) } else { typedNodePlan.typePlan },\n        ),\n      ),\n    ),\n    declaredType: declaredTypeFor(context, node, astIndex),\n    call: foundCall,\n    binding: if contextualEnumVariant {\n      emptyBindingPlan()\n    } else {\n      bindingPlanFor(context, node, astIndex, effectiveKind)\n    },\n    control: control,\n    controlTarget: if control.ownsTarget {\n      id\n    } else {\n      loopControlTarget(context, node, astIndex)\n    },\n    runtimeLeaf: kindPlan.runtimeLeaf,\n  }\n}\n\nfunction operationReferenceIdentity(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> string {\n  let identityIndex = if node.kind == \"pattern/nominal-record\" {\n    match context.state.childIndexes.get(\"{astIndex}:name\") {\n      case Some(index) => index\n      case None => astIndex\n    }\n  } else {\n    astIndex\n  }\n  match context.module.ast.get(identityIndex) {\n    case Some(identityNode) => referenceIdentity(\n      context.input.referencesBySpan,\n      context.moduleIndex,\n      identityNode.lo,\n      identityNode.hi,\n    )\n    case None => \"\"\n  }\n}\n\nfunction operationReferenceDeclarationIdentity(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> string {\n  let identityIndex = if node.kind == \"pattern/nominal-record\" {\n    context.state.childIndexes.get(\"{astIndex}:name\") ?? astIndex\n  } else { astIndex }\n  match context.module.ast.get(identityIndex) {\n    case Some(identityNode) => match context.input.referencesBySpan.get(spanKey(context.moduleIndex,identityNode.lo,identityNode.hi)) {\n      case Some(reference) => if reference.targetModuleIndex >= 0 && reference.targetLo >= 0 && reference.targetHi >= reference.targetLo {\n        \"source:{reference.targetModuleIndex}:{reference.targetLo}:{reference.targetHi}\"\n      } else { \"\" }\n      case None => \"\"\n    }\n    case None => \"\"\n  }\n}\n\nfunction declaredTypeAt(\n  context: ModuleLoweringContext,\n  nodeKind: string,\n  astIndex: int,\n) -> Array<PreviewTypeAtom> {\n  match context.module.ast.get(astIndex) {\n    case Some(found) => match context.input.declaredTypes.get(\n      declaredTypeKey(nodeKind, context.moduleIndex, found.lo, found.hi),\n    ) {\n      case Some(value) => value\n      case None => []\n    }\n    case None => []\n  }\n}\n\nfunction declaredChildType(\n  context: ModuleLoweringContext,\n  parent: int,\n  field: string,\n  nodeKind: string,\n) -> Array<PreviewTypeAtom> {\n  match context.state.childIndexes.get(\"{parent}:{field}\") {\n    case Some(index) => declaredTypeAt(context, nodeKind, index)\n    case None => []\n  }\n}\n\nfunction declaredLetType(\n  context: ModuleLoweringContext,\n  astIndex: int,\n) -> Array<PreviewTypeAtom> {\n  let patternIndex = match context.state.childIndexes.get(\"{astIndex}:pattern\") {\n    case Some(found) => found\n    case None => return []\n  }\n  let pattern = match context.module.ast.get(patternIndex) {\n    case Some(found) => found\n    case None => return []\n  }\n  let annotated = pattern.kind == \"pattern/typed\" ||\n    context.state.childIndexes.containsKey(\"{astIndex}:type\")\n  if !annotated {\n    return []\n  }\n  if pattern.kind != \"pattern/typed\" && pattern.kind != \"pattern/binding\" {\n    return []\n  }\n  if context.state.childIndexes.containsKey(\"{patternIndex}:name\") {\n    declaredChildType(context, patternIndex, \"name\", \"binding\")\n  } else {\n    declaredTypeAt(context, \"binding\", patternIndex)\n  }\n}\n\n// Declared types come from the checker's binding and declaration nodes:\n// parameters, function signatures, and annotated let/const bindings.\nfunction declaredTypeFor(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> Array<PreviewTypeAtom> {\n  match node.kind {\n    case \"parameter\" => declaredChildType(context, astIndex, \"name\", \"binding\")\n    case \"lambda-parameter\" => declaredChildType(context, astIndex, \"name\", \"binding\")\n    case \"function-declaration\" => declaredChildType(\n      context,\n      astIndex,\n      \"name\",\n      \"declaration\",\n    )\n    case \"statement/function\" => match context.state.childIndexes.get(\n      \"{astIndex}:declaration\",\n    ) {\n      case Some(index) => declaredChildType(context, index, \"name\", \"declaration\")\n      case None => []\n    }\n    case \"statement/const\" => if context.state.childIndexes.containsKey(\n      \"{astIndex}:type\",\n    ) {\n      declaredChildType(context, astIndex, \"name\", \"binding\")\n    } else {\n      []\n    }\n    case \"statement/let\" => declaredLetType(context, astIndex)\n    case _ => []\n  }\n}\n\n// Each source-written call type argument is an independent single-root tree.\n// Argument order and nested type edges are preserved.\nfunction callTypeArgumentsFor(context: ModuleLoweringContext, call: PreviewAstNode, callIndex: int) -> Array<Array<PreviewTypeAtom>> {\n  let mut result: Array<Array<PreviewTypeAtom>> = []\n  let mut index = callIndex + 1\n  while index < context.module.ast.length {\n    let node = context.module.ast[index]\n    if node.lo >= call.hi { break }\n    if node.parent == callIndex && node.field == \"typeArguments\" {\n      let plan = typedNodePlanFor(context.input.typedNodePlans, context.moduleIndex, node.lo, node.hi)\n      result.push(plan.typePlan.atoms)\n    }\n    index += 1\n  }\n  result\n}\n\nrecord LowerImportPlan {\n  module: string,\n  bindings: Array<string>,\n}\n\nfunction emptyImportPlan() -> LowerImportPlan {\n  LowerImportPlan {\n    module: \"\",\n    bindings: [],\n  }\n}\n\nfunction importBindingRow(\n  context: ModuleLoweringContext,\n  kind: string,\n  sourceName: string,\n  boundIndex: int,\n) -> string {\n  match context.module.ast.get(boundIndex) {\n    case Some(bound) => {\n      let boundName = sourceText(context.state.source, bound.lo, bound.hi)\n      \"{kind}|{sourceName}|{boundName}|{bound.lo}|{bound.hi}\"\n    }\n    case None => \"\"\n  }\n}\n\n// Namespace import aliases by bound name, for defer captures of `alias.member`.\nfunction recordNamespaceImport(context: ModuleLoweringContext, boundIndex: int) -> () {\n  let bound = bindingSourceAt(context.module.ast, boundIndex, context.state.source)\n  if bound.name != \"\" {\n    let mut imports = context.state.namespaceImports\n    imports.insert(bound.name, bound)\n  }\n}\n\n// The import subtree follows its statement in preorder, so one forward scan\n// collects the module path segments and every bound name.\nfunction importPlanFor(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> LowerImportPlan {\n  if node.kind != \"statement/import\" {\n    return emptyImportPlan()\n  }\n  let itemIndex = match context.state.childIndexes.get(\"{astIndex}:import\") {\n    case Some(found) => found\n    case None => return emptyImportPlan()\n  }\n  let pathIndex = match context.state.childIndexes.get(\"{itemIndex}:path\") {\n    case Some(found) => found\n    case None => return emptyImportPlan()\n  }\n  let mut segments: Array<string> = []\n  let mut bindings: Array<string> = []\n  let mut lastSegment = -1\n  let mut aliasIndex = -1\n  let mut index = astIndex + 1\n  let mut scanning = true\n  while scanning {\n    match context.module.ast.get(index) {\n      case Some(found) => if found.lo < node.lo || found.hi > node.hi {\n        scanning = false\n      } else {\n        if found.parent == pathIndex && found.field == \"segments\" {\n          segments.push(sourceText(context.state.source, found.lo, found.hi))\n          lastSegment = index\n        } else if found.parent == itemIndex && found.field == \"alias\" {\n          aliasIndex = index\n        } else if found.parent == itemIndex && found.field == \"specs\" {\n          let sourceName = childText(\n            context.module.ast,\n            context.state.childIndexes,\n            index,\n            \"name\",\n            context.state.source,\n          )\n          let boundIndex = match context.state.childIndexes.get(\"{index}:alias\") {\n            case Some(alias) => alias\n            case None => match context.state.childIndexes.get(\"{index}:name\") {\n              case Some(name) => name\n              case None => -1\n            }\n          }\n          if boundIndex >= 0 {\n            bindings.push(importBindingRow(context, \"selected-import\", sourceName, boundIndex))\n          }\n        }\n        index += 1\n      }\n      case None => {\n        scanning = false\n      }\n    }\n  }\n  if bindings.length == 0 {\n    let boundIndex = if aliasIndex >= 0 { aliasIndex } else { lastSegment }\n    if boundIndex >= 0 {\n      bindings.push(importBindingRow(context, \"namespace-import\", \"\", boundIndex))\n      recordNamespaceImport(context, boundIndex)\n    }\n  }\n  LowerImportPlan {\n    module: segments.join(\".\"),\n    bindings: bindings,\n  }\n}\n\n// A type declaration's checked signature accompanies its declaration\n// operation. Consumers can instantiate field/payload types without source text.\nfunction appendNominalType(\n  output: Array<PreviewTypeAtom>,\n  atoms: Array<PreviewTypeAtom>,\n  parent: int,\n  field: string,\n  index: int,\n  name: string,\n) -> () {\n  let offset = output.length\n  let mut target = output\n  for atom in atoms {\n    target.push(PreviewTypeAtom {\n      ...atom,\n      parent: if atom.parent < 0 { parent } else { atom.parent + offset },\n      field: if atom.parent < 0 { field } else { atom.field },\n      index: if atom.parent < 0 { index } else { atom.index },\n      edgeName: if atom.parent < 0 { name } else { atom.edgeName },\n    })\n  }\n  ()\n}\n\nfunction typeDefinitionFor(\n  context: ModuleLoweringContext,\n  declaration: PreviewAstNode,\n  declarationIndex: int,\n) -> Array<PreviewTypeAtom> {\n  let kind = match declaration.kind {\n    case \"statement/record\" => \"nominal-record\"\n    case \"statement/enum\" => \"enum\"\n    case \"statement/newtype\" => \"newtype\"\n    case \"statement/type-alias\" => \"alias\"\n    case _ => return []\n  }\n  let name = childText(context.module.ast, context.state.childIndexes,\n    declarationIndex, \"name\", context.state.source)\n  let mut output = [PreviewTypeAtom {\n    parent: -1, field: \"root\", index: 0, edgeName: \"\", kind: kind,\n    name: name, value: \"\", identity: \"{context.module.identity}::{name}\",\n    origin: context.module.identity,\n  }]\n  let mut variantIndex = -1\n  let mut variantAtom = -1\n  let mut fieldIndex = -1\n  let mut fieldName = \"\"\n  let mut fieldOrdinal = 0\n  let mut index = declarationIndex + 1\n  while index < context.module.ast.length {\n    let node = context.module.ast[index]\n    if node.lo >= declaration.hi { break }\n    if node.parent == declarationIndex && node.field == \"typeParameters\" {\n      let parameter = sourceText(context.state.source, node.lo, node.hi)\n      output.push(PreviewTypeAtom {\n        parent: 0, field: \"typeParameters\", index: node.index, edgeName: \"\",\n        kind: \"type-parameter\", name: parameter, value: \"\", identity: \"\", origin: \"\",\n      })\n    } else if node.parent == declarationIndex && node.kind == \"enum-variant\" {\n      variantIndex = index\n      variantAtom = output.length\n      let variantName = childText(context.module.ast, context.state.childIndexes,\n        index, \"name\", context.state.source)\n      output.push(PreviewTypeAtom {\n        parent: 0, field: \"variants\", index: node.index, edgeName: variantName,\n        kind: \"variant\", name: variantName, value: \"\", identity: \"\", origin: \"\",\n      })\n    } else if node.parent == declarationIndex && node.kind == \"record-field-declaration\" {\n      fieldIndex = index\n      fieldOrdinal = node.index\n      fieldName = childText(context.module.ast, context.state.childIndexes,\n        index, \"name\", context.state.source)\n    } else if (node.parent == fieldIndex && node.field == \"type\") ||\n      (node.parent == variantIndex && node.field == \"payload\") ||\n      (node.parent == declarationIndex && (node.field == \"base\" ||\n        (kind == \"alias\" && node.field == \"type\"))) {\n      let plan = typedNodePlanFor(context.input.typedNodePlans,\n        context.moduleIndex, node.lo, node.hi)\n      if node.field == \"payload\" {\n        appendNominalType(output, plan.typePlan.atoms, variantAtom, \"payload\", node.index, \"\")\n      } else if node.field == \"base\" || (kind == \"alias\" && node.field == \"type\") {\n        appendNominalType(output, plan.typePlan.atoms, 0, \"base\", 0, \"\")\n      } else {\n        appendNominalType(output, plan.typePlan.atoms, 0, \"fields\", fieldOrdinal, fieldName)\n      }\n    }\n    index += 1\n  }\n  output\n}\n\nfunction lowerNodeOperation(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n  plan: LowerNodePlan,\n) -> Stage1Operation {\n  let importPlan = importPlanFor(context, node, astIndex)\n  Stage1Operation {\n    schema: STAGE1_IR_SCHEMA,\n    id: plan.id,\n    module: context.module.identity,\n    lo: node.lo,\n    hi: plan.operationHi,\n    parentId: plan.parentId,\n    role: plan.roleName,\n    kind: plan.kindName,\n    literalSourceMap: if node.kind == \"string-part/text\" { attribute(node.attributeNames,node.attributeValues,\"sourceMap\") } else { \"\" },\n    literalEncoding: \"checked-values/v1\",\n    detail: if plan.kindName == \"expression/length\" { lengthDetail(context.module.ast,context.state.childIndexes,astIndex,context.state.source) } else if plan.kindName == \"expression/integer\" { integerDetail(context.module.ast,context.state.childIndexes,astIndex,context.state.source) } else { detail(\n      context.module.ast,\n      context.state.childIndexes,\n      astIndex,\n      node,\n      context.state.source,\n    ) },\n    operands: [],\n    operandLabels: [],\n    semanticType: plan.typePlan.semanticType,\n    representation: plan.typePlan.representation,\n    referenceIdentity: operationReferenceIdentity(context, node, astIndex),\n    referenceDeclarationIdentity: operationReferenceDeclarationIdentity(context,node,astIndex),\n    bindingName: plan.binding.name,\n    bindingMutable: plan.binding.mutable,\n    bindingStorage: plan.binding.storage,\n    declarationIdentity: plan.binding.declarationIdentity,\n    controlKind: plan.control.kind,\n    controlTarget: plan.controlTarget,\n    cleanupIds: if node.kind == \"statement/defer\" { [plan.id] } else { [] },\n    callTarget: plan.call.targetIdentity,\n    callCalleeKind: plan.call.calleeKind,\n    callMethod: plan.call.method,\n    callMethodClass: plan.call.methodClass,\n    callOptional: plan.call.optional,\n    callShadowFirst: plan.call.shadowFirst,\n    callStageMethod: plan.call.stageMethod,\n    callArguments: plan.call.arguments,\n    callEvaluations: plan.call.evaluations,\n    runtimeLeaf: runtimeLeaf(plan.runtimeLeaf, plan.call.targetIdentity),\n    generatedNameSeed: plan.id,\n    semanticTypeAtoms: plan.typePlan.atoms,\n    declaredTypeAtoms: plan.declaredType,\n    callTypeArguments: if node.kind == \"expression/call\" { callTypeArgumentsFor(context, node, astIndex) } else { [] },\n    typeDefinition: typeDefinitionFor(context, node, astIndex),\n    importModule: importPlan.module,\n    importBindings: importPlan.bindings,\n    sourceOrdinal: context.module.sourceOrdinal,\n  }\n}\n\nfunction indexClosureOperation(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  operationIndex: int,\n) -> () {\n  if node.kind == \"expression/lambda\" || node.kind == \"function-declaration\" {\n    let mut indexes = context.state.closureOperationIndexes\n    match indexes.get(node.lo) {\n      case Some(found) => {\n        let mut byEnd = found\n        byEnd.insert(node.hi, operationIndex)\n      }\n      case None => {\n        let mut byEnd: Map<int, int> = map {}\n        byEnd.insert(node.hi, operationIndex)\n        indexes.insert(node.lo, byEnd)\n      }\n    }\n  }\n}\n\nfunction indexSpecialOperandRebuild(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> () {\n  if node.kind == \"expression/comprehension\" || node.kind == \"expression/for\" {\n    let mut rebuilds = context.state.specialOperandRebuilds\n    rebuilds.push(SpecialOperandRebuild {\n      astIndex: astIndex,\n      comprehension: node.kind == \"expression/comprehension\",\n    })\n  }\n}\n\nfunction appendUnadmittedNode(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  parentOperationIndex: int,\n) -> () {\n  let mut indexes = context.state.operationIndexByAst\n  indexes.push(parentOperationIndex)\n  indexClosureOperation(context, node, parentOperationIndex)\n}\n\nfunction appendUnsupportedNode(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  parentOperationIndex: int,\n) -> () {\n  appendUnadmittedNode(context, node, parentOperationIndex)\n  if !transparentAstKind(node.kind) {\n    let marker = \"{context.module.identity}:{node.kind}\"\n    if !hasString(context.output.unsupported, marker) {\n      let mut unsupported = context.output.unsupported\n      unsupported.push(marker)\n    }\n  }\n}\n\nfunction indexProtocolScope(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n) -> bool {\n  let insideProtocol = if node.parent < 0 {\n    false\n  } else {\n    match context.state.protocolScopes.get(node.parent) {\n      case Some(value) => value\n      case None => false\n    }\n  }\n  let mut scopes = context.state.protocolScopes\n  scopes.push(insideProtocol || node.kind == \"statement/protocol\")\n  insideProtocol\n}\n\nfunction appendModuleNode(\n  context: ModuleLoweringContext,\n  node: PreviewAstNode,\n  astIndex: int,\n) -> Result<(), string> {\n  let insideProtocol = indexProtocolScope(context, node)\n  indexOperandLabel(context, node, astIndex)\n  let plan = planLowerNode(context, node, astIndex, insideProtocol)\n  if !plan.admitted {\n    // A signed scalar literal is represented by the enclosing exact value.\n    // Its consumed syntax children share that operation, without a refusal.\n    if insideProtocol || foldedScalarAncestor(\n      context.module.ast, context.state.childIndexes, astIndex, context.state.source,\n    ) {\n      appendUnadmittedNode(context, node, plan.parentOperationIndex)\n    } else {\n      appendUnsupportedNode(context, node, plan.parentOperationIndex)\n    }\n    return Ok(())\n  }\n  if context.output.operations.length >= context.request.maxLoweredNodes {\n    return Err(\"Stage 1 lowering operation count exceeds {context.request.maxLoweredNodes}\")\n  }\n  let mut operations = context.output.operations\n  operations.push(lowerNodeOperation(context, node, astIndex, plan))\n  let mut ids = context.state.operationIds\n  ids.push(plan.id)\n  let operationIndex = operations.length - 1\n  let mut indexes = context.state.operationIndexByAst\n  indexes.push(operationIndex)\n  appendAdmittedOperand(\n    context,\n    operationIndex,\n    plan.parentOperationIndex,\n    astIndex,\n  )\n  indexClosureOperation(context, node, operationIndex)\n  indexSpecialOperandRebuild(context, node, astIndex)\n  if node.kind == \"statement/defer\" || node.kind == \"expression/concurrent\" {\n    let mut boundaries = context.state.captureBoundaryIndexes\n    boundaries.push(operationIndex)\n  }\n  Ok(())\n}\n\nfunction appendModuleNodes(context: ModuleLoweringContext) -> Result<(), string> {\n  let mut astIndex = 0\n  for node in context.module.ast {\n    appendModuleNode(context, node, astIndex)?\n    astIndex += 1\n  }\n  Ok(())\n}\n\nfunction appendOperand(\n  parent: Stage1Operation,\n  operationId: string,\n  label: string,\n) -> () {\n  let mut operands = parent.operands\n  operands.push(operationId)\n  let mut labels = parent.operandLabels\n  labels.push(label)\n}\n\nfunction operandLabelAt(context: ModuleLoweringContext, astIndex: int) -> string {\n  match context.state.operandLabelsByAst.get(astIndex) {\n    case Some(value) => value\n    case None => \"\"\n  }\n}\n\nfunction deferFunctionDefault(\n  context: ModuleLoweringContext,\n  parentIndex: int,\n  operationIndex: int,\n  astIndex: int,\n) -> () {\n  let deferred = DeferredOperand {\n    parentIndex: parentIndex,\n    operationIndex: operationIndex,\n    astIndex: astIndex,\n  }\n  let mut defaults = context.state.functionDefaultOperands\n  match defaults.get(parentIndex) {\n    case Some(group) => {\n      let mut target = group\n      target.push(deferred)\n    }\n    case None => defaults.insert(parentIndex, [deferred])\n  }\n  ()\n}\n\nfunction appendFunctionDefaults(\n  context: ModuleLoweringContext,\n  parent: Stage1Operation,\n  parentIndex: int,\n) -> () {\n  match context.state.functionDefaultOperands.get(parentIndex) {\n    case Some(defaults) => for deferred in defaults {\n      match context.module.ast.get(deferred.astIndex) {\n        case Some(node) => match context.output.operations.get(deferred.operationIndex) {\n          case Some(operation) => appendOperand(\n            parent,\n            operation.id,\n            \"{operandLabelAt(context, node.parent)}/{operandLabelAt(context, deferred.astIndex)}\",\n          )\n          case None => ()\n        }\n        case None => ()\n      }\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction appendAdmittedOperand(\n  context: ModuleLoweringContext,\n  operationIndex: int,\n  parentIndex: int,\n  astIndex: int,\n) -> () {\n  if parentIndex < 0 {\n    return\n  }\n  match context.output.operations.get(operationIndex) {\n    case Some(operation) => match context.output.operations.get(parentIndex) {\n      case Some(parent) => if parent.kind == \"expression/comprehension\" ||\n        parent.kind == \"expression/for\" {\n        ()\n      } else {\n        let field = match context.module.ast.get(astIndex) {\n          case Some(node) => node.field\n          case None => \"\"\n        }\n        if parent.kind == \"function\" && field == \"default\" {\n          deferFunctionDefault(context, parentIndex, operationIndex, astIndex)\n        } else if parent.kind == \"let\" && operation.role == \"pattern\" {\n          let mut deferred = context.state.deferredOperands\n          deferred.push(DeferredOperand {\n            parentIndex: parentIndex,\n            operationIndex: operationIndex,\n            astIndex: astIndex,\n          })\n        } else {\n          if parent.kind == \"function\" && field == \"body\" {\n            appendFunctionDefaults(context, parent, parentIndex)\n          }\n          appendOperand(\n            parent,\n            operation.id,\n            operandLabelAt(context, astIndex),\n          )\n        }\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n}\n\nfunction appendDeferredOperands(context: ModuleLoweringContext) -> () {\n  for deferred in context.state.deferredOperands {\n    match context.output.operations.get(deferred.parentIndex) {\n      case Some(parent) => match context.output.operations.get(deferred.operationIndex) {\n        case Some(operation) => appendOperand(\n          parent,\n          operation.id,\n          operandLabelAt(context, deferred.astIndex),\n        )\n        case None => ()\n      }\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction rebuildSpecialOperands(context: ModuleLoweringContext) -> () {\n  for rebuild in context.state.specialOperandRebuilds {\n    if rebuild.comprehension {\n      rebuildComprehensionOperands(\n        context.module.ast,\n        context.state.childIndexes,\n        context.state.comprehensionChildIndexes,\n        context.state.operationIndexByAst,\n        context.state.operandLabelsByAst,\n        context.output.operations,\n        rebuild.astIndex,\n      )\n    } else {\n      rebuildForOperands(\n        context.module.ast,\n        context.state.childIndexes,\n        context.state.operationIndexByAst,\n        context.state.operandLabelsByAst,\n        context.output.operations,\n        rebuild.astIndex,\n      )\n    }\n  }\n  ()\n}\n\nfunction captureOperation(\n  context: ModuleLoweringContext,\n  capture: PreviewTypedCapture,\n  parentId: string,\n  id: string,\n) -> Stage1Operation {\n  let typePlan = projectLowerType(capture.typeValue)\n  Stage1Operation {\n    schema: STAGE1_IR_SCHEMA,\n    id: id,\n    module: context.module.identity,\n    lo: capture.referenceLo,\n    hi: capture.referenceHi,\n    parentId: parentId,\n    role: \"binding\",\n    kind: \"binding/capture\",\n    detail: \"\",\n    operands: [],\n    operandLabels: [],\n    semanticType: typePlan.semanticType,\n    representation: typePlan.representation,\n    referenceIdentity: \"\",\n    bindingName: capture.name,\n    bindingMutable: false,\n    bindingStorage: \"captured\",\n    declarationIdentity: \"source:{capture.moduleIndex}:{capture.declarationLo}:{capture.declarationHi}\",\n    controlKind: \"\",\n    controlTarget: \"\",\n    cleanupIds: [],\n    callTarget: \"\",\n    callCalleeKind: \"\",\n    callMethod: \"\",\n    callMethodClass: \"\",\n    callOptional: false,\n    callShadowFirst: false,\n    callStageMethod: \"\",\n    callArguments: [],\n    callEvaluations: [],\n    runtimeLeaf: \"\",\n    generatedNameSeed: id,\n    semanticTypeAtoms: typePlan.atoms,\n    declaredTypeAtoms: [],\n    callTypeArguments: [],\n    typeDefinition: [],\n    importModule: \"\",\n    importBindings: [],\n    sourceOrdinal: context.module.sourceOrdinal,\n  }\n}\n\nfunction appendModuleCapture(\n  context: ModuleLoweringContext,\n  capture: PreviewTypedCapture,\n) -> Result<(), string> {\n  let closureIndex = match context.state.closureOperationIndexes.get(capture.closureLo) {\n    case Some(byEnd) => match byEnd.get(capture.closureHi) {\n      case Some(found) => found\n      case None => -1\n    }\n    case None => -1\n  }\n  if closureIndex < 0 {\n    return Err(\"Stage 1 capture `{capture.name}` has no lowered closure parent\")\n  }\n  let parentId = match context.output.operations.get(closureIndex) {\n    case Some(value) => value.id\n    case None => return Err(\"Stage 1 capture parent is out of range\")\n  }\n  let writes = match context.input.referencesBySpan.get(spanKey(\n    context.moduleIndex,\n    capture.referenceLo,\n    capture.referenceHi,\n  )) {\n    case Some(reference) => reference.role == \"write\"\n    case None => false\n  }\n  pushCaptureOperation(context, capture, parentId, writes)\n}\n\nfunction pushCaptureOperation(\n  context: ModuleLoweringContext,\n  capture: PreviewTypedCapture,\n  parentId: string,\n  writes: bool,\n) -> Result<(), string> {\n  if context.output.operations.length >= context.request.maxLoweredNodes {\n    return Err(\"Stage 1 lowering operation count exceeds {context.request.maxLoweredNodes}\")\n  }\n  let captureId = operationId(\n    context.module.identity,\n    context.module.sourceOrdinal,\n    \"binding\",\n    \"capture\",\n    capture.referenceLo,\n    capture.referenceHi,\n  )\n  let id = reserveOperationId(context, \"{captureId}:parent:{parentId}\")\n  let mut operations = context.output.operations\n  operations.push(Stage1Operation {\n    ...captureOperation(context, capture, parentId, id),\n    bindingMutable: writes,\n  })\n  let mut ids = context.state.operationIds\n  ids.push(id)\n  Ok(())\n}\n\nfunction boundaryCapture(\n  context: ModuleLoweringContext,\n  reference: PreviewResolvedReference,\n  cleanup: Stage1Operation,\n  declarationLo: int,\n  declarationHi: int,\n  name: string,\n  atoms: Array<PreviewTypeAtom>,\n) -> PreviewTypedCapture {\n  PreviewTypedCapture {\n    moduleIndex: context.moduleIndex,\n    closureLo: cleanup.lo,\n    closureHi: cleanup.hi,\n    referenceLo: reference.lo,\n    referenceHi: reference.hi,\n    declarationLo: declarationLo,\n    declarationHi: declarationHi,\n    name: name,\n    typeValue: atoms,\n    ambient: false,\n  }\n}\n\n// The checker's closure capture rule applied to a deferred action or a\n// concurrent future: a value reference whose declaration in the module lies\n// outside it, and a namespace member through the module's import alias.\nfunction boundaryCaptureFor(\n  context: ModuleLoweringContext,\n  reference: PreviewResolvedReference,\n  cleanup: Stage1Operation,\n) -> Option<PreviewTypedCapture> {\n  if reference.role == \"namespace-member\" {\n    let alias = match reference.name.split(\".\").get(0) {\n      case Some(found) => found\n      case None => return None\n    }\n    if alias == reference.name {\n      return None\n    }\n    return match context.state.namespaceImports.get(alias) {\n      case Some(bound) => Some(boundaryCapture(\n        context,\n        reference,\n        cleanup,\n        bound.lo,\n        bound.hi,\n        bound.name,\n        [unknownTypeAtom()],\n      ))\n      case None => None\n    }\n  }\n  if reference.targetModuleIndex != reference.moduleIndex {\n    return None\n  }\n  if reference.targetLo >= cleanup.lo && reference.targetHi <= cleanup.hi {\n    return None\n  }\n  let atoms = match declaredTypeEntry(\n    context,\n    reference.targetModuleIndex,\n    reference.targetLo,\n    reference.targetHi,\n  ) {\n    case Some(found) => found\n    case None => {\n      let observed = typedNodePlanFor(\n        context.input.typedNodePlans,\n        context.moduleIndex,\n        reference.lo,\n        reference.hi,\n      )\n      if observed.nodeKind != \"expression\" {\n        return None\n      }\n      observed.typePlan.atoms\n    }\n  }\n  Some(boundaryCapture(\n    context,\n    reference,\n    cleanup,\n    reference.targetLo,\n    reference.targetHi,\n    reference.name,\n    atoms,\n  ))\n}\n\n// Deferred actions and concurrent arms carry their lexical environment;\n// each reference retains the declaration identity and its write effect.\nfunction appendBoundaryCaptures(context: ModuleLoweringContext) -> Result<(), string> {\n  if context.state.captureBoundaryIndexes.length == 0 {\n    return Ok(())\n  }\n  let mut references: Array<PreviewResolvedReference> = []\n  for reference in context.input.references {\n    if reference.moduleIndex == context.moduleIndex && reference.namespace == \"value\" {\n      references.push(reference)\n    }\n  }\n  references.sortBy((reference) => reference.hi)\n  references.sortBy((reference) => reference.lo)\n  for operationIndex in context.state.captureBoundaryIndexes {\n    let cleanup = match context.output.operations.get(operationIndex) {\n      case Some(found) => found\n      case None => return Err(\"Stage 1 capture boundary is out of range\")\n    }\n    for reference in references {\n      if reference.lo >= cleanup.lo && reference.hi <= cleanup.hi {\n        match boundaryCaptureFor(context, reference, cleanup) {\n          case Some(capture) => pushCaptureOperation(\n            context,\n            capture,\n            cleanup.id,\n            reference.role == \"write\",\n          )?\n          case None => ()\n        }\n      }\n    }\n  }\n  Ok(())\n}\n\nfunction appendModuleCaptures(context: ModuleLoweringContext) -> Result<(), string> {\n  match context.input.capturesByModule.get(context.moduleIndex) {\n    case Some(captures) => for capture in captures {\n      appendModuleCapture(context, capture)?\n    }\n    case None => ()\n  }\n  Ok(())\n}\n\nfunction lowerModule(context: ModuleLoweringContext) -> Result<Stage1Module, string> {\n  appendModuleNodes(context)?\n  appendDeferredOperands(context)\n  rebuildSpecialOperands(context)\n  appendModuleCaptures(context)?\n  appendBoundaryCaptures(context)?\n  Ok(Stage1Module {\n    schema: STAGE1_IR_SCHEMA,\n    identity: context.module.identity,\n    path: context.module.path,\n    sourceOrdinal: context.module.sourceOrdinal,\n    initializationOrdinal: context.moduleIndex,\n    entry: context.module.entry,\n    extern: context.module.extern,\n    operationIds: context.state.operationIds,\n    generatedStd: context.module.generatedStd,\n    languageMode: context.request.languageMode,\n    importEdges: importEdgesOf(context.input.importEdges, context.module.identity),\n  })\n}\n\nfunction lowerModules(\n  request: LowerBridgeRequest,\n  input: LoweringInput,\n) -> Result<LoweringOutput, string> {\n  let output = emptyLoweringOutput()\n  let mut moduleIndex = 0\n  let mut modules = output.modules\n  for module in input.modules {\n    let context = moduleLoweringContext(request, input, output, module, moduleIndex)\n    modules.push(lowerModule(context)?)\n    moduleIndex += 1\n  }\n  Ok(output)\n}\n\nfunction loweredResponse(\n  request: LowerBridgeRequest,\n  output: LoweringOutput,\n) -> Stage1Response {\n  Stage1Response {\n    schema: STAGE1_EXCHANGE_SCHEMA,\n    status: if output.unsupported.length > 0 { \"unsupported\" } else { \"completed\" },\n    frontEnd: request.frontEnd,\n    loweredModules: output.modules,\n    loweredOperations: output.operations,\n    generatedRust: \"\",\n    unsupported: output.unsupported,\n    provenance: compilerProvenance(\n      request.sourceSetId,\n      request.producer,\n      request.producerStage,\n    ),\n  }\n}\n\nexport function lowerStep(requestBytes: Bytes) -> Result<Bytes, string> {\n  let request = decodeLowerBridgeRequest(requestBytes.decodeUtf8()?)?\n  let response = if request.frontEndStatus != \"completed\" {\n    emptyResponse(request)\n  } else {\n    loweredResponse(request, lowerValue(request)?)\n  }\n  Ok((jsonBoundary.stringify(response)?).encodeUtf8())\n}\n\n// Typed handoff used by the Rust emitter; the legacy byte adapter stays outside.\nexport function lowerValue(request: LowerBridgeRequest) -> Result<LoweringOutput, string> {\n  lowerModules(request, decodeLoweringInput(request)?)\n}\n\nexport record LoweredDatabase { output: LoweringOutput, db: Database }\n\nexport function lowerDatabase(request: LowerBridgeRequest) -> Result<LoweredDatabase, string> {\n  let output = lowerValue(request)?\n  Ok(LoweredDatabase { output: output, db: newDatabase(output) })\n}\n",
      "sourceSha256": "fc49410b19617623c0db6c92532542844fd640824a449861d15b0eb94cd75f25"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/parser.tpz",
      "language": "topaz",
      "bytes": 2780,
      "sha256": "948cd9458ba95d13fe967109a2b4f0a1836e2e9ccf625b20674568a13d0ef491",
      "content": "// Parse facade over the self compiler's token and grammar leaves.\n// Flattening stays here because it shapes the public preview tree, while parser\n// state, recovery, and grammar families remain below parser/.\n\nimport types { ParseResult, PreviewAstNode, PreviewToken, SyntaxNode }\nimport parser.core { Parser, ParserRequest, ParserService }\nimport parser.declarations_modules { parseBlock, parseProgram }\nimport parser.expressions { parseExpressionBp }\n\nfunction dispatchParserService(\n  parser: Parser,\n  request: ParserRequest,\n) -> Result<SyntaxNode, string> {\n  if request.kind == \"parse-block\" {\n    return parseBlock(\n      dispatchParserService,\n      parser,\n      request.field,\n      request.index,\n    )\n  }\n  parseExpressionBp(\n    dispatchParserService,\n    parser,\n    request.precedence,\n    request.field,\n    request.index,\n  )\n}\n\nfunction parserService() -> ParserService {\n  dispatchParserService\n}\n\nfunction flatten(\n  value: SyntaxNode,\n  parent: int,\n  depth: int,\n  maxNodes: int,\n  maxDepth: int,\n  output: Array<PreviewAstNode>,\n) -> Result<int, string> {\n  if depth > maxDepth {\n    return Err(\"front-end preview AST depth exceeds {maxDepth}\")\n  }\n  if output.length >= maxNodes {\n    return Err(\"front-end preview AST node count exceeds {maxNodes}\")\n  }\n  let mut rows = output\n  let ordinal = output.length\n  let mut attributeNames: Array<string> = []\n  let mut attributeKinds: Array<string> = []\n  let mut attributeValues: Array<string> = []\n  for attribute in value.attributes {\n    attributeNames.push(attribute.name)\n    attributeKinds.push(attribute.kind)\n    attributeValues.push(attribute.value)\n  }\n  rows.push(PreviewAstNode {\n    kind: value.kind,\n    lo: value.lo,\n    hi: value.hi,\n    parent: parent,\n    field: value.field,\n    index: value.index,\n    attributeNames: attributeNames,\n    attributeKinds: attributeKinds,\n    attributeValues: attributeValues,\n  })\n  for child in value.children {\n    flatten(child, ordinal, depth + 1, maxNodes, maxDepth, output)?\n  }\n  Ok(ordinal)\n}\n\n// Parses a normalized token stream into the bounded preview AST.\nexport function parse(\n  tokens: Array<PreviewToken>,\n  source: string,\n  maxNodes: int,\n  maxDepth: int,\n  languageMode: string = \"topaz-5.20\",\n) -> Result<ParseResult, string> {\n  let bytes = (source).encodeUtf8()\n  let parser = Parser {\n    languageMode: languageMode,\n    source: bytes,\n    tokens: tokens,\n    position: [0],\n    lastHi: [0],\n    pendingGt: [],\n    nakedLambda: [true],\n    recordUpdate: [true],\n    diagnostics: [],\n  }\n  let root = parseProgram(parserService(), parser, bytes.length())\n  let mut nodes: Array<PreviewAstNode> = []\n  flatten(root, -1, 0, maxNodes, maxDepth, nodes)?\n  Ok(ParseResult { root: root, nodes: nodes, diagnostics: parser.diagnostics })\n}\n",
      "sourceSha256": "948cd9458ba95d13fe967109a2b4f0a1836e2e9ccf625b20674568a13d0ef491"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/parser/core.tpz",
      "language": "topaz",
      "bytes": 11833,
      "sha256": "83426c4e5670527cd4d0b1600159b34b6dd0991887080a164bb5e793059769d6",
      "content": "import literal { cookStringParts, validIntegerLiteral, validDecimalLiteral }\n// Parser cursor, diagnostics, node construction, and recovery primitives.\n// Grammar leaves share this state and these token helpers; no grammar family is\n// selected or dispatched from the core itself.\n\nimport types {\n  PreviewAstAttribute,\n  PreviewDiagnostic,\n  PreviewToken,\n  SyntaxNode,\n}\n\nexport record ParserRequest {\n  kind: string,\n  precedence: int,\n  field: string,\n  index: int,\n}\n\n// Position, synthetic-token, and diagnostic state shared across recursive grammar services.\nexport record Parser {\n  languageMode: string,\n  source: Bytes,\n  tokens: Array<PreviewToken>,\n  position: Array<int>,\n  lastHi: Array<int>,\n  pendingGt: Array<int>,\n  nakedLambda: Array<bool>,\n  recordUpdate: Array<bool>,\n  diagnostics: Array<PreviewDiagnostic>,\n}\n\nexport type ParserService = (Parser, ParserRequest) -> Result<SyntaxNode, string>\n\nexport function invokeParseBlock(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  service(parser, ParserRequest {\n    kind: \"parse-block\",\n    precedence: 0,\n    field: field,\n    index: index,\n  })\n}\n\nexport function invokeParseExpressionBp(\n  service: ParserService,\n  parser: Parser,\n  precedence: int,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  service(parser, ParserRequest {\n    kind: \"parse-expression-bp\",\n    precedence: precedence,\n    field: field,\n    index: index,\n  })\n}\n\nexport function boxValue(values: Array<int>) -> int {\n  values[0]\n}\n\nexport function setBox(values: Array<int>, value: int) -> () {\n  let mut target = values\n  target[0] = value\n  ()\n}\n\nexport function lambdaAllowed(parser: Parser) -> bool {\n  parser.nakedLambda[0]\n}\n\nexport function setLambdaAllowed(parser: Parser, value: bool) -> () {\n  let mut target = parser.nakedLambda\n  target[0] = value\n  ()\n}\n\nexport function recordUpdateAllowed(parser: Parser) -> bool {\n  parser.recordUpdate[0]\n}\n\nexport function setRecordUpdateAllowed(parser: Parser, value: bool) -> () {\n  let mut target = parser.recordUpdate\n  target[0] = value\n  ()\n}\n\nexport function layoutTokenAt(parser: Parser, position: int) -> PreviewToken {\n  match parser.tokens.get(position) {\n    case Some(value) => value\n    case None => parser.tokens[parser.tokens.length - 1]\n  }\n}\n\nexport function tokenAt(parser: Parser, offset: int) -> PreviewToken {\n  if parser.pendingGt.length > 0 {\n    if offset == 0 {\n      let hi = boxValue(parser.pendingGt)\n      return PreviewToken {\n        kind: \"gt\",\n        lo: hi - 1,\n        hi: hi,\n        stream: \"layout\",\n        synthetic: true,\n      }\n    }\n    let position = boxValue(parser.position) + offset - 1\n    return layoutTokenAt(parser, position)\n  }\n  let position = boxValue(parser.position) + offset\n  layoutTokenAt(parser, position)\n}\n\nexport function current(parser: Parser) -> PreviewToken {\n  tokenAt(parser, 0)\n}\n\nexport function at(parser: Parser, kind: string) -> bool {\n  current(parser).kind == kind\n}\n\nexport function bump(parser: Parser) -> PreviewToken {\n  let value = current(parser)\n  if parser.pendingGt.length > 0 {\n    let mut pending = parser.pendingGt\n    pending.pop()\n    setBox(parser.lastHi, value.hi)\n    return value\n  }\n  if value.kind != \"eof\" {\n    setBox(parser.position, boxValue(parser.position) + 1)\n  }\n  setBox(parser.lastHi, value.hi)\n  value\n}\n\nexport function eat(parser: Parser, kind: string) -> bool {\n  if at(parser, kind) {\n    bump(parser)\n    true\n  } else {\n    false\n  }\n}\n\nexport function text(parser: Parser, lo: int, hi: int) -> string {\n  match parser.source.slice(lo, hi).decodeUtf8() {\n    case Ok(value) => value\n    case Err(_) => \"\"\n  }\n}\n\nexport function diagnostic(code: string, message: string, lo: int, hi: int) -> PreviewDiagnostic {\n  PreviewDiagnostic { code: code, message: message, lo: lo, hi: hi, notes: [] }\n}\n\nexport function addDiagnostic(\n  parser: Parser,\n  code: string,\n  message: string,\n  lo: int,\n  hi: int,\n) -> () {\n  let mut diagnostics = parser.diagnostics\n  diagnostics.push(diagnostic(code, message, lo, hi))\n  ()\n}\n\nexport function rejectReservedBinding(parser: Parser, name: PreviewToken) -> () {\n  if text(parser, name.lo, name.hi) == \"None\" {\n    addDiagnostic(\n      parser,\n      \"TPZ2012\",\n      \"`None` is the Option constructor (§22.1) and cannot be a binding name\",\n      name.lo,\n      name.hi,\n    )\n  }\n  ()\n}\n\nexport function fail(parser: Parser, message: string) -> Result<int, string> {\n  let token = current(parser)\n  let mut diagnostics = parser.diagnostics\n  diagnostics.push(diagnostic(\"TPZ2001\", message, token.lo, token.hi))\n  Err(message)\n}\n\nexport function expect(\n  parser: Parser,\n  kind: string,\n  description: string,\n) -> Result<PreviewToken, string> {\n  if at(parser, kind) {\n    return Ok(bump(parser))\n  }\n  fail(parser, \"expected {description}\")?\n  Err(\"expected {description}\")\n}\n\nexport function expectLeftBrace(parser: Parser) -> Result<PreviewToken, string> {\n  expect(parser, \"left-brace\", \"`\\{`\")\n}\n\nexport function expectRightBrace(parser: Parser) -> Result<PreviewToken, string> {\n  expect(parser, \"right-brace\", \"`\\}`\")\n}\n\nexport function identifier(parser: Parser, description: string) -> Result<PreviewToken, string> {\n  if at(parser, \"identifier\") {\n    return Ok(bump(parser))\n  }\n  fail(parser, \"expected {description}\")?\n  Err(\"expected {description}\")\n}\n\nexport function isFieldNameKind(kind: string) -> bool {\n  kind == \"identifier\" || kind.startsWith(\"keyword/\")\n}\n\nexport function fieldName(parser: Parser, description: string) -> Result<PreviewToken, string> {\n  if isFieldNameKind(current(parser).kind) {\n    return Ok(bump(parser))\n  }\n  fail(parser, \"expected {description}\")?\n  Err(\"expected {description}\")\n}\n\nexport function matchingParenFollowedBy(parser: Parser, expected: string) -> bool {\n  let mut depth = 0\n  let mut offset = 0\n  while true {\n    let kind = tokenAt(parser, offset).kind\n    if kind == \"eof\" {\n      return false\n    }\n    if kind == \"left-paren\" || kind == \"left-bracket\" || kind == \"left-brace\" {\n      depth += 1\n    } else if kind == \"right-paren\" ||\n      kind == \"right-bracket\" ||\n      kind == \"right-brace\" {\n      depth -= 1\n      if depth == 0 {\n        return tokenAt(parser, offset + 1).kind == expected\n      }\n    }\n    offset += 1\n  }\n  false\n}\n\nexport function stringAttribute(name: string, value: string) -> PreviewAstAttribute {\n  PreviewAstAttribute { name: name, kind: \"string\", value: value }\n}\n\nexport function boolAttribute(name: string, value: bool) -> PreviewAstAttribute {\n  PreviewAstAttribute {\n    name: name,\n    kind: \"bool\",\n    value: if value { \"true\" } else { \"false\" },\n  }\n}\n\nexport function node(\n  kind: string,\n  lo: int,\n  hi: int,\n  field: string,\n  index: int,\n  attributes: Array<PreviewAstAttribute>,\n  children: Array<SyntaxNode>,\n) -> SyntaxNode {\n  SyntaxNode {\n    kind: kind,\n    lo: lo,\n    hi: hi,\n    field: field,\n    index: index,\n    attributes: attributes,\n    children: children,\n  }\n}\n\nexport function attach(value: SyntaxNode, field: string, index: int) -> SyntaxNode {\n  node(\n    value.kind,\n    value.lo,\n    value.hi,\n    field,\n    index,\n    value.attributes,\n    value.children,\n  )\n}\n\nexport function identNode(value: PreviewToken, field: string, index: int) -> SyntaxNode {\n  node(\"identifier\", value.lo, value.hi, field, index, [], [])\n}\n\nfunction parseNestedExpression(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let previousLambda = lambdaAllowed(parser)\n  let previousRecordUpdate = recordUpdateAllowed(parser)\n  setLambdaAllowed(parser, true)\n  setRecordUpdateAllowed(parser, true)\n  let result = invokeParseExpressionBp(service, parser, 1, field, index)\n  setRecordUpdateAllowed(parser, previousRecordUpdate)\n  setLambdaAllowed(parser, previousLambda)\n  result\n}\n\nexport function validateNumericLiteral(parser: Parser, token: PreviewToken) -> Result<(), string> {\n  let spelling = text(parser, token.lo, token.hi)\n  if parser.languageMode != \"topaz-5.21\" && (spelling.contains(\"_\") || spelling.startsWith(\"0x\") || spelling.startsWith(\"0X\") || spelling.startsWith(\"0b\") || spelling.startsWith(\"0B\")) {\n    fail(parser, \"numeric separators and radix literals require language mode 5.21\")?\n  }\n  let valid = if token.kind == \"float\" { validDecimalLiteral(spelling) } else { validIntegerLiteral(spelling) }\n  if !valid { fail(parser, \"malformed numeric literal\")? }\n  Ok(())\n}\n\nexport function parseString(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let start = bump(parser)\n  let tagged = start.kind.contains(\"tagged=true\")\n  let multiline = start.kind.contains(\"multiline=true\")\n  let delimiterLength = if multiline { 3 } else { 1 }\n  let mut children: Array<SyntaxNode> = []\n  if tagged {\n    let tagHi = start.hi - delimiterLength\n    let tag = text(parser, start.lo, tagHi)\n    if tag != \"p\" && tag != \"r\" && tag != \"sh\" && tag != \"sql\" {\n      let mut diagnostics = parser.diagnostics\n      diagnostics.push(diagnostic(\n        \"TPZ2002\",\n        \"unknown template tag `{tag}`; the registry is `p`, `r`, `sh`, `sql`\",\n        start.lo,\n        tagHi,\n      ))\n    }\n    children.push(node(\"template-tag\", start.lo, tagHi, \"tag\", 0, [], []))\n  }\n  let mut partIndex = 0\n  while !at(parser, \"string-end\") && !at(parser, \"eof\") {\n    if at(parser, \"string-text\") {\n      let part = bump(parser)\n      children.push(node(\n        \"string-part/text\",\n        part.lo,\n        part.hi,\n        \"parts\",\n        partIndex,\n        [],\n        [],\n      ))\n      partIndex += 1\n      continue\n    }\n    if eat(parser, \"interpolation-start\") {\n      if at(parser, \"interpolation-end\") {\n        addDiagnostic(\n          parser,\n          \"TPZ2001\",\n          \"expected an expression\",\n          current(parser).lo,\n          current(parser).hi,\n        )\n        bump(parser)\n      } else {\n        let expression = parseNestedExpression(service, parser, \"value\", 0)?\n        expect(parser, \"interpolation-end\", \"`\\}`\")?\n        children.push(node(\n          \"string-part/interpolation\",\n          expression.lo,\n          expression.hi,\n          \"parts\",\n          partIndex,\n          [],\n          [expression],\n        ))\n        partIndex += 1\n      }\n      continue\n    }\n    fail(parser, \"expected string content\")?\n  }\n  let close = expect(parser, \"string-end\", \"a string close\")?\n  Ok(node(\n    if tagged { \"expression/template\" } else { \"expression/string\" },\n    start.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    cookStringParts(parser.source, start.hi, close.lo, multiline, children),\n  ))\n}\n\nexport function skipSeparators(parser: Parser) -> () {\n  while eat(parser, \"separator\") {}\n  ()\n}\n\nexport function synchronize(parser: Parser) -> () {\n  let mut depth = 0\n  while !at(parser, \"eof\") {\n    let kind = current(parser).kind\n    if depth == 0 && (kind == \"separator\" || kind == \"right-brace\") {\n      break\n    }\n    if kind == \"left-paren\" || kind == \"left-bracket\" ||\n      kind == \"left-brace\" || kind == \"interpolation-start\" ||\n      kind.startsWith(\"string-start/\") {\n      depth += 1\n    } else if kind == \"right-paren\" || kind == \"right-bracket\" ||\n      kind == \"right-brace\" || kind == \"interpolation-end\" ||\n      kind == \"string-end\" {\n      if depth == 0 {\n        break\n      }\n      depth -= 1\n    }\n    bump(parser)\n  }\n  eat(parser, \"separator\")\n  ()\n}\n\nexport function itemBoundary(parser: Parser) -> () {\n  if at(parser, \"separator\") {\n    skipSeparators(parser)\n  } else if !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    addDiagnostic(\n      parser,\n      \"TPZ2001\",\n      \"expected a statement separator\",\n      current(parser).lo,\n      current(parser).hi,\n    )\n    synchronize(parser)\n  }\n  ()\n}\n",
      "sourceSha256": "83426c4e5670527cd4d0b1600159b34b6dd0991887080a164bb5e793059769d6"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/parser/declarations_modules.tpz",
      "language": "topaz",
      "bytes": 37341,
      "sha256": "153d92263f81f4699363d44e8dc10f41e5dbf5ae04548a60f8eed644a126dd56",
      "content": "// Declaration, statement, block, import, export, and program grammar.\n// Expression and type-pattern parsers are called through their forward service\n// records; the public parse result is assembled by parser.tpz.\n\nimport types { PreviewToken, SyntaxNode }\nimport parser.core {\n  Parser,\n  ParserService,\n  addDiagnostic,\n  at,\n  attach,\n  boolAttribute,\n  boxValue,\n  bump,\n  current,\n  eat,\n  expect,\n  expectLeftBrace,\n  expectRightBrace,\n  fail,\n  identNode,\n  identifier,\n  itemBoundary,\n  lambdaAllowed,\n  node,\n  recordUpdateAllowed,\n  rejectReservedBinding,\n  setLambdaAllowed,\n  setRecordUpdateAllowed,\n  skipSeparators,\n  stringAttribute,\n  synchronize,\n  text,\n  tokenAt,\n}\nimport parser.types_patterns {\n  bindingPattern,\n  expectCloseAngle,\n  namedType,\n  parsePattern,\n  parseType,\n}\nimport parser.expressions {\n  blockExpression,\n  labelNode,\n  parseExpression,\n  parseExpressionBeforeBlock,\n}\n\n// The high component is the type-parameter index and the low component is its bound ordinal.\nconst TYPE_BOUND_INDEX_STRIDE = 4294967296\n\nfunction rejectedStatement(message: string) -> Result<SyntaxNode, string> {\n  Err(message)\n}\n\nfunction skipBalancedBraces(parser: Parser) -> () {\n  if !at(parser, \"left-brace\") {\n    return ()\n  }\n  let mut depth = 0\n  while !at(parser, \"eof\") {\n    let kind = current(parser).kind\n    if kind == \"left-brace\" {\n      depth += 1\n    } else if kind == \"right-brace\" {\n      depth -= 1\n    }\n    bump(parser)\n    if depth == 0 {\n      break\n    }\n  }\n  ()\n}\n\nfunction parseTypeParameters(\n  parser: Parser,\n  field: string,\n) -> Result<Array<SyntaxNode>, string> {\n  let mut parameters: Array<SyntaxNode> = []\n  if !eat(parser, \"lt\") {\n    return Ok(parameters)\n  }\n  let mut index = 0\n  while true {\n    let name = identifier(parser, \"a type parameter\")?\n    let spelling=text(parser,name.lo,name.hi)\n    if parser.languageMode == \"topaz-5.21\" && (spelling == \"Length\" || spelling == \"Pt\" || spelling == \"Mm\" || spelling == \"Cm\" || spelling == \"In\" || spelling == \"Em\") { fail(parser,\"Length unit markers are compiler-owned\")? }\n    parameters.push(identNode(name, field, index))\n    index += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  expectCloseAngle(parser)?\n  Ok(parameters)\n}\n\nfunction parseFunctionTypeParameters(parser: Parser) -> Result<Array<SyntaxNode>, string> {\n  let mut parameters: Array<SyntaxNode> = []\n  let mut bounds: Array<SyntaxNode> = []\n  if !eat(parser, \"lt\") {\n    return Ok(parameters)\n  }\n  let mut parameterIndex = 0\n  while true {\n    let name = identifier(parser, \"a type parameter\")?\n    let spelling=text(parser,name.lo,name.hi)\n    if parser.languageMode == \"topaz-5.21\" && (spelling == \"Length\" || spelling == \"Pt\" || spelling == \"Mm\" || spelling == \"Cm\" || spelling == \"In\" || spelling == \"Em\") { fail(parser,\"Length unit markers are compiler-owned\")? }\n    parameters.push(identNode(name, \"typeParameters\", parameterIndex))\n    if eat(parser, \"colon\") {\n      let mut boundIndex = 0\n      while true {\n        let bound = identifier(parser, \"a protocol bound\")?\n        bounds.push(identNode(\n          bound,\n          \"typeParameterBounds\",\n          parameterIndex * TYPE_BOUND_INDEX_STRIDE + boundIndex,\n        ))\n        boundIndex += 1\n        if !eat(parser, \"plus\") {\n          break\n        }\n      }\n    }\n    parameterIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  expectCloseAngle(parser)?\n  for bound in bounds {\n    parameters.push(bound)\n  }\n  Ok(parameters)\n}\n\nfunction parseFunction(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/function\", \"`function`\")?\n  let name = identifier(parser, \"a function name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for parameter in parseFunctionTypeParameters(parser)? {\n    children.push(parameter)\n  }\n  expect(parser, \"left-paren\", \"`(`\")?\n  let mut parameterIndex = 0\n  while !at(parser, \"right-paren\") && !at(parser, \"eof\") {\n    let parameterLo = current(parser).lo\n    let variadic = eat(parser, \"ellipsis\")\n    let parameterName = identifier(parser, \"a parameter name\")?\n    rejectReservedBinding(parser, parameterName)\n    let parameterType = if parameterIndex == 0 && !variadic &&\n      text(parser, parameterName.lo, parameterName.hi) == \"self\" &&\n      !at(parser, \"colon\") {\n      namedType(parameterName, \"type\", 0)\n    } else {\n      expect(parser, \"colon\", \"`:`\")?\n      parseType(service, parser, \"type\", 0)?\n    }\n    let mut parameterChildren: Array<SyntaxNode> = [\n      identNode(parameterName, \"name\", 0),\n      parameterType,\n    ]\n    if eat(parser, \"eq\") {\n      parameterChildren.push(parseExpression(service, parser, \"default\", 0)?)\n    }\n    children.push(node(\n      \"parameter\",\n      parameterLo,\n      boxValue(parser.lastHi),\n      \"parameters\",\n      parameterIndex,\n      [boolAttribute(\"variadic\", variadic)],\n      parameterChildren,\n    ))\n    parameterIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  expect(parser, \"right-paren\", \"`)`\")?\n  if eat(parser, \"thin-arrow\") {\n    children.push(parseType(service, parser, \"returnType\", 0)?)\n  }\n  let body = parseBlock(service, parser, \"body\", 0)?\n  let hi = body.hi\n  children.push(body)\n  let declaration = node(\n    \"function-declaration\",\n    name.lo,\n    hi,\n    \"declaration\",\n    0,\n    [],\n    children,\n  )\n  Ok(node(\n    \"statement/function\",\n    keyword.lo,\n    hi,\n    field,\n    index,\n    [],\n    [declaration],\n  ))\n}\n\nfunction parseTypeAlias(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/type\", \"`type`\")?\n  let name = identifier(parser, \"a type name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for parameter in parseTypeParameters(parser, \"typeParameters\")? {\n    children.push(parameter)\n  }\n  expect(parser, \"eq\", \"`=`\")?\n  let typeNode = parseType(service, parser, \"type\", 0)?\n  let hi = typeNode.hi\n  children.push(typeNode)\n  Ok(node(\n    \"statement/type-alias\",\n    keyword.lo,\n    hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseDerives(parser: Parser) -> Result<Array<SyntaxNode>, string> {\n  let mut derives: Array<SyntaxNode> = []\n  if !at(parser, \"identifier\") || text(parser, current(parser).lo, current(parser).hi) != \"derives\" {\n    return Ok(derives)\n  }\n  bump(parser)\n  let mut index = 0\n  while true {\n    derives.push(identNode(identifier(parser, \"a protocol name to derive\")?, \"derives\", index))\n    index += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  Ok(derives)\n}\n\nfunction contextualHeadAt(parser: Parser, offset: int, word: string) -> bool {\n  let head = tokenAt(parser, offset)\n  head.kind == \"identifier\" && text(parser, head.lo, head.hi) == word &&\n    tokenAt(parser, offset + 1).kind == \"identifier\"\n}\n\nfunction contextualHead(parser: Parser, word: string) -> bool {\n  contextualHeadAt(parser, 0, word)\n}\n\nfunction contextualHeadWithFollowAt(\n  parser: Parser,\n  offset: int,\n  word: string,\n  firstFollow: string,\n  secondFollow: string,\n) -> bool {\n  contextualHeadAt(parser, offset, word) &&\n    (tokenAt(parser, offset + 2).kind == firstFollow ||\n      tokenAt(parser, offset + 2).kind == secondFollow)\n}\n\nfunction contextualHeadWithFollow(\n  parser: Parser,\n  word: string,\n  firstFollow: string,\n  secondFollow: string,\n) -> bool {\n  contextualHeadWithFollowAt(parser, 0, word, firstFollow, secondFollow)\n}\n\nfunction derivableDeclarationHeadAt(parser: Parser, offset: int, word: string) -> bool {\n  if !contextualHeadAt(parser, offset, word) {\n    return false\n  }\n  let follow = tokenAt(parser, offset + 2)\n  follow.kind == \"left-brace\" || follow.kind == \"lt\" ||\n    (follow.kind == \"identifier\" && text(parser, follow.lo, follow.hi) == \"derives\")\n}\n\nfunction derivableDeclarationHead(parser: Parser, word: string) -> bool {\n  derivableDeclarationHeadAt(parser, 0, word)\n}\n\nfunction parseEnum(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`enum`\")?\n  let name = identifier(parser, \"an enum name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for parameter in parseTypeParameters(parser, \"typeParameters\")? {\n    children.push(parameter)\n  }\n  let derives = parseDerives(parser)?\n  expectLeftBrace(parser)?\n  let mut variantIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let variant = identifier(parser, \"a variant name\")?\n    let mut variantChildren: Array<SyntaxNode> = [identNode(variant, \"name\", 0)]\n    if eat(parser, \"left-paren\") {\n      let mut payloadIndex = 0\n      while true {\n        variantChildren.push(parseType(\n          service,\n\n          parser,\n          \"payload\",\n          payloadIndex,\n        )?)\n        payloadIndex += 1\n        if !eat(parser, \"comma\") {\n          break\n        }\n      }\n      expect(parser, \"right-paren\", \"`)`\")?\n    }\n    children.push(node(\n      \"enum-variant\",\n      variant.lo,\n      variant.hi,\n      \"variants\",\n      variantIndex,\n      [],\n      variantChildren,\n    ))\n    variantIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expectRightBrace(parser)?\n  for derived in derives {\n    children.push(derived)\n  }\n  Ok(node(\n    \"statement/enum\",\n    head.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseRecord(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`record`\")?\n  let name = identifier(parser, \"a record name\")?\n  let recordName = text(parser, name.lo, name.hi)\n  if recordName == \"map\" || recordName == \"set\" {\n    addDiagnostic(\n      parser,\n      \"TPZ2012\",\n      \"`{recordName}` is reserved for the `{recordName} \\{ … \\}` collection literal (§6) and cannot be a record name\",\n      name.lo,\n      name.hi,\n    )\n  }\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for parameter in parseTypeParameters(parser, \"typeParameters\")? {\n    children.push(parameter)\n  }\n  let derives = parseDerives(parser)?\n  expectLeftBrace(parser)?\n  let mut fieldIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let fieldLo = current(parser).lo\n    let fieldNameToken = identifier(parser, \"a field name\")?\n    expect(parser, \"colon\", \"`:`\")?\n    let typeNode = parseType(service, parser, \"type\", 0)?\n    let mut fieldChildren: Array<SyntaxNode> = [\n      identNode(fieldNameToken, \"name\", 0),\n      typeNode,\n    ]\n    if eat(parser, \"eq\") {\n      fieldChildren.push(parseExpression(service, parser, \"default\", 0)?)\n    }\n    children.push(node(\n      \"record-field-declaration\",\n      fieldLo,\n      boxValue(parser.lastHi),\n      \"fields\",\n      fieldIndex,\n      [],\n      fieldChildren,\n    ))\n    fieldIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expectRightBrace(parser)?\n  for derived in derives {\n    children.push(derived)\n  }\n  Ok(node(\n    \"statement/record\",\n    head.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseNewtype(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`newtype`\")?\n  let name = identifier(parser, \"a newtype name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for parameter in parseTypeParameters(parser, \"typeParameters\")? {\n    children.push(parameter)\n  }\n  expect(parser, \"eq\", \"`=`\")?\n  let base = parseType(service, parser, \"base\", 0)?\n  let hi = base.hi\n  children.push(base)\n  Ok(node(\n    \"statement/newtype\",\n    head.lo,\n    hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseImpl(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`impl`\")?\n  let name = identifier(parser, \"a type name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  if eat(parser, \"lt\") {\n    children.push(identNode(identifier(parser, \"a conforming type name\")?, \"target\", 0))\n    expectCloseAngle(parser)?\n  }\n  expectLeftBrace(parser)?\n  skipSeparators(parser)\n  let mut methodIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let methodLo = current(parser).lo\n    let exported = at(parser, \"identifier\") &&\n      text(parser, current(parser).lo, current(parser).hi) == \"export\"\n    if exported {\n      bump(parser)\n    }\n    if !at(parser, \"keyword/function\") {\n      fail(parser, \"an impl body contains only `function` methods\")?\n    }\n    let statement = parseFunction(service, parser, \"unused\", 0)?\n    let declaration = match statement.children.get(0) {\n      case Some(value) => attach(value, \"declaration\", 0)\n      case None => return Err(\"function declaration projection is missing\")\n    }\n    children.push(node(\n      \"impl-method\",\n      methodLo,\n      statement.hi,\n      \"methods\",\n      methodIndex,\n      [boolAttribute(\"exported\", exported)],\n      [declaration],\n    ))\n    methodIndex += 1\n    skipSeparators(parser)\n  }\n  let close = expectRightBrace(parser)?\n  Ok(node(\n    \"statement/impl\",\n    head.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseProtocolMethod(service: ParserService,\nparser: Parser, index: int) -> Result<SyntaxNode, string> {\n  expect(parser, \"keyword/function\", \"`function`\")?\n  let name = identifier(parser, \"a function name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for parameter in parseFunctionTypeParameters(parser)? {\n    children.push(parameter)\n  }\n  expect(parser, \"left-paren\", \"`(`\")?\n  let mut parameterIndex = 0\n  while !at(parser, \"right-paren\") && !at(parser, \"eof\") {\n    let parameterLo = current(parser).lo\n    let variadic = eat(parser, \"ellipsis\")\n    let parameterName = identifier(parser, \"a parameter name\")?\n    rejectReservedBinding(parser, parameterName)\n    expect(parser, \"colon\", \"`:`\")?\n    let parameterType = parseType(service, parser, \"type\", 0)?\n    let mut parameterChildren: Array<SyntaxNode> = [\n      identNode(parameterName, \"name\", 0),\n      parameterType,\n    ]\n    if eat(parser, \"eq\") {\n      parameterChildren.push(parseExpression(service, parser, \"default\", 0)?)\n    }\n    children.push(node(\n      \"parameter\",\n      parameterLo,\n      boxValue(parser.lastHi),\n      \"parameters\",\n      parameterIndex,\n      [boolAttribute(\"variadic\", variadic)],\n      parameterChildren,\n    ))\n    parameterIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  expect(parser, \"right-paren\", \"`)`\")?\n  if eat(parser, \"thin-arrow\") {\n    children.push(parseType(service, parser, \"returnType\", 0)?)\n  }\n  let bodyToken = current(parser)\n  children.push(node(\n    \"block\",\n    bodyToken.lo,\n    bodyToken.hi,\n    \"body\",\n    0,\n    [],\n    [],\n  ))\n  Ok(node(\n    \"function-declaration\",\n    name.lo,\n    bodyToken.hi,\n    \"methods\",\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseProtocol(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`protocol`\")?\n  let name = identifier(parser, \"a protocol name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for parameter in parseTypeParameters(parser, \"typeParameters\")? {\n    children.push(parameter)\n  }\n  expectLeftBrace(parser)?\n  skipSeparators(parser)\n  let mut methodIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    if !at(parser, \"keyword/function\") {\n      fail(parser, \"a protocol body contains only `function` signatures\")?\n    }\n    children.push(parseProtocolMethod(service, parser, methodIndex)?)\n    methodIndex += 1\n    skipSeparators(parser)\n  }\n  let close = expectRightBrace(parser)?\n  Ok(node(\n    \"statement/protocol\",\n    head.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseUsing(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`using`\")?\n  let name = identifier(parser, \"a resource binding name\")?\n  rejectReservedBinding(parser, name)\n  expect(parser, \"eq\", \"`=`\")?\n  let value = parseExpressionBeforeBlock(service, parser, \"value\", 0)?\n  let body = parseBlock(service, parser, \"body\", 0)?\n  Ok(node(\n    \"statement/using\",\n    head.lo,\n    body.hi,\n    field,\n    index,\n    [],\n    [identNode(name, \"name\", 0), value, body],\n  ))\n}\n\nfunction parseLet(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/let\", \"`let`\")?\n  let mutable = eat(parser, \"keyword/mut\")\n  let pattern = if mutable {\n    let name = identifier(parser, \"a binding name\")?\n    rejectReservedBinding(parser, name)\n    bindingPattern(name, \"pattern\", 0)\n  } else {\n    parsePattern(service, parser, \"pattern\", 0)?\n  }\n  let mut children: Array<SyntaxNode> = [pattern]\n  if eat(parser, \"colon\") {\n    children.push(parseType(service, parser, \"type\", 0)?)\n  }\n  if !mutable && at(parser, \"keyword/mut\") {\n    fail(parser, \"`mut` comes right after `let` — write `let mut <name> = …`\")?\n  }\n  expect(parser, \"eq\", \"`=`\")?\n  children.push(parseExpression(service, parser, \"value\", 0)?)\n  Ok(node(\n    \"statement/let\",\n    keyword.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [boolAttribute(\"mutable\", mutable)],\n    children,\n  ))\n}\n\nfunction parseConst(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/const\", \"`const`\")?\n  let name = identifier(parser, \"a constant name\")?\n  rejectReservedBinding(parser, name)\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  if eat(parser, \"colon\") {\n    children.push(parseType(service, parser, \"type\", 0)?)\n  }\n  expect(parser, \"eq\", \"`=`\")?\n  children.push(parseExpression(service, parser, \"value\", 0)?)\n  Ok(node(\n    \"statement/const\",\n    keyword.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseReturnStatement(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = bump(parser)\n  let mut children: Array<SyntaxNode> = []\n  if !at(parser, \"separator\") && !at(parser, \"right-brace\") &&\n    !at(parser, \"eof\") {\n    children.push(parseExpression(service, parser, \"value\", 0)?)\n  }\n  Ok(node(\n    \"statement/return\",\n    keyword.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseLoopExitStatement(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let kind = current(parser).kind\n  let keyword = bump(parser)\n  let mut children: Array<SyntaxNode> = []\n  if at(parser, \"label\") {\n    children.push(labelNode(bump(parser), \"label\", 0))\n  }\n  if kind == \"keyword/break\" && !at(parser, \"separator\") &&\n    !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    children.push(parseExpression(service, parser, \"value\", 0)?)\n  }\n  Ok(node(\n    if kind == \"keyword/break\" {\n      \"statement/break\"\n    } else {\n      \"statement/continue\"\n    },\n    keyword.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction whileLetNode(\n  keyword: PreviewToken,\n  pattern: SyntaxNode,\n  scrutinee: SyntaxNode,\n  sourceBody: SyntaxNode,\n  field: string,\n  index: int,\n) -> SyntaxNode {\n  let hi = sourceBody.hi\n  let lo = keyword.lo\n  let bodyExpression = blockExpression(sourceBody, \"body\", 0)\n  let firstCase = node(\n    \"match-case\",\n    lo,\n    hi,\n    \"cases\",\n    0,\n    [],\n    [pattern, bodyExpression],\n  )\n  let wildcard = node(\"pattern/wildcard\", lo, hi, \"pattern\", 0, [], [])\n  let syntheticBreak = node(\n    \"statement/break\",\n    lo,\n    hi,\n    \"statements\",\n    0,\n    [],\n    [],\n  )\n  let syntheticBlock = node(\n    \"block\",\n    lo,\n    hi,\n    \"block\",\n    0,\n    [],\n    [syntheticBreak],\n  )\n  let breakExpression = node(\n    \"expression/block\",\n    lo,\n    hi,\n    \"body\",\n    0,\n    [],\n    [syntheticBlock],\n  )\n  let secondCase = node(\n    \"match-case\",\n    lo,\n    hi,\n    \"cases\",\n    1,\n    [],\n    [wildcard, breakExpression],\n  )\n  let matchExpression = node(\n    \"expression/match\",\n    lo,\n    hi,\n    \"tail\",\n    0,\n    [],\n    [scrutinee, firstCase, secondCase],\n  )\n  let body = node(\"block\", lo, hi, \"body\", 0, [], [matchExpression])\n  let condition = node(\n    \"expression/boolean\",\n    lo,\n    hi,\n    \"condition\",\n    0,\n    [boolAttribute(\"value\", true)],\n    [],\n  )\n  node(\"statement/while\", lo, hi, field, index, [], [condition, body])\n}\n\nfunction parseWhileStatement(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = bump(parser)\n  if eat(parser, \"keyword/let\") {\n    let pattern = parsePattern(service, parser, \"pattern\", 0)?\n    expect(parser, \"eq\", \"`=`\")?\n    let scrutinee = parseExpressionBeforeBlock(service, parser, \"scrutinee\", 0)?\n    let body = parseBlock(service, parser, \"block\", 0)?\n    return Ok(whileLetNode(keyword, pattern, scrutinee, body, field, index))\n  }\n  let condition = parseExpressionBeforeBlock(service, parser, \"condition\", 0)?\n  let body = parseBlock(service, parser, \"body\", 0)?\n  Ok(node(\n    \"statement/while\",\n    keyword.lo,\n    body.hi,\n    field,\n    index,\n    [],\n    [condition, body],\n  ))\n}\n\nfunction parseDeferStatement(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = bump(parser)\n  let value = parseExpression(service, parser, \"value\", 0)?\n  if value.kind != \"expression/block\" && value.kind != \"expression/call\" {\n    addDiagnostic(\n      parser,\n      \"TPZ2004\",\n      \"`defer` takes a block or a call\",\n      value.lo,\n      value.hi,\n    )\n  }\n  Ok(node(\n    \"statement/defer\",\n    keyword.lo,\n    value.hi,\n    field,\n    index,\n    [],\n    [value],\n  ))\n}\n\nfunction assignmentOperator(kind: string) -> string {\n  match kind {\n    case \"eq\" => \"assign\"\n    case \"plus-eq\" => \"add\"\n    case \"minus-eq\" => \"subtract\"\n    case \"star-eq\" => \"multiply\"\n    case \"slash-eq\" => \"divide\"\n    case \"percent-eq\" => \"remainder\"\n    case _ => \"coalesce\"\n  }\n}\n\nfunction parseExpressionStatement(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let expression = parseExpression(service, parser, \"value\", 0)?\n  let assignmentKind = current(parser).kind\n  if assignmentKind != \"eq\" && assignmentKind != \"plus-eq\" &&\n    assignmentKind != \"minus-eq\" && assignmentKind != \"star-eq\" &&\n    assignmentKind != \"slash-eq\" && assignmentKind != \"percent-eq\" &&\n    assignmentKind != \"question-question-eq\" {\n    return Ok(node(\n      \"statement/expression\",\n      expression.lo,\n      expression.hi,\n      field,\n      index,\n      [],\n      [expression],\n    ))\n  }\n  if expression.kind != \"expression/identifier\" &&\n    expression.kind != \"expression/member\" &&\n    expression.kind != \"expression/index\" {\n    addDiagnostic(\n      parser,\n      \"TPZ2003\",\n      \"assignment target must be an identifier, member access, or index access\",\n      expression.lo,\n      expression.hi,\n    )\n  }\n  bump(parser)\n  let value = parseExpression(service, parser, \"value\", 0)?\n  Ok(node(\n    \"statement/assign\",\n    expression.lo,\n    value.hi,\n    field,\n    index,\n    [stringAttribute(\"operator\", assignmentOperator(assignmentKind))],\n    [attach(expression, \"target\", 0), value],\n  ))\n}\n\nfunction parseStatement(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let kind = current(parser).kind\n  if kind == \"keyword/function\" { return parseFunction(service, parser, field, index) }\n  if kind == \"keyword/let\" { return parseLet(service, parser, field, index) }\n  if kind == \"keyword/mut\" {\n    fail(parser, \"`mut` comes right after `let` — write `let mut <name> = …`\")?\n  }\n  if kind == \"keyword/type\" { return parseTypeAlias(service, parser, field, index) }\n  if derivableDeclarationHead(parser, \"enum\") { return parseEnum(service, parser, field, index) }\n  if derivableDeclarationHead(parser, \"record\") { return parseRecord(service, parser, field, index) }\n  if contextualHeadWithFollow(parser, \"newtype\", \"eq\", \"lt\") {\n    return parseNewtype(service, parser, field, index)\n  }\n  if contextualHeadWithFollow(parser, \"impl\", \"left-brace\", \"lt\") {\n    return parseImpl(service, parser, field, index)\n  }\n  if contextualHeadWithFollow(parser, \"protocol\", \"left-brace\", \"lt\") {\n    return parseProtocol(service, parser, field, index)\n  }\n  if contextualHead(parser, \"using\") && tokenAt(parser, 2).kind == \"eq\" {\n    return parseUsing(service, parser, field, index)\n  }\n  if kind == \"keyword/const\" { return parseConst(service, parser, field, index) }\n  if kind == \"keyword/return\" {\n    return parseReturnStatement(service, parser, field, index)\n  }\n  if kind == \"keyword/break\" || kind == \"keyword/continue\" {\n    return parseLoopExitStatement(service, parser, field, index)\n  }\n  if kind == \"keyword/while\" {\n    return parseWhileStatement(service, parser, field, index)\n  }\n  if kind == \"keyword/defer\" {\n    return parseDeferStatement(service, parser, field, index)\n  }\n  parseExpressionStatement(service, parser, field, index)\n}\n\nfunction parseBlockBody(\n  service: ParserService,\n  parser: Parser,\n  open: PreviewToken,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let mut statements: Array<SyntaxNode> = []\n  let mut tail: Option<SyntaxNode> = None\n  let mut statementIndex = 0\n  skipSeparators(parser)\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let before = boxValue(parser.position)\n    match parseStatement(service, parser, \"statements\", statementIndex) {\n      case Ok(statement) => {\n        if at(parser, \"right-brace\") && statement.kind == \"statement/expression\" {\n          tail = statement.children.get(0)\n          break\n        }\n        statements.push(statement)\n        statementIndex += 1\n        itemBoundary(parser)\n      }\n      case Err(_) => synchronize(parser)\n    }\n    if boxValue(parser.position) == before &&\n      !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n      addDiagnostic(\n        parser,\n        \"TPZ2001\",\n        \"expected a statement\",\n        current(parser).lo,\n        current(parser).hi,\n      )\n      bump(parser)\n    }\n    skipSeparators(parser)\n  }\n  let close = expectRightBrace(parser)?\n  let mut children = statements\n  match tail {\n    case Some(value) => children.push(attach(value, \"tail\", 0))\n    case None => ()\n  }\n  Ok(node(\"block\", open.lo, close.hi, field, index, [], children))\n}\n\nexport function parseBlock(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let open = expectLeftBrace(parser)?\n  let previousLambda = lambdaAllowed(parser)\n  let previousRecordUpdate = recordUpdateAllowed(parser)\n  setLambdaAllowed(parser, true)\n  setRecordUpdateAllowed(parser, true)\n  let result = parseBlockBody(service, parser, open, field, index)\n  setLambdaAllowed(parser, previousLambda)\n  setRecordUpdateAllowed(parser, previousRecordUpdate)\n  result\n}\n\nfunction isContextualWord(parser: Parser, word: string) -> bool {\n  at(parser, \"identifier\") && text(parser, current(parser).lo, current(parser).hi) == word\n}\n\nrecord ParsedImportSpec {\n  node: SyntaxNode,\n  sourceName: string,\n  sourceToken: PreviewToken,\n  boundName: string,\n  boundToken: PreviewToken,\n}\n\nfunction parseModulePath(parser: Parser) -> Result<SyntaxNode, string> {\n  let first = identifier(parser, \"a module path segment\")?\n  let mut pathChildren: Array<SyntaxNode> = [identNode(first, \"segments\", 0)]\n  let mut pathIndex = 1\n  let mut pathHi = first.hi\n  while eat(parser, \"dot\") {\n    let segment = identifier(parser, \"a module path segment\")?\n    pathChildren.push(identNode(segment, \"segments\", pathIndex))\n    pathIndex += 1\n    pathHi = segment.hi\n  }\n  Ok(node(\n    \"module-path\",\n    first.lo,\n    pathHi,\n    \"path\",\n    0,\n    [],\n    pathChildren,\n  ))\n}\n\nfunction parseImportSpec(\n  parser: Parser,\n  index: int,\n) -> Result<ParsedImportSpec, string> {\n  if current(parser).kind.startsWith(\"keyword/\") {\n    let token = current(parser)\n    addDiagnostic(\n      parser,\n      \"TPZ2011\",\n      \"an import name is an identifier; keywords cannot be selected\",\n      token.lo,\n      token.hi,\n    )\n    return Err(\"an import name is an identifier\")\n  }\n  let name = identifier(parser, \"an import name\")?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  let mut hi = name.hi\n  let sourceName = text(parser, name.lo, name.hi)\n  let mut boundName = sourceName\n  let mut boundToken = name\n  if isContextualWord(parser, \"as\") {\n    bump(parser)\n    let alias = identifier(parser, \"an import alias\")?\n    hi = alias.hi\n    boundName = text(parser, alias.lo, alias.hi)\n    boundToken = alias\n    children.push(identNode(alias, \"alias\", 0))\n  }\n  Ok(ParsedImportSpec {\n    node: node(\"import-spec\", name.lo, hi, \"specs\", index, [], children),\n    sourceName: sourceName,\n    sourceToken: name,\n    boundName: boundName,\n    boundToken: boundToken,\n  })\n}\n\nfunction diagnoseDuplicateImportSpecs(\n  parser: Parser,\n  specs: Array<ParsedImportSpec>,\n) -> () {\n  // Diagnose each later offending spec once in source order, with\n  // source-name precedence when both duplicate axes apply.\n  let mut sourceNames: Set<string> = set {}\n  let mut boundNames: Set<string> = set {}\n  for spec in specs {\n    let sourceDuplicate = sourceNames.contains(spec.sourceName)\n    let boundDuplicate = boundNames.contains(spec.boundName)\n    sourceNames.add(spec.sourceName)\n    boundNames.add(spec.boundName)\n    if sourceDuplicate {\n      addDiagnostic(\n        parser,\n        \"TPZ2011\",\n        \"this exported name is already selected in this list\",\n        spec.sourceToken.lo,\n        spec.sourceToken.hi,\n      )\n    } else if boundDuplicate {\n      addDiagnostic(\n        parser,\n        \"TPZ2011\",\n        \"this local name is already bound by this list\",\n        spec.boundToken.lo,\n        spec.boundToken.hi,\n      )\n    }\n  }\n  ()\n}\n\nfunction parseImportSelection(parser: Parser) -> Result<Array<SyntaxNode>, string> {\n  let open = expectLeftBrace(parser)?\n  let mut parsedSpecs: Array<ParsedImportSpec> = []\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    parsedSpecs.push(parseImportSpec(parser, parsedSpecs.length)?)\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expectRightBrace(parser)?\n  if parsedSpecs.length == 0 {\n    addDiagnostic(\n      parser,\n      \"TPZ2011\",\n      \"a selection list selects at least one exported name\",\n      open.lo,\n      close.hi,\n    )\n  }\n  diagnoseDuplicateImportSpecs(parser, parsedSpecs)\n  let mut specs: Array<SyntaxNode> = []\n  for spec in parsedSpecs {\n    specs.push(spec.node)\n  }\n  Ok(specs)\n}\n\nfunction parseImportAlias(parser: Parser) -> Result<SyntaxNode, string> {\n  bump(parser)\n  let alias = identNode(identifier(parser, \"an import alias\")?, \"alias\", 0)\n  if at(parser, \"left-brace\") {\n    let brace = current(parser)\n    addDiagnostic(\n      parser,\n      \"TPZ2009\",\n      \"a namespace alias and a selection list do not compose (`import m as ns \\{ x \\}` is invalid syntax)\",\n      brace.lo,\n      brace.hi,\n    )\n    skipBalancedBraces(parser)\n  }\n  Ok(alias)\n}\n\nfunction parseImport(parser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`import`\")?\n  let path = parseModulePath(parser)?\n  let mut importChildren: Array<SyntaxNode> = [path]\n  if at(parser, \"left-brace\") {\n    for spec in parseImportSelection(parser)? {\n      importChildren.push(spec)\n    }\n  } else if isContextualWord(parser, \"as\") {\n    importChildren.push(parseImportAlias(parser)?)\n  }\n  let hi = boxValue(parser.lastHi)\n  let importItem = node(\n    \"import-item\",\n    head.lo,\n    hi,\n    \"import\",\n    0,\n    [],\n    importChildren,\n  )\n  Ok(node(\n    \"statement/import\",\n    head.lo,\n    hi,\n    field,\n    index,\n    [],\n    [importItem],\n  ))\n}\n\nfunction parseImportAtProgram(\n  parser: Parser,\n  field: string,\n  index: int,\n  prologueDone: bool,\n) -> Result<SyntaxNode, string> {\n  let statement = parseImport(parser, field, index)?\n  if prologueDone {\n    addDiagnostic(\n      parser,\n      \"TPZ2010\",\n      \"imports form a prologue: every `import` precedes all other top-level items\",\n      statement.lo,\n      statement.hi,\n    )\n  }\n  Ok(statement)\n}\n\nfunction parseExport(service: ParserService,\nparser: Parser, field: string, index: int) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`export`\")?\n  let inner = parseStatement(service, parser, \"item\", 0)?\n  if inner.kind == \"statement/let\" {\n    match inner.children.get(0) {\n      case Some(pattern) => {\n        if pattern.kind != \"pattern/binding\" && pattern.kind != \"pattern/typed\" {\n          addDiagnostic(\n            parser,\n            \"TPZ2007\",\n            \"an exported `let` binds exactly one identifier; destructure privately, then export the identifier\",\n            pattern.lo,\n            pattern.hi,\n          )\n        }\n      }\n      case None => ()\n    }\n  }\n  Ok(node(\n    \"statement/export\",\n    head.lo,\n    inner.hi,\n    field,\n    index,\n    [],\n    [inner],\n  ))\n}\n\nfunction exportDeclarationHead(parser: Parser) -> bool {\n  if !isContextualWord(parser, \"export\") {\n    return false\n  }\n  let follow = tokenAt(parser, 1)\n  if follow.kind == \"keyword/function\" ||\n    follow.kind == \"keyword/type\" ||\n    follow.kind == \"keyword/let\" ||\n    follow.kind == \"keyword/const\" {\n    return true\n  }\n  if follow.kind != \"identifier\" {\n    return false\n  }\n  let word = text(parser, follow.lo, follow.hi)\n  if word == \"enum\" || word == \"record\" {\n    return derivableDeclarationHeadAt(parser, 1, word)\n  }\n  word == \"newtype\" && contextualHeadWithFollowAt(parser, 1, word, \"eq\", \"lt\")\n}\n\nfunction rejectStringModulePath(parser: Parser) -> Result<SyntaxNode, string> {\n  let token = current(parser)\n  addDiagnostic(\n    parser,\n    \"TPZ2008\",\n    \"string and template module paths are reserved and unused; module paths are dotted identifiers\",\n    token.lo,\n    token.hi,\n  )\n  rejectedStatement(\"reserved module path\")\n}\n\nfunction rejectUseItem(parser: Parser) -> Result<SyntaxNode, string> {\n  let token = current(parser)\n  addDiagnostic(\n    parser,\n    \"TPZ2008\",\n    \"`use` is reserved and unused; did you mean `import`?\",\n    token.lo,\n    token.hi,\n  )\n  rejectedStatement(\"reserved use item\")\n}\n\nfunction rejectExportList(parser: Parser) -> Result<SyntaxNode, string> {\n  let token = current(parser)\n  addDiagnostic(\n    parser,\n    \"TPZ2009\",\n    \"export lists are invalid syntax; put `export` on each public declaration\",\n    token.lo,\n    token.hi,\n  )\n  bump(parser)\n  skipBalancedBraces(parser)\n  rejectedStatement(\"rejected export list\")\n}\n\nfunction rejectReexport(parser: Parser) -> Result<SyntaxNode, string> {\n  let token = current(parser)\n  addDiagnostic(\n    parser,\n    \"TPZ2009\",\n    \"re-export syntax does not exist (`export import ...` is rejected)\",\n    token.lo,\n    token.hi,\n  )\n  rejectedStatement(\"re-export is rejected\")\n}\n\nfunction parseProgramItem(\n  service: ParserService,\n  parser: Parser,\n  index: int,\n  prologueDone: bool,\n) -> Result<SyntaxNode, string> {\n  if isContextualWord(parser, \"import\") && tokenAt(parser, 1).kind == \"identifier\" {\n    return parseImportAtProgram(parser, \"items\", index, prologueDone)\n  }\n  if isContextualWord(parser, \"import\") &&\n    tokenAt(parser, 1).kind.startsWith(\"string-start/\") {\n    return rejectStringModulePath(parser)\n  }\n  if isContextualWord(parser, \"use\") && tokenAt(parser, 1).kind == \"identifier\" {\n    return rejectUseItem(parser)\n  }\n  if isContextualWord(parser, \"export\") && tokenAt(parser, 1).kind == \"left-brace\" {\n    return rejectExportList(parser)\n  }\n  if isContextualWord(parser, \"export\") &&\n    tokenAt(parser, 1).kind == \"identifier\" &&\n    text(parser, tokenAt(parser, 1).lo, tokenAt(parser, 1).hi) == \"import\" {\n    return rejectReexport(parser)\n  }\n  if exportDeclarationHead(parser) {\n    parseExport(service, parser, \"items\", index)\n  } else {\n    parseStatement(service, parser, \"items\", index)\n  }\n}\n\nexport function parseProgram(service: ParserService,\nparser: Parser, sourceLength: int) -> SyntaxNode {\n  let mut items: Array<SyntaxNode> = []\n  let mut index = 0\n  let mut prologueDone = false\n  skipSeparators(parser)\n  while !at(parser, \"eof\") {\n    let before = boxValue(parser.position)\n    match parseProgramItem(service, parser, index, prologueDone) {\n      case Ok(statement) => {\n        if statement.kind != \"statement/import\" {\n          prologueDone = true\n        }\n        items.push(statement)\n        index += 1\n        itemBoundary(parser)\n      }\n      case Err(_) => synchronize(parser)\n    }\n    if boxValue(parser.position) == before && !at(parser, \"eof\") {\n      addDiagnostic(\n        parser,\n        \"TPZ2001\",\n        \"expected a statement\",\n        current(parser).lo,\n        current(parser).hi,\n      )\n      bump(parser)\n    }\n    skipSeparators(parser)\n  }\n  node(\"program\", 0, sourceLength, \"root\", 0, [], items)\n}\n",
      "sourceSha256": "153d92263f81f4699363d44e8dc10f41e5dbf5ae04548a60f8eed644a126dd56"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/parser/expressions.tpz",
      "language": "topaz",
      "bytes": 44406,
      "sha256": "1c6d84f2b9361c3fd8d12dd8f173005be70d5b0bea264b910f5c47c35e7e7660",
      "content": "import literal { integerMagnitude, validIntegerLiteral, floatLiteralBits }\n// Atom, postfix, precedence, and control-expression grammar.\n// Type and pattern parsing enter through parser services, while node allocation\n// and recovery remain in parser.core.\n\nimport length { validLiteral }\nimport types { PreviewAstAttribute, PreviewDiagnostic, PreviewToken, SyntaxNode }\nimport parser.core {\n  Parser,\n  ParserService,\n  addDiagnostic,\n  at,\n  attach,\n  boolAttribute,\n  boxValue,\n  bump,\n  current,\n  diagnostic,\n  eat,\n  expect,\n  expectLeftBrace,\n  expectRightBrace,\n  fail,\n  fieldName,\n  identNode,\n  identifier,\n  isFieldNameKind,\n  itemBoundary,\n  invokeParseBlock,\n  lambdaAllowed,\n  layoutTokenAt,\n  matchingParenFollowedBy,\n  node,\n  parseString,\n  validateNumericLiteral,\n  recordUpdateAllowed,\n  rejectReservedBinding,\n  setLambdaAllowed,\n  setRecordUpdateAllowed,\n  skipSeparators,\n  stringAttribute,\n  synchronize,\n  text,\n  tokenAt,\n}\nimport parser.types_patterns { parsePattern, parseType, parseTypeArguments }\n\nfunction diagnosticWithNotes(\n  code: string,\n  message: string,\n  lo: int,\n  hi: int,\n  notes: Array<string>,\n) -> PreviewDiagnostic {\n  PreviewDiagnostic { code: code, message: message, lo: lo, hi: hi, notes: notes }\n}\n\nfunction nullAttribute(name: string) -> PreviewAstAttribute {\n  PreviewAstAttribute { name: name, kind: \"null\", value: \"\" }\n}\n\nfunction binaryPrecedence(kind: string) -> int {\n  match kind {\n    case \"pipe-gt\" => 1\n    case \"gt-gt\" => 2\n    case \"question-question\" => 3\n    case \"or-or\" => 4\n    case \"and-and\" => 5\n    case \"eq-eq\" | \"not-eq\" => 6\n    case \"lt\" | \"le\" | \"gt\" | \"ge\" | \"keyword/in\" => 6\n    case \"dot-dot\" | \"dot-dot-lt\" => 7\n    case \"plus\" | \"minus\" => 8\n    case \"star\" | \"slash\" | \"percent\" => 9\n    case _ => 0\n  }\n}\n\nfunction binaryName(kind: string) -> string {\n  match kind {\n    case \"plus\" => \"add\"\n    case \"minus\" => \"subtract\"\n    case \"star\" => \"multiply\"\n    case \"slash\" => \"divide\"\n    case \"percent\" => \"remainder\"\n    case \"lt\" => \"less-than\"\n    case \"le\" => \"less-or-equal\"\n    case \"gt\" => \"greater-than\"\n    case \"ge\" => \"greater-or-equal\"\n    case \"eq-eq\" => \"equal\"\n    case \"not-eq\" => \"not-equal\"\n    case \"keyword/in\" => \"in\"\n    case \"and-and\" => \"and\"\n    case \"or-or\" => \"or\"\n    case \"question-question\" => \"coalesce\"\n    case _ => \"\"\n  }\n}\n\nfunction parseCallArguments(\n  service: ParserService,\n  parser: Parser,\n) -> Result<Array<SyntaxNode>, string> {\n  expect(parser, \"left-paren\", \"`(`\")?\n  let mut arguments: Array<SyntaxNode> = []\n  let mut index = 0\n  while !at(parser, \"right-paren\") && !at(parser, \"eof\") {\n    if eat(parser, \"ellipsis\") {\n      let value = parseNestedExpression(service, parser, \"value\", 0)?\n      arguments.push(node(\n        \"call-argument/spread\",\n        value.lo,\n        value.hi,\n        \"arguments\",\n        index,\n        [],\n        [value],\n      ))\n    } else if at(parser, \"identifier\") && tokenAt(parser, 1).kind == \"colon\" {\n      let name = bump(parser)\n      bump(parser)\n      let value = parseNestedExpression(service, parser, \"value\", 0)?\n      arguments.push(node(\n        \"call-argument/named\",\n        name.lo,\n        value.hi,\n        \"arguments\",\n        index,\n        [],\n        [identNode(name, \"name\", 0), value],\n      ))\n    } else {\n      arguments.push(parseNestedExpression(service, parser, \"arguments\", index)?)\n    }\n    index += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  expect(parser, \"right-paren\", \"`)`\")?\n  Ok(arguments)\n}\n\nfunction looksLikeCallTypeArguments(parser: Parser) -> bool {\n  if !at(parser, \"lt\") {\n    return false\n  }\n  let mut angle = 0\n  let mut paren = 0\n  let mut brace = 0\n  let mut offset = 0\n  let mut sawTypeToken = false\n  while true {\n    let token = tokenAt(parser, offset)\n    if token.kind == \"lt\" {\n      angle += 1\n    } else if token.kind == \"gt\" || token.kind == \"gt-gt\" {\n      if paren != 0 || brace != 0 {\n        return false\n      }\n      if token.kind == \"gt-gt\" {\n        angle -= 2\n      } else {\n        angle -= 1\n      }\n      if angle <= 0 {\n        let next = tokenAt(parser, offset + 1)\n        return angle == 0 && sawTypeToken &&\n          next.kind == \"left-paren\" && token.hi == next.lo\n      }\n      sawTypeToken = true\n    } else if token.kind == \"left-paren\" {\n      paren += 1\n      sawTypeToken = true\n    } else if token.kind == \"right-paren\" {\n      paren -= 1\n      if paren < 0 {\n        return false\n      }\n    } else if token.kind == \"left-brace\" {\n      brace += 1\n      sawTypeToken = true\n    } else if token.kind == \"right-brace\" {\n      brace -= 1\n      if brace < 0 {\n        return false\n      }\n    } else if token.kind == \"identifier\" || token.kind == \"dot\" ||\n      token.kind == \"thin-arrow\" || token.kind == \"ellipsis\" ||\n      token.kind == \"pipe\" || token.kind == \"colon\" ||\n      token.kind == \"integer\" || token.kind == \"float\" ||\n      token.kind == \"keyword/true\" || token.kind == \"keyword/false\" ||\n      token.kind == \"keyword/null\" || token.kind == \"string-end\" ||\n      token.kind == \"string-text\" || token.kind.startsWith(\"string-start/\") {\n      sawTypeToken = true\n    } else if token.kind != \"comma\" {\n      return false\n    }\n    offset += 1\n  }\n  false\n}\n\nfunction parseLambdaParameters(\n  service: ParserService,\n  parser: Parser,\n) -> Result<Array<SyntaxNode>, string> {\n  let mut parameters: Array<SyntaxNode> = []\n  let mut index = 0\n  while !at(parser, \"right-paren\") && !at(parser, \"eof\") {\n    let lo = current(parser).lo\n    let name = identifier(parser, \"a parameter name\")?\n    rejectReservedBinding(parser, name)\n    let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n    if eat(parser, \"colon\") {\n      children.push(parseType(service, parser, \"type\", 0)?)\n    }\n    parameters.push(node(\n      \"lambda-parameter\",\n      lo,\n      boxValue(parser.lastHi),\n      \"parameters\",\n      index,\n      [],\n      children,\n    ))\n    index += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  Ok(parameters)\n}\n\nfunction parseSingleLambda(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let name = identifier(parser, \"a parameter name\")?\n  rejectReservedBinding(parser, name)\n  expect(parser, \"fat-arrow\", \"`=>`\")?\n  let body = parseExpression(service, parser, \"body\", 0)?\n  Ok(node(\n    \"expression/lambda\",\n    name.lo,\n    body.hi,\n    field,\n    index,\n    [],\n    [\n      node(\n        \"lambda-parameter\",\n        name.lo,\n        name.hi,\n        \"parameters\",\n        0,\n        [],\n        [identNode(name, \"name\", 0)],\n      ),\n      body,\n    ],\n  ))\n}\n\nfunction parseParenLambda(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let open = expect(parser, \"left-paren\", \"`(`\")?\n  let mut children = parseLambdaParameters(service, parser)?\n  expect(parser, \"right-paren\", \"`)`\")?\n  expect(parser, \"fat-arrow\", \"`=>`\")?\n  let body = parseExpression(service, parser, \"body\", 0)?\n  let hi = body.hi\n  children.push(body)\n  Ok(node(\"expression/lambda\", open.lo, hi, field, index, [], children))\n}\n\nfunction parseArray(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let open = expect(parser, \"left-bracket\", \"`[`\")?\n  let mut elements: Array<SyntaxNode> = []\n  let mut elementIndex = 0\n  while !at(parser, \"right-bracket\") && !at(parser, \"eof\") {\n    if eat(parser, \"ellipsis\") {\n      let value = parseNestedExpression(service, parser, \"value\", 0)?\n      elements.push(node(\n        \"array-element/spread\",\n        value.lo,\n        value.hi,\n        \"elements\",\n        elementIndex,\n        [],\n        [value],\n      ))\n    } else {\n      elements.push(parseNestedExpression(service, parser, \"elements\", elementIndex)?)\n    }\n    elementIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expect(parser, \"right-bracket\", \"`]`\")?\n  Ok(node(\n    \"expression/array\",\n    open.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    elements,\n  ))\n}\n\nfunction parseFieldInitializers(\n  service: ParserService,\n  parser: Parser,\n  rejectRecordSpread: bool,\n) -> Result<Array<SyntaxNode>, string> {\n  let mut fields: Array<SyntaxNode> = []\n  let mut fieldIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    if rejectRecordSpread && at(parser, \"ellipsis\") {\n      let spread = current(parser)\n      addDiagnostic(\n        parser,\n        \"TPZ2001\",\n        \"a record spread `...` must be the FIRST element and appear at most once\",\n        spread.lo,\n        spread.hi,\n      )\n      recoverToMatchingRightBrace(parser)\n      break\n    }\n    let name = fieldName(parser, \"a field name\")?\n    expect(parser, \"colon\", \"`:`\")?\n    let value = parseNestedExpression(service, parser, \"value\", 0)?\n    fields.push(node(\n      \"field-initializer\",\n      name.lo,\n      value.hi,\n      \"fields\",\n      fieldIndex,\n      [],\n      [identNode(name, \"name\", 0), value],\n    ))\n    fieldIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  Ok(fields)\n}\n\nfunction parseRecordLiteral(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let open = expectLeftBrace(parser)?\n  let children = parseFieldInitializers(service, parser, false)?\n  let close = expectRightBrace(parser)?\n  Ok(node(\n    \"expression/record-literal\",\n    open.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseRecordUpdate(\n  service: ParserService,\n  parser: Parser,\n  base: SyntaxNode,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  expectLeftBrace(parser)?\n  let mut children: Array<SyntaxNode> = [attach(base, \"base\", 0)]\n  if eat(parser, \"ellipsis\") {\n    children.push(parseNestedExpression(service, parser, \"spread\", 0)?)\n    if !at(parser, \"right-brace\") && !eat(parser, \"comma\") {\n      let token = current(parser)\n      addDiagnostic(parser, \"TPZ2001\", \"expected `,` or `\\}`\", token.lo, token.hi)\n      recoverToMatchingRightBrace(parser)\n    }\n  }\n  for found in parseFieldInitializers(service, parser, true)? {\n    children.push(found)\n  }\n  let close = expectRightBrace(parser)?\n  Ok(node(\n    \"expression/record-update\",\n    base.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseComprehensionClauses(\n  service: ParserService,\n  parser: Parser,\n) -> Result<Array<SyntaxNode>, string> {\n  let mut clauses: Array<SyntaxNode> = []\n  let mut clauseIndex = 0\n  while true {\n    if eat(parser, \"keyword/for\") {\n      let pattern = parsePattern(service, parser, \"pattern\", 0)?\n      expect(parser, \"keyword/in\", \"`in`\")?\n      let iterator = parseExpressionWithoutNakedLambda(service, parser, \"iterator\", 0)?\n      clauses.push(node(\n        \"comprehension-clause/for\",\n        pattern.lo,\n        iterator.hi,\n        \"clauses\",\n        clauseIndex,\n        [],\n        [pattern, iterator],\n      ))\n      clauseIndex += 1\n      continue\n    }\n    if eat(parser, \"keyword/if\") {\n      let condition = parseExpressionWithoutNakedLambda(service, parser, \"condition\", 0)?\n      clauses.push(node(\n        \"comprehension-clause/if\",\n        condition.lo,\n        condition.hi,\n        \"clauses\",\n        clauseIndex,\n        [],\n        [condition],\n      ))\n      clauseIndex += 1\n      continue\n    }\n    break\n  }\n  expect(parser, \"fat-arrow\", \"`=>` to introduce the comprehension body\")?\n  Ok(clauses)\n}\n\nfunction parseArrayComprehension(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let open = expect(parser, \"left-bracket\", \"`[`\")?\n  let mut children = parseComprehensionClauses(service, parser)?\n  children.push(parseNestedExpression(service, parser, \"body\", 0)?)\n  let close = expect(parser, \"right-bracket\", \"`]`\")?\n  Ok(node(\n    \"expression/comprehension\",\n    open.lo,\n    close.hi,\n    field,\n    index,\n    [stringAttribute(\"collection\", \"array\")],\n    children,\n  ))\n}\n\nfunction parseSetComprehension(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`set`\")?\n  expectLeftBrace(parser)?\n  let mut children = parseComprehensionClauses(service, parser)?\n  children.push(parseNestedExpression(service, parser, \"body\", 0)?)\n  let close = expectRightBrace(parser)?\n  Ok(node(\n    \"expression/comprehension\",\n    head.lo,\n    close.hi,\n    field,\n    index,\n    [stringAttribute(\"collection\", \"set\")],\n    children,\n  ))\n}\n\nfunction parseMapComprehension(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`map`\")?\n  expectLeftBrace(parser)?\n  let mut children = parseComprehensionClauses(service, parser)?\n  children.push(parseNestedExpression(service, parser, \"bodyKey\", 0)?)\n  expect(parser, \"colon\", \"`:` (a map comprehension body is `key: value`)\")?\n  children.push(parseNestedExpression(service, parser, \"bodyValue\", 0)?)\n  let close = expectRightBrace(parser)?\n  Ok(node(\n    \"expression/comprehension\",\n    head.lo,\n    close.hi,\n    field,\n    index,\n    [stringAttribute(\"collection\", \"map\")],\n    children,\n  ))\n}\n\nfunction parseSet(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`set`\")?\n  expectLeftBrace(parser)?\n  let mut elements: Array<SyntaxNode> = []\n  let mut elementIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    elements.push(parseNestedExpression(service, parser, \"elements\", elementIndex)?)\n    elementIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expectRightBrace(parser)?\n  Ok(node(\"expression/set\", head.lo, close.hi, field, index, [], elements))\n}\n\nfunction parseMap(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`map`\")?\n  expectLeftBrace(parser)?\n  let mut entries: Array<SyntaxNode> = []\n  let mut entryIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let key = parseNestedExpression(service, parser, \"key\", 0)?\n    expect(parser, \"colon\", \"`:`\")?\n    let value = parseNestedExpression(service, parser, \"value\", 0)?\n    entries.push(node(\n      \"map-entry\",\n      key.lo,\n      value.hi,\n      \"entries\",\n      entryIndex,\n      [],\n      [key, value],\n    ))\n    entryIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expectRightBrace(parser)?\n  Ok(node(\"expression/map\", head.lo, close.hi, field, index, [], entries))\n}\n\nexport function blockExpression(block: SyntaxNode, field: string, index: int) -> SyntaxNode {\n  node(\n    \"expression/block\",\n    block.lo,\n    block.hi,\n    field,\n    index,\n    [],\n    [attach(block, \"block\", 0)],\n  )\n}\n\nfunction parseIfLet(\n  service: ParserService,\n  parser: Parser,\n  keyword: PreviewToken,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  expect(parser, \"keyword/let\", \"`let`\")?\n  let pattern = parsePattern(service, parser, \"pattern\", 0)?\n  expect(parser, \"eq\", \"`=`\")?\n  let scrutinee = parseExpressionBeforeBlock(service, parser, \"scrutinee\", 0)?\n  let thenBlock = invokeParseBlock(service, parser, \"block\", 0)?\n  let thenExpression = blockExpression(thenBlock, \"body\", 0)\n  let mut elseExpression = node(\n    \"expression/unit\",\n    thenBlock.hi,\n    thenBlock.hi,\n    \"body\",\n    0,\n    [],\n    [],\n  )\n  if eat(parser, \"keyword/else\") {\n    elseExpression = if at(parser, \"keyword/if\") {\n      parseIf(service, parser, \"body\", 0)?\n    } else {\n      let block = invokeParseBlock(service, parser, \"block\", 0)?\n      blockExpression(block, \"body\", 0)\n    }\n  }\n  let hi = elseExpression.hi\n  let wholeLo = keyword.lo\n  let firstCase = node(\n    \"match-case\",\n    wholeLo,\n    hi,\n    \"cases\",\n    0,\n    [],\n    [pattern, thenExpression],\n  )\n  let wildcard = node(\"pattern/wildcard\", wholeLo, hi, \"pattern\", 0, [], [])\n  let secondCase = node(\n    \"match-case\",\n    wholeLo,\n    hi,\n    \"cases\",\n    1,\n    [],\n    [wildcard, elseExpression],\n  )\n  Ok(node(\n    \"expression/match\",\n    wholeLo,\n    hi,\n    field,\n    index,\n    [],\n    [scrutinee, firstCase, secondCase],\n  ))\n}\n\nfunction parseIf(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/if\", \"`if`\")?\n  if at(parser, \"keyword/let\") {\n    return parseIfLet(service, parser, keyword, field, index)\n  }\n  let condition = parseExpressionBeforeBlock(service, parser, \"condition\", 0)?\n  let thenBlock = invokeParseBlock(service, parser, \"then\", 0)?\n  let mut children: Array<SyntaxNode> = [condition, thenBlock]\n  let mut hi = thenBlock.hi\n  if eat(parser, \"keyword/else\") {\n    let elseValue = if at(parser, \"keyword/if\") {\n      parseIf(service, parser, \"else\", 0)?\n    } else {\n      let block = invokeParseBlock(service, parser, \"block\", 0)?\n      blockExpression(block, \"else\", 0)\n    }\n    hi = elseValue.hi\n    children.push(elseValue)\n  }\n  Ok(node(\"expression/if\", keyword.lo, hi, field, index, [], children))\n}\n\nfunction parseFor(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/for\", \"`for`\")?\n  let pattern = parsePattern(service, parser, \"pattern\", 0)?\n  expect(parser, \"keyword/in\", \"`in`\")?\n  let iterator = parseExpressionBeforeBlock(service, parser, \"iterator\", 0)?\n  let body = invokeParseBlock(service, parser, \"body\", 0)?\n  Ok(node(\n    \"expression/for\",\n    keyword.lo,\n    body.hi,\n    field,\n    index,\n    [],\n    [pattern, iterator, body],\n  ))\n}\n\nexport function labelNode(value: PreviewToken, field: string, index: int) -> SyntaxNode {\n  node(\"identifier\", value.lo + 1, value.hi, field, index, [], [])\n}\n\nfunction parseLoop(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let head = identifier(parser, \"`loop`\")?\n  let mut children: Array<SyntaxNode> = []\n  if at(parser, \"label\") {\n    children.push(labelNode(bump(parser), \"label\", 0))\n  }\n  let body = invokeParseBlock(service, parser, \"body\", 0)?\n  let hi = body.hi\n  children.push(body)\n  Ok(node(\"expression/loop\", head.lo, hi, field, index, [], children))\n}\n\nfunction parseConcurrentTimeout(parser: Parser) -> Result<Option<SyntaxNode>, string> {\n  if !at(parser, \"left-paren\") {\n    return Ok(None)\n  }\n  bump(parser)\n  let key = identifier(parser, \"`timeout`\")?\n  if text(parser, key.lo, key.hi) != \"timeout\" {\n    addDiagnostic(\n      parser,\n      \"TPZ2005\",\n      \"`concurrent` takes only a `timeout:` argument\",\n      key.lo,\n      key.hi,\n    )\n  }\n  if !eat(parser, \"colon\") {\n    let token = current(parser)\n    addDiagnostic(parser, \"TPZ2001\", \"expected `:` after `timeout`\", token.lo, token.hi)\n  }\n  let duration = current(parser)\n  let mut durationHi = duration.hi\n  let mut unit = \"s\"\n  let mut valueAttribute = nullAttribute(\"valueDecimal\")\n  if duration.kind.startsWith(\"duration/\") {\n    unit = duration.kind.replace(\"duration/\", \"\")\n    let spelling = text(parser, duration.lo, duration.hi)\n    let magnitude = spelling.replace(unit, \"\")\n    if !validIntegerLiteral(magnitude) || (parser.languageMode != \"topaz-5.21\" && magnitude.contains(\"_\")) { fail(parser,\"malformed numeric literal\")? }\n    bump(parser)\n    valueAttribute = stringAttribute(\"valueDecimal\", magnitude.replace(\"_\", \"\"))\n  } else {\n    addDiagnostic(\n      parser,\n      \"TPZ2001\",\n      \"expected a duration literal, e.g. `3s`\",\n      duration.lo,\n      duration.hi,\n    )\n    recoverToMatchingRightParen(parser, false)\n    let recoveredHi = boxValue(parser.lastHi)\n    if recoveredHi > durationHi {\n      durationHi = recoveredHi\n    }\n  }\n  let value = node(\n    \"expression/duration\",\n    duration.lo,\n    durationHi,\n    \"timeout\",\n    0,\n    [\n      stringAttribute(\"unit\", unit),\n      valueAttribute,\n    ],\n    [],\n  )\n  expect(parser, \"right-paren\", \"`)`\")?\n  Ok(Some(value))\n}\n\nfunction parseConcurrentArm(\n  service: ParserService,\n  parser: Parser,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let name = identifier(parser, \"an arm name\")?\n  expect(parser, \"colon\", \"`:`\")?\n  let value = parseNestedExpression(service, parser, \"value\", 0)?\n  Ok(node(\n    \"concurrent-arm\",\n    name.lo,\n    value.hi,\n    \"arms\",\n    index,\n    [],\n    [identNode(name, \"name\", 0), value],\n  ))\n}\n\nfunction parseConcurrentArms(\n  service: ParserService,\n  parser: Parser,\n  keyword: PreviewToken,\n) -> Result<Array<SyntaxNode>, string> {\n  expectLeftBrace(parser)?\n  let mut arms: Array<SyntaxNode> = []\n  skipSeparators(parser)\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let before = boxValue(parser.position)\n    match parseConcurrentArm(service, parser, arms.length) {\n      case Ok(arm) => {\n        arms.push(arm)\n        itemBoundary(parser)\n      }\n      case Err(_) => synchronize(parser)\n    }\n    if boxValue(parser.position) == before &&\n      !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n      addDiagnostic(\n        parser,\n        \"TPZ2001\",\n        \"expected a concurrent arm\",\n        current(parser).lo,\n        current(parser).hi,\n      )\n      bump(parser)\n    }\n    skipSeparators(parser)\n  }\n  expectRightBrace(parser)?\n  if arms.length == 0 {\n    addDiagnostic(\n      parser,\n      \"TPZ2001\",\n      \"`concurrent` requires at least one arm\",\n      keyword.lo,\n      boxValue(parser.lastHi),\n    )\n  }\n  Ok(arms)\n}\n\nfunction parseConcurrentElse(\n  service: ParserService,\n  parser: Parser,\n  keyword: PreviewToken,\n  hasTimeout: bool,\n) -> Result<Option<SyntaxNode>, string> {\n  let elseToken = current(parser)\n  if eat(parser, \"keyword/else\") {\n    if !hasTimeout {\n      addDiagnostic(\n        parser,\n        \"TPZ2005\",\n        \"`else` requires the `concurrent(timeout: ...)` form\",\n        elseToken.lo,\n        elseToken.hi,\n      )\n    }\n    return Ok(Some(invokeParseBlock(service, parser, \"else\", 0)?))\n  }\n  if hasTimeout {\n    addDiagnostic(\n      parser,\n      \"TPZ2005\",\n      \"the `concurrent(timeout: ...)` form requires an `else` block\",\n      keyword.lo,\n      boxValue(parser.lastHi),\n    )\n  }\n  Ok(None)\n}\n\nfunction parseConcurrent(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/concurrent\", \"`concurrent`\")?\n  let mut children: Array<SyntaxNode> = []\n  let timeout = parseConcurrentTimeout(parser)?\n  let mut hasTimeout = false\n  match timeout {\n    case Some(value) => {\n      hasTimeout = true\n      children.push(value)\n    }\n    case None => ()\n  }\n  for arm in parseConcurrentArms(service, parser, keyword)? {\n    children.push(arm)\n  }\n  match parseConcurrentElse(service, parser, keyword, hasTimeout)? {\n    case Some(value) => children.push(value)\n    case None => ()\n  }\n  Ok(node(\n    \"expression/concurrent\",\n    keyword.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseMatchCase(\n  service: ParserService,\n  parser: Parser,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/case\", \"`case`\")?\n  let pattern = parsePattern(service, parser, \"pattern\", 0)?\n  let mut children: Array<SyntaxNode> = [pattern]\n  if eat(parser, \"keyword/if\") {\n    children.push(parseExpressionWithoutNakedLambda(service, parser, \"guard\", 0)?)\n  }\n  expect(parser, \"fat-arrow\", \"`=>`\")?\n  let hi = if at(parser, \"keyword/return\") {\n    let returnToken = bump(parser)\n    let mut returnChildren: Array<SyntaxNode> = []\n    if !at(parser, \"separator\") && !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n      returnChildren.push(parseNestedExpression(service, parser, \"value\", 0)?)\n    }\n    let returnHi = boxValue(parser.lastHi)\n    children.push(node(\n      \"match-case-return\",\n      returnToken.lo,\n      returnHi,\n      \"body\",\n      0,\n      [],\n      returnChildren,\n    ))\n    returnHi\n  } else {\n    let body = parseNestedExpression(service, parser, \"body\", 0)?\n    let bodyHi = body.hi\n    children.push(body)\n    bodyHi\n  }\n  Ok(node(\"match-case\", keyword.lo, hi, \"cases\", index, [], children))\n}\n\nfunction parseMatch(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let keyword = expect(parser, \"keyword/match\", \"`match`\")?\n  let scrutinee = parseExpressionBeforeBlock(service, parser, \"scrutinee\", 0)?\n  let open = expectLeftBrace(parser)?\n  let mut children: Array<SyntaxNode> = [scrutinee]\n  let mut caseIndex = 0\n  skipSeparators(parser)\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let before = boxValue(parser.position)\n    match parseMatchCase(service, parser, caseIndex) {\n      case Ok(found) => {\n        children.push(found)\n        caseIndex += 1\n        itemBoundary(parser)\n      }\n      case Err(_) => synchronize(parser)\n    }\n    if boxValue(parser.position) == before &&\n      !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n      addDiagnostic(\n        parser,\n        \"TPZ2001\",\n        \"expected `case`\",\n        current(parser).lo,\n        current(parser).hi,\n      )\n      bump(parser)\n    }\n    skipSeparators(parser)\n  }\n  let close = expectRightBrace(parser)?\n  if caseIndex == 0 {\n    addDiagnostic(\n      parser,\n      \"TPZ2001\",\n      \"`match` requires at least one `case`\",\n      open.lo,\n      close.hi,\n    )\n  }\n  Ok(node(\n    \"expression/match\",\n    keyword.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseIdentifierAtom(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let value = current(parser)\n  if tokenAt(parser, 1).kind == \"fat-arrow\" && lambdaAllowed(parser) {\n    return parseSingleLambda(service, parser, field, index)\n  }\n  let name = text(parser, value.lo, value.hi)\n  if name == \"set\" && tokenAt(parser, 1).kind == \"left-brace\" {\n    if tokenAt(parser, 2).kind == \"keyword/for\" {\n      return parseSetComprehension(service, parser, field, index)\n    }\n    return parseSet(service, parser, field, index)\n  }\n  if name == \"map\" && tokenAt(parser, 1).kind == \"left-brace\" {\n    if tokenAt(parser, 2).kind == \"keyword/for\" {\n      return parseMapComprehension(service, parser, field, index)\n    }\n    return parseMap(service, parser, field, index)\n  }\n  if name == \"loop\" &&\n    (tokenAt(parser, 1).kind == \"left-brace\" ||\n      (tokenAt(parser, 1).kind == \"label\" && tokenAt(parser, 2).kind == \"left-brace\")) {\n    return parseLoop(service, parser, field, index)\n  }\n  bump(parser)\n  Ok(node(\"expression/identifier\", value.lo, value.hi, field, index, [], []))\n}\n\nfunction parseParenthesizedExpression(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let openPosition = boxValue(parser.position)\n  let open = bump(parser)\n  if eat(parser, \"right-paren\") {\n    return Ok(node(\n      \"expression/unit\",\n      open.lo,\n      boxValue(parser.lastHi),\n      field,\n      index,\n      [],\n      [],\n    ))\n  }\n  let inner = parseNestedExpression(service, parser, \"operand\", 0)?\n  if at(parser, \"comma\") {\n    let comma = current(parser)\n    let mut diagnostics = parser.diagnostics\n    diagnostics.push(diagnosticWithNotes(\n      \"TPZ2001\",\n      \"parentheses group a single expression; `(a, b)` comma lists are not Topaz syntax\",\n      comma.lo,\n      comma.hi,\n      if looksLikeExplicitTypeArgumentsBefore(parser, openPosition) {\n        [\"Topaz infers type arguments — drop the explicit `<…>`, e.g. `Array.of(…)`\"]\n      } else {\n        []\n      },\n    ))\n    recoverToMatchingRightParen(parser, true)\n    return Ok(node(\n      \"expression/parenthesized\",\n      open.lo,\n      boxValue(parser.lastHi),\n      field,\n      index,\n      [],\n      [inner],\n    ))\n  }\n  let close = expect(parser, \"right-paren\", \"`)`\")?\n  Ok(node(\n    \"expression/parenthesized\",\n    open.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    [inner],\n  ))\n}\n\nfunction looksLikeExplicitTypeArgumentsBefore(parser: Parser, leftParenPosition: int) -> bool {\n  if leftParenPosition == 0 || layoutTokenAt(parser, leftParenPosition - 1).kind != \"gt\" {\n    return false\n  }\n  let mut position = leftParenPosition - 1\n  let mut depth = 0\n  while true {\n    let kind = layoutTokenAt(parser, position).kind\n    if kind == \"gt\" {\n      depth += 1\n    } else if kind == \"lt\" {\n      depth -= 1\n      if depth == 0 {\n        break\n      }\n    } else if kind != \"identifier\" && kind != \"comma\" {\n      return false\n    }\n    if position == 0 {\n      return false\n    }\n    position -= 1\n  }\n  position > 0 && layoutTokenAt(parser, position - 1).kind == \"identifier\"\n}\n\nfunction recoverToMatchingRightParen(parser: Parser, consumeClose: bool) -> () {\n  let mut depth = 0\n  while !at(parser, \"eof\") {\n    let kind = current(parser).kind\n    if kind == \"left-paren\" || kind == \"left-bracket\" || kind == \"left-brace\" {\n      depth += 1\n    } else if kind == \"right-paren\" || kind == \"right-bracket\" || kind == \"right-brace\" {\n      if depth == 0 {\n        if consumeClose && kind == \"right-paren\" {\n          bump(parser)\n        }\n        return ()\n      }\n      depth -= 1\n    }\n    bump(parser)\n  }\n  ()\n}\n\nfunction recoverToMatchingRightBrace(parser: Parser) -> () {\n  let mut depth = 0\n  while !at(parser, \"eof\") {\n    let kind = current(parser).kind\n    if kind == \"left-paren\" || kind == \"left-bracket\" || kind == \"left-brace\" {\n      depth += 1\n    } else if kind == \"right-paren\" || kind == \"right-bracket\" || kind == \"right-brace\" {\n      if depth == 0 {\n        return ()\n      }\n      depth -= 1\n    }\n    bump(parser)\n  }\n  ()\n}\n\nfunction parseCollectionAtom(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let value = current(parser)\n  if value.kind == \"left-bracket\" {\n    if tokenAt(parser, 1).kind == \"keyword/for\" {\n      return parseArrayComprehension(service, parser, field, index)\n    }\n    return parseArray(service, parser, field, index)\n  }\n  if value.kind == \"left-brace\" &&\n    isFieldNameKind(tokenAt(parser, 1).kind) &&\n    tokenAt(parser, 2).kind == \"colon\" {\n    return parseRecordLiteral(service, parser, field, index)\n  }\n  if value.kind == \"left-brace\" {\n    let block = invokeParseBlock(service, parser, \"block\", 0)?\n    return Ok(node(\n      \"expression/block\",\n      block.lo,\n      block.hi,\n      field,\n      index,\n      [],\n      [block],\n    ))\n  }\n  fail(parser, \"expected a collection or block expression\")?\n  Err(\"expected a collection or block expression\")\n}\n\nfunction parseLiteralAtom(\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let value = current(parser)\n  if value.kind == \"integer\" || value.kind == \"float\" { validateNumericLiteral(parser, value)? }\n  bump(parser)\n  if value.kind == \"integer\" {\n    return Ok(node(\n      \"expression/integer\",\n      value.lo,\n      value.hi,\n      field,\n      index,\n      [stringAttribute(\"valueDecimal\", match integerMagnitude(text(parser, value.lo, value.hi)) { case Some(n) => n.toString(10); case None => \"\" })],\n      [],\n    ))\n  }\n  if value.kind == \"float\" {\n    let bits = floatLiteralBits(text(parser, value.lo, value.hi))\n    return Ok(node(\n      \"expression/float\",\n      value.lo,\n      value.hi,\n      field,\n      index,\n      [if bits != \"\" && bits != \"7ff0000000000000\" { stringAttribute(\"floatBits\", bits) } else { nullAttribute(\"floatBits\") }],\n      [],\n    ))\n  }\n  if value.kind == \"keyword/true\" || value.kind == \"keyword/false\" {\n    return Ok(node(\n      \"expression/boolean\",\n      value.lo,\n      value.hi,\n      field,\n      index,\n      [boolAttribute(\"value\", value.kind == \"keyword/true\")],\n      [],\n    ))\n  }\n  Ok(node(\"expression/null\", value.lo, value.hi, field, index, [], []))\n}\n\nfunction parseAtom(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let value = current(parser)\n  if value.kind.startsWith(\"length/\") {\n    if parser.languageMode != \"topaz-5.21\" { fail(parser,\"Length literals require language mode 5.21\")? }\n    let spelling = text(parser,value.lo,value.hi)\n    if !validLiteral(spelling) { fail(parser,\"malformed Length literal\")? }\n    bump(parser)\n    return Ok(node(\"expression/length\",value.lo,value.hi,field,index,[stringAttribute(\"unit\",value.kind.replace(\"length/\",\"\")),stringAttribute(\"spelling\",spelling)],[]))\n  }\n  if value.kind == \"integer\" || value.kind == \"float\" ||\n    value.kind == \"keyword/true\" || value.kind == \"keyword/false\" ||\n    value.kind == \"keyword/null\" {\n    return parseLiteralAtom(parser, field, index)\n  }\n  if value.kind.startsWith(\"duration/\") {\n    fail(parser, \"a duration literal is valid only in `concurrent(timeout: ...)`\")?\n  }\n  if value.kind == \"identifier\" {\n    return parseIdentifierAtom(service, parser, field, index)\n  }\n  if value.kind == \"underscore\" {\n    bump(parser)\n    return Ok(node(\n      \"expression/placeholder\",\n      value.lo,\n      value.hi,\n      field,\n      index,\n      [],\n      [],\n    ))\n  }\n  if value.kind.startsWith(\"string-start/\") {\n    return parseString(service, parser, field, index)\n  }\n  if value.kind == \"left-paren\" && lambdaAllowed(parser) &&\n    matchingParenFollowedBy(parser, \"fat-arrow\") {\n    return parseParenLambda(service, parser, field, index)\n  }\n  if value.kind == \"left-paren\" {\n    return parseParenthesizedExpression(service, parser, field, index)\n  }\n  if value.kind == \"left-bracket\" || value.kind == \"left-brace\" {\n    return parseCollectionAtom(service, parser, field, index)\n  }\n  if value.kind == \"keyword/if\" {\n    return parseIf(service, parser, field, index)\n  }\n  if value.kind == \"keyword/match\" {\n    return parseMatch(service, parser, field, index)\n  }\n  if value.kind == \"keyword/for\" {\n    return parseFor(service, parser, field, index)\n  }\n  if value.kind == \"keyword/concurrent\" {\n    return parseConcurrent(service, parser, field, index)\n  }\n  fail(parser, \"expected an expression\")?\n  Err(\"expected an expression\")\n}\n\nfunction parseCallPostfix(\n  service: ParserService,\n  parser: Parser,\n  callee: SyntaxNode,\n  field: string,\n  index: int,\n  withTypeArguments: bool,\n) -> Result<SyntaxNode, string> {\n  let typeArguments = if withTypeArguments {\n    parseTypeArguments(service, parser)?\n  } else {\n    []\n  }\n  let arguments = parseCallArguments(service, parser)?\n  let mut children: Array<SyntaxNode> = [attach(callee, \"callee\", 0)]\n  for argument in arguments {\n    children.push(argument)\n  }\n  let mut typeIndex = 0\n  for typeArgument in typeArguments {\n    children.push(attach(typeArgument, \"typeArguments\", typeIndex))\n    typeIndex += 1\n  }\n  Ok(node(\n    \"expression/call\",\n    callee.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseIndexPostfix(\n  service: ParserService,\n  parser: Parser,\n  object: SyntaxNode,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  bump(parser)\n  let found = parseNestedExpression(service, parser, \"index\", 0)?\n  let close = expect(parser, \"right-bracket\", \"`]`\")?\n  Ok(node(\n    \"expression/index\",\n    object.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    [attach(object, \"object\", 0), found],\n  ))\n}\n\nfunction parseMemberPostfix(\n  parser: Parser,\n  object: SyntaxNode,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let optional = at(parser, \"question-dot\")\n  bump(parser)\n  let name = fieldName(parser, \"a member name\")?\n  Ok(node(\n    if optional { \"expression/optional-access\" } else { \"expression/member\" },\n    object.lo,\n    name.hi,\n    field,\n    index,\n    [],\n    [attach(object, \"object\", 0), identNode(name, \"field\", 0)],\n  ))\n}\n\nfunction tryPostfix(\n  parser: Parser,\n  operand: SyntaxNode,\n  field: string,\n  index: int,\n) -> SyntaxNode {\n  bump(parser)\n  node(\n    \"expression/try\",\n    operand.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    [attach(operand, \"operand\", 0)],\n  )\n}\n\nfunction startsRecordUpdate(parser: Parser, base: SyntaxNode) -> bool {\n  if !recordUpdateAllowed(parser) || !at(parser, \"left-brace\") {\n    return false\n  }\n  if isFieldNameKind(tokenAt(parser, 1).kind) && tokenAt(parser, 2).kind == \"colon\" {\n    return true\n  }\n  base.kind == \"expression/identifier\" &&\n    (tokenAt(parser, 1).kind == \"ellipsis\" || tokenAt(parser, 1).kind == \"right-brace\")\n}\n\nfunction parsePostfix(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let mut value = parseAtom(service, parser, field, index)?\n  while true {\n    if at(parser, \"left-paren\") {\n      value = parseCallPostfix(service, parser, value, field, index, false)?\n    } else if at(parser, \"lt\") &&\n      (value.kind == \"expression/identifier\" ||\n        value.kind == \"expression/member\" ||\n        value.kind == \"expression/optional-access\") &&\n      looksLikeCallTypeArguments(parser) {\n      value = parseCallPostfix(service, parser, value, field, index, true)?\n    } else if at(parser, \"left-bracket\") {\n      value = parseIndexPostfix(service, parser, value, field, index)?\n    } else if at(parser, \"dot\") || at(parser, \"question-dot\") {\n      value = parseMemberPostfix(parser, value, field, index)?\n    } else if at(parser, \"question\") {\n      value = tryPostfix(parser, value, field, index)\n    } else if startsRecordUpdate(parser, value) {\n      value = parseRecordUpdate(service, parser, value, field, index)?\n    } else {\n      break\n    }\n  }\n  Ok(value)\n}\n\nfunction parseUnary(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let value = current(parser)\n  if value.kind == \"plus\" || value.kind == \"minus\" || value.kind == \"bang\" {\n    bump(parser)\n    let operand = parseUnary(service, parser, \"operand\", 0)?\n    let operator = match value.kind {\n      case \"plus\" => \"plus\"\n      case \"minus\" => \"minus\"\n      case _ => \"not\"\n    }\n    return Ok(node(\n      \"expression/unary\",\n      value.lo,\n      operand.hi,\n      field,\n      index,\n      [stringAttribute(\"operator\", operator)],\n      [operand],\n    ))\n  }\n  if value.kind == \"tilde\" {\n    let mut diagnostics = parser.diagnostics\n    diagnostics.push(diagnostic(\n      \"TPZ2013\",\n      \"reserved operator `~`: Topaz has no bitwise operations\",\n      value.lo,\n      value.hi,\n    ))\n    bump(parser)\n    return parseUnary(service, parser, field, index)\n  }\n  let mut lhs = parsePostfix(service, parser, field, index)?\n  if eat(parser, \"star-star\") {\n    let rhs = parseUnary(service, parser, \"right\", 0)?\n    lhs = node(\n      \"expression/binary\",\n      lhs.lo,\n      rhs.hi,\n      field,\n      index,\n      [stringAttribute(\"operator\", \"power\")],\n      [attach(lhs, \"left\", 0), rhs],\n    )\n  }\n  Ok(lhs)\n}\n\nfunction parsePipeInfix(\n  service: ParserService,\n  parser: Parser,\n  lhs: SyntaxNode,\n  precedence: int,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  if eat(parser, \"dot\") {\n    let name = identifier(parser, \"a field name\")?\n    return Ok(node(\n      \"expression/pipe\",\n      lhs.lo,\n      name.hi,\n      field,\n      index,\n      [],\n      [attach(lhs, \"left\", 0), identNode(name, \"field\", 0)],\n    ))\n  }\n  let rhs = parseExpressionBp(service, parser, precedence + 1, \"right\", 0)?\n  Ok(node(\n    \"expression/pipe\",\n    lhs.lo,\n    rhs.hi,\n    field,\n    index,\n    [],\n    [attach(lhs, \"left\", 0), rhs],\n  ))\n}\n\nfunction parseComposeInfix(\n  service: ParserService,\n  parser: Parser,\n  lhs: SyntaxNode,\n  precedence: int,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let rhs = parseExpressionBp(service, parser, precedence, \"right\", 0)?\n  Ok(node(\n    \"expression/compose\",\n    lhs.lo,\n    rhs.hi,\n    field,\n    index,\n    [],\n    [attach(lhs, \"left\", 0), rhs],\n  ))\n}\n\nfunction parseRangeInfix(\n  service: ParserService,\n  parser: Parser,\n  lhs: SyntaxNode,\n  precedence: int,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let operator = layoutTokenAt(parser, boxValue(parser.position) - 1)\n  let kind = current(parser).kind\n  let missingEndpoint = kind == \"separator\" || kind == \"eof\" ||\n    kind == \"right-paren\" || kind == \"right-brace\" || kind == \"right-bracket\" ||\n    kind == \"comma\" || kind == \"fat-arrow\" ||\n    (kind.startsWith(\"keyword/\") && kind != \"keyword/if\" && kind != \"keyword/match\" &&\n      kind != \"keyword/for\" && kind != \"keyword/concurrent\" &&\n      kind != \"keyword/true\" && kind != \"keyword/false\" && kind != \"keyword/null\")\n  let rhs = if missingEndpoint {\n    addDiagnostic(\n      parser,\n      \"TPZ2001\",\n      \"expected a range endpoint after `..`, e.g. `1..5`\",\n      operator.lo,\n      operator.hi,\n    )\n    attach(lhs, \"high\", 0)\n  } else {\n    parseExpressionBp(service, parser, precedence + 1, \"high\", 0)?\n  }\n  let mut children: Array<SyntaxNode> = [attach(lhs, \"low\", 0), rhs]\n  if eat(parser, \"keyword/by\") {\n    children.push(parseExpressionBp(service, parser, precedence + 1, \"step\", 0)?)\n  }\n  let hi = if missingEndpoint && children.length == 2 {\n    operator.hi\n  } else {\n    match children.get(children.length - 1) {\n      case Some(last) => last.hi\n      case None => rhs.hi\n    }\n  }\n  Ok(node(\n    \"expression/range\",\n    lhs.lo,\n    hi,\n    field,\n    index,\n    [boolAttribute(\"inclusive\", operator.kind == \"dot-dot\")],\n    children,\n  ))\n}\n\nfunction parseBinaryInfix(\n  service: ParserService,\n  parser: Parser,\n  lhs: SyntaxNode,\n  operator: string,\n  precedence: int,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let rhs = parseExpressionBp(service, parser, precedence + 1, \"right\", 0)?\n  Ok(node(\n    \"expression/binary\",\n    lhs.lo,\n    rhs.hi,\n    field,\n    index,\n    [stringAttribute(\"operator\", binaryName(operator))],\n    [attach(lhs, \"left\", 0), rhs],\n  ))\n}\n\nexport function parseExpressionBp(\n  service: ParserService,\n  parser: Parser,\n  minimum: int,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let mut lhs = parseUnary(service, parser, field, index)?\n  while true {\n    let operator = current(parser).kind\n    let precedence = binaryPrecedence(operator)\n    if precedence < minimum || precedence == 0 {\n      break\n    }\n    bump(parser)\n    if operator == \"pipe-gt\" {\n      lhs = parsePipeInfix(service, parser, lhs, precedence, field, index)?\n    } else if operator == \"gt-gt\" {\n      lhs = parseComposeInfix(service, parser, lhs, precedence, field, index)?\n    } else if operator == \"dot-dot\" || operator == \"dot-dot-lt\" {\n      lhs = parseRangeInfix(service, parser, lhs, precedence, field, index)?\n    } else {\n      lhs = parseBinaryInfix(service, parser, lhs, operator, precedence, field, index)?\n    }\n  }\n  Ok(lhs)\n}\n\nexport function parseExpression(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  parseExpressionBp(service, parser, 1, field, index)\n}\n\nfunction parseNestedExpression(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let previousLambda = lambdaAllowed(parser)\n  setLambdaAllowed(parser, true)\n  let result = parseRecordNestedExpression(service, parser, field, index)\n  setLambdaAllowed(parser, previousLambda)\n  result\n}\n\nfunction parseRecordNestedExpression(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let previous = recordUpdateAllowed(parser)\n  setRecordUpdateAllowed(parser, true)\n  let result = parseExpression(service, parser, field, index)\n  setRecordUpdateAllowed(parser, previous)\n  result\n}\n\nfunction parseExpressionWithoutNakedLambda(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let previous = lambdaAllowed(parser)\n  setLambdaAllowed(parser, false)\n  let result = parseRecordNestedExpression(service, parser, field, index)\n  setLambdaAllowed(parser, previous)\n  result\n}\n\nexport function parseExpressionBeforeBlock(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let previous = recordUpdateAllowed(parser)\n  setRecordUpdateAllowed(parser, false)\n  let result = parseExpression(service, parser, field, index)\n  setRecordUpdateAllowed(parser, previous)\n  result\n}\n",
      "sourceSha256": "1c6d84f2b9361c3fd8d12dd8f173005be70d5b0bea264b910f5c47c35e7e7660"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/parser/types_patterns.tpz",
      "language": "topaz",
      "bytes": 16732,
      "sha256": "5e836a97ae90bc3ad8b2256809ab7b530a7eaf027d168f6eae763bf6644ca047",
      "content": "import literal { literalAttribute }\n// Type-expression and binding-pattern grammar for the self-host parser.\n// It shares cursor and node helpers with parser.core and returns syntax trees to\n// declaration and expression leaves without owning parse-result flattening.\n\nimport types { PreviewToken, SyntaxNode }\nimport parser.core {\n  Parser,\n  ParserService,\n  addDiagnostic,\n  at,\n  attach,\n  boolAttribute,\n  boxValue,\n  bump,\n  current,\n  diagnostic,\n  eat,\n  expect,\n  expectLeftBrace,\n  expectRightBrace,\n  fail,\n  fieldName,\n  identNode,\n  identifier,\n  invokeParseExpressionBp,\n  matchingParenFollowedBy,\n  node,\n  parseString,\n  validateNumericLiteral,\n  rejectReservedBinding,\n  setBox,\n  stringAttribute,\n  text,\n  tokenAt,\n}\n\nexport function bindingPattern(value: PreviewToken, field: string, index: int) -> SyntaxNode {\n  node(\n    \"pattern/binding\",\n    value.lo,\n    value.hi,\n    field,\n    index,\n    [],\n    [identNode(value, \"name\", 0)],\n  )\n}\n\nexport function namedType(value: PreviewToken, field: string, index: int) -> SyntaxNode {\n  node(\n    \"type/named\",\n    value.lo,\n    value.hi,\n    field,\n    index,\n    [],\n    [identNode(value, \"name\", 0)],\n  )\n}\n\nexport function expectCloseAngle(parser: Parser) -> Result<int, string> {\n  if at(parser, \"gt\") {\n    return Ok(bump(parser).hi)\n  }\n  if at(parser, \"gt-gt\") {\n    let token = bump(parser)\n    let mut pending = parser.pendingGt\n    pending.push(token.hi)\n    setBox(parser.lastHi, token.lo + 1)\n    return Ok(token.lo + 1)\n  }\n  fail(parser, \"expected `>`\")?\n  Err(\"expected `>`\")\n}\n\nexport function parseTypeArguments(\n  service: ParserService,\n  parser: Parser,\n) -> Result<Array<SyntaxNode>, string> {\n  expect(parser, \"lt\", \"`<`\")?\n  let mut arguments: Array<SyntaxNode> = [\n    parseType(service, parser, \"arguments\", 0)?,\n  ]\n  let mut index = 1\n  while eat(parser, \"comma\") {\n    arguments.push(parseType(\n      service,\n\n      parser,\n      \"arguments\",\n      index,\n    )?)\n    index += 1\n  }\n  expectCloseAngle(parser)?\n  Ok(arguments)\n}\n\nfunction parseNamedType(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let namespace = bump(parser)\n  if eat(parser, \"dot\") {\n    let name = identifier(parser, \"an exported type name\")?\n    let mut children: Array<SyntaxNode> = [\n      identNode(namespace, \"namespace\", 0),\n      identNode(name, \"name\", 0),\n    ]\n    if at(parser, \"lt\") {\n      for argument in parseTypeArguments(service, parser)? {\n        children.push(argument)\n      }\n    }\n    return Ok(node(\n      \"type/qualified\",\n      namespace.lo,\n      boxValue(parser.lastHi),\n      field,\n      index,\n      [],\n      children,\n    ))\n  }\n  let mut children: Array<SyntaxNode> = [identNode(namespace, \"name\", 0)]\n  if at(parser, \"lt\") {\n    for argument in parseTypeArguments(service, parser)? {\n      children.push(argument)\n    }\n  }\n  Ok(node(\n    \"type/named\",\n    namespace.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseRecordType(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let open = bump(parser)\n  let mut fields: Array<SyntaxNode> = []\n  let mut fieldIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let name = fieldName(parser, \"a field name\")?\n    expect(parser, \"colon\", \"`:`\")?\n    let typeNode = parseType(service, parser, \"type\", 0)?\n    fields.push(node(\n      \"record-type-field\",\n      name.lo,\n      typeNode.hi,\n      \"fields\",\n      fieldIndex,\n      [],\n      [identNode(name, \"name\", 0), typeNode],\n    ))\n    fieldIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expectRightBrace(parser)?\n  if fields.length == 0 {\n    addDiagnostic(\n      parser,\n      \"TPZ2001\",\n      \"a record type requires at least one field\",\n      open.lo,\n      close.hi,\n    )\n  }\n  Ok(node(\"type/record\", open.lo, close.hi, field, index, [], fields))\n}\n\nfunction parseFunctionType(\n  service: ParserService,\n  parser: Parser,\n  open: PreviewToken,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let mut parameters: Array<SyntaxNode> = []\n  let mut parameterIndex = 0\n  while !at(parser, \"right-paren\") && !at(parser, \"eof\") {\n    let variadic = eat(parser, \"ellipsis\")\n    let typeNode = parseType(service, parser, \"type\", 0)?\n    parameters.push(node(\n      \"function-type-parameter\",\n      typeNode.lo,\n      typeNode.hi,\n      \"parameters\",\n      parameterIndex,\n      [boolAttribute(\"variadic\", variadic)],\n      [typeNode],\n    ))\n    parameterIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  expect(parser, \"right-paren\", \"`)`\")?\n  expect(parser, \"thin-arrow\", \"`->`\")?\n  let returnType = parseType(service, parser, \"returnType\", 0)?\n  let hi = returnType.hi\n  parameters.push(returnType)\n  Ok(node(\"type/function\", open.lo, hi, field, index, [], parameters))\n}\n\nfunction parseParenthesizedType(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let functionType = matchingParenFollowedBy(parser, \"thin-arrow\")\n  let open = bump(parser)\n  if functionType {\n    return parseFunctionType(service, parser, open, field, index)\n  }\n  if eat(parser, \"right-paren\") {\n    return Ok(node(\n      \"type/unit\",\n      open.lo,\n      boxValue(parser.lastHi),\n      field,\n      index,\n      [],\n      [],\n    ))\n  }\n  let inner = parseType(service, parser, field, index)?\n  let close = expect(parser, \"right-paren\", \"`)`\")?\n  Ok(node(\n    inner.kind,\n    open.lo,\n    close.hi,\n    field,\n    index,\n    inner.attributes,\n    inner.children,\n  ))\n}\n\nfunction parsePrimaryType(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let start = current(parser)\n  if start.kind == \"identifier\" {\n    return parseNamedType(service, parser, field, index)\n  }\n  if start.kind == \"left-brace\" {\n    return parseRecordType(service, parser, field, index)\n  }\n  if start.kind == \"left-paren\" {\n    return parseParenthesizedType(service, parser, field, index)\n  }\n  if start.kind == \"integer\" || start.kind == \"float\" ||\n    start.kind == \"keyword/true\" || start.kind == \"keyword/false\" ||\n    start.kind == \"keyword/null\" {\n    if start.kind == \"integer\" || start.kind == \"float\" { validateNumericLiteral(parser, start)? }\n    bump(parser)\n    let kind = if start.kind == \"integer\" || start.kind == \"float\" { start.kind } else if start.kind == \"keyword/null\" { \"null\" } else { \"bool\" }\n    return Ok(node(\"type/literal\", start.lo, start.hi, field, index, [stringAttribute(\"literalKind\",kind),stringAttribute(\"literalSpelling\",text(parser,start.lo,start.hi))], []))\n  }\n  if start.kind.startsWith(\"string-start/\") {\n    let literal = parseString(service, parser, field, index)?\n    for part in literal.children {\n      if part.kind == \"string-part/interpolation\" {\n        addDiagnostic(\n          parser,\n          \"TPZ2001\",\n          \"a literal type cannot contain interpolation\",\n          literal.lo,\n          literal.hi,\n        )\n        break\n      }\n    }\n    let mut cooked = \"\"\n    let mut maps: Array<string> = []\n    for part in literal.children {\n      if part.kind == \"string-part/text\" { cooked = cooked + literalAttribute(part, \"cooked\"); maps.push(literalAttribute(part, \"sourceMap\")) }\n    }\n    let attributes = if literal.kind == \"expression/template\" { [] }\n      else { [stringAttribute(\"cooked\", cooked), stringAttribute(\"sourceMap\", maps.join(\";\"))] }\n    return Ok(node(\"type/literal\", literal.lo, literal.hi, field, index, attributes, []))\n  }\n  fail(parser, \"expected a type\")?\n  Err(\"expected a type\")\n}\n\nexport function parseType(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let first = parsePrimaryType(service, parser, field, index)?\n  if !at(parser, \"pipe\") {\n    return Ok(first)\n  }\n  let mut members: Array<SyntaxNode> = [attach(first, \"members\", 0)]\n  let mut memberIndex = 1\n  while eat(parser, \"pipe\") {\n    members.push(parsePrimaryType(\n      service,\n\n      parser,\n      \"members\",\n      memberIndex,\n    )?)\n    memberIndex += 1\n  }\n  Ok(node(\"type/union\", first.lo, boxValue(parser.lastHi), field, index, [], members))\n}\n\nfunction isLiteralExpressionKind(kind: string) -> bool {\n  kind == \"expression/integer\" ||\n    kind == \"expression/float\" ||\n    kind == \"expression/string\" ||\n    kind == \"expression/boolean\" ||\n    kind == \"expression/null\" ||\n    kind == \"expression/unit\"\n}\n\nfunction parseRecordPatternFields(\n  service: ParserService,\n  parser: Parser,\n) -> Result<Array<SyntaxNode>, string> {\n  let open = expectLeftBrace(parser)?\n  let mut fields: Array<SyntaxNode> = []\n  let mut fieldIndex = 0\n  while !at(parser, \"right-brace\") && !at(parser, \"eof\") {\n    let lo = current(parser).lo\n    let name = if current(parser).kind.startsWith(\"keyword/\") &&\n      tokenAt(parser, 1).kind == \"colon\" {\n      bump(parser)\n    } else {\n      identifier(parser, \"a field name\")?\n    }\n    let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n    if eat(parser, \"colon\") {\n      children.push(parsePattern(service, parser, \"pattern\", 0)?)\n    } else {\n      rejectReservedBinding(parser, name)\n    }\n    fields.push(node(\n      \"record-pattern-field\",\n      lo,\n      boxValue(parser.lastHi),\n      \"fields\",\n      fieldIndex,\n      [],\n      children,\n    ))\n    fieldIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expectRightBrace(parser)?\n  if fields.length == 0 {\n    let mut diagnostics = parser.diagnostics\n    diagnostics.push(diagnostic(\n      \"TPZ2001\",\n      \"a record pattern requires at least one field\",\n      open.lo,\n      close.hi,\n    ))\n  }\n  Ok(fields)\n}\n\nfunction parseListPattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let open = bump(parser)\n  let mut elements: Array<SyntaxNode> = []\n  let mut elementIndex = 0\n  while !at(parser, \"right-bracket\") && !at(parser, \"eof\") {\n    if eat(parser, \"dot-dot\") {\n      let markerLo = boxValue(parser.lastHi) - 2\n      let mut children: Array<SyntaxNode> = []\n      if !at(parser, \"comma\") && !at(parser, \"right-bracket\") {\n        children.push(parsePattern(service, parser, \"binding\", 0)?)\n      }\n      let restLo = match children.get(0) {\n        case Some(binding) => binding.lo\n        case None => markerLo\n      }\n      let restHi = boxValue(parser.lastHi)\n      elements.push(node(\n        \"list-pattern/rest\",\n        restLo,\n        restHi,\n        \"elements\",\n        elementIndex,\n        [],\n        children,\n      ))\n    } else {\n      elements.push(parsePattern(\n        service,\n\n        parser,\n        \"elements\",\n        elementIndex,\n      )?)\n    }\n    elementIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expect(parser, \"right-bracket\", \"`]`\")?\n  let mut normalized: Array<SyntaxNode> = []\n  for element in elements {\n    if element.kind == \"list-pattern/rest\" && element.children.length == 0 {\n      normalized.push(node(\n        element.kind,\n        open.lo,\n        close.hi,\n        element.field,\n        element.index,\n        element.attributes,\n        element.children,\n      ))\n    } else {\n      normalized.push(element)\n    }\n  }\n  Ok(node(\"pattern/list\", open.lo, close.hi, field, index, [], normalized))\n}\n\nfunction parseConstructorPattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let name = bump(parser)\n  bump(parser)\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  let mut argumentIndex = 0\n  while !at(parser, \"right-paren\") && !at(parser, \"eof\") {\n    children.push(parsePattern(\n      service,\n\n      parser,\n      \"arguments\",\n      argumentIndex,\n    )?)\n    argumentIndex += 1\n    if !eat(parser, \"comma\") {\n      break\n    }\n  }\n  let close = expect(parser, \"right-paren\", \"`)`\")?\n  Ok(node(\n    \"pattern/constructor\",\n    name.lo,\n    close.hi,\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseNominalRecordPattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let name = bump(parser)\n  let fields = parseRecordPatternFields(service, parser)?\n  let mut children: Array<SyntaxNode> = [identNode(name, \"name\", 0)]\n  for found in fields {\n    children.push(found)\n  }\n  Ok(node(\n    \"pattern/nominal-record\",\n    name.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    children,\n  ))\n}\n\nfunction parseTypedPattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let name = bump(parser)\n  rejectReservedBinding(parser, name)\n  bump(parser)\n  let typeNode = parseType(service, parser, \"type\", 0)?\n  Ok(node(\n    \"pattern/typed\",\n    name.lo,\n    typeNode.hi,\n    field,\n    index,\n    [],\n    [identNode(name, \"name\", 0), typeNode],\n  ))\n}\n\nfunction identifierStartsBindingPattern(parser: Parser) -> bool {\n  let next = tokenAt(parser, 1).kind\n  next != \"dot-dot\" && next != \"dot-dot-lt\" && next != \"plus\" &&\n    next != \"minus\" && next != \"star\" && next != \"slash\" &&\n    next != \"percent\" && next != \"star-star\"\n}\n\nfunction parseIdentifierPattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<Option<SyntaxNode>, string> {\n  let next = tokenAt(parser, 1).kind\n  if next == \"left-paren\" {\n    return Ok(Some(parseConstructorPattern(\n      service,\n\n      parser,\n      field,\n      index,\n    )?))\n  }\n  if next == \"left-brace\" {\n    return Ok(Some(parseNominalRecordPattern(\n      service,\n\n      parser,\n      field,\n      index,\n    )?))\n  }\n  if next == \"colon\" {\n    return Ok(Some(parseTypedPattern(\n      service,\n\n      parser,\n      field,\n      index,\n    )?))\n  }\n  if !identifierStartsBindingPattern(parser) {\n    return Ok(None)\n  }\n  let name = bump(parser)\n  if text(parser, name.lo, name.hi) == \"None\" {\n    return Ok(Some(node(\n      \"pattern/constructor\",\n      name.lo,\n      name.hi,\n      field,\n      index,\n      [],\n      [identNode(name, \"name\", 0)],\n    )))\n  }\n  Ok(Some(bindingPattern(name, field, index)))\n}\n\nfunction parseExpressionPattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let first = invokeParseExpressionBp(service, parser, 8, \"value\", 0)?\n  if at(parser, \"dot-dot\") || at(parser, \"dot-dot-lt\") {\n    let inclusive = at(parser, \"dot-dot\")\n    bump(parser)\n    let high = invokeParseExpressionBp(service, parser, 8, \"high\", 0)?\n    return Ok(node(\n      \"pattern/range\",\n      first.lo,\n      high.hi,\n      field,\n      index,\n      [boolAttribute(\"inclusive\", inclusive)],\n      [attach(first, \"low\", 0), high],\n    ))\n  }\n  if isLiteralExpressionKind(first.kind) {\n    return Ok(node(\n      \"pattern/literal\",\n      first.lo,\n      first.hi,\n      field,\n      index,\n      [],\n      [attach(first, \"value\", 0)],\n    ))\n  }\n  fail(parser, \"expected a pattern\")?\n  Err(\"expected a pattern\")\n}\n\nfunction parsePrimaryPattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let start = current(parser)\n  if start.kind == \"underscore\" {\n    let value = bump(parser)\n    return Ok(node(\"pattern/wildcard\", value.lo, value.hi, field, index, [], []))\n  }\n  if start.kind == \"left-bracket\" {\n    return parseListPattern(service, parser, field, index)\n  }\n  if start.kind == \"left-brace\" {\n    let fields = parseRecordPatternFields(service, parser)?\n    return Ok(node(\n      \"pattern/record\",\n      start.lo,\n      boxValue(parser.lastHi),\n      field,\n      index,\n      [],\n      fields,\n    ))\n  }\n  if start.kind == \"identifier\" {\n    match parseIdentifierPattern(service, parser, field, index)? {\n      case Some(pattern) => return Ok(pattern)\n      case None => ()\n    }\n  }\n  parseExpressionPattern(service, parser, field, index)\n}\n\nexport function parsePattern(\n  service: ParserService,\n  parser: Parser,\n  field: string,\n  index: int,\n) -> Result<SyntaxNode, string> {\n  let first = parsePrimaryPattern(service, parser, field, index)?\n  if !at(parser, \"pipe\") {\n    return Ok(first)\n  }\n  let mut alternatives: Array<SyntaxNode> = [attach(first, \"alternatives\", 0)]\n  let mut alternativeIndex = 1\n  while eat(parser, \"pipe\") {\n    alternatives.push(parsePrimaryPattern(\n      service,\n\n      parser,\n      \"alternatives\",\n      alternativeIndex,\n    )?)\n    alternativeIndex += 1\n  }\n  Ok(node(\n    \"pattern/or\",\n    first.lo,\n    boxValue(parser.lastHi),\n    field,\n    index,\n    [],\n    alternatives,\n  ))\n}\n",
      "sourceSha256": "5e836a97ae90bc3ad8b2256809ab7b530a7eaf027d168f6eae763bf6644ca047"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/profile.tpz",
      "language": "topaz",
      "bytes": 25220,
      "sha256": "85a89e0c514a3d19a8eed35ba84b44c49e6632da9f573480fa0ab0d1de21eaa2",
      "content": "import types {\n  PreviewAstNode,\n  PreviewCheckDiagnostic,\n  PreviewModuleResult,\n  PreviewResolvedReference,\n  PreviewToken,\n  PreviewTypeAtom,\n  PreviewTypedCall,\n  PreviewTypedCapture,\n  PreviewTypedNode,\n}\n\nrecord ProfileSpan {\n  lo: int,\n  hi: int,\n}\n\nrecord ProfileDenial {\n  rule: string,\n  message: string,\n}\n\nfunction moduleText(source: Bytes, lo: int, hi: int) -> string {\n  match source.slice(lo, hi).decodeUtf8() {\n    case Ok(value) => value\n    case Err(_) => \"\"\n  }\n}\n\nfunction sameFinding(\n  left: PreviewCheckDiagnostic,\n  right: PreviewCheckDiagnostic,\n) -> bool {\n  left.moduleIndex == right.moduleIndex &&\n    left.lo == right.lo &&\n    left.hi == right.hi &&\n    left.code == right.code &&\n    left.message == right.message &&\n    left.profileRule == right.profileRule\n}\n\nfunction before(\n  left: PreviewCheckDiagnostic,\n  right: PreviewCheckDiagnostic,\n) -> bool {\n  left.moduleIndex < right.moduleIndex ||\n    (left.moduleIndex == right.moduleIndex && left.lo < right.lo) ||\n    (left.moduleIndex == right.moduleIndex && left.lo == right.lo &&\n      left.hi < right.hi) ||\n    (left.moduleIndex == right.moduleIndex && left.lo == right.lo &&\n      left.hi == right.hi && left.profileRule < right.profileRule) ||\n    (left.moduleIndex == right.moduleIndex && left.lo == right.lo &&\n      left.hi == right.hi && left.profileRule == right.profileRule &&\n      left.message < right.message)\n}\n\nfunction insertFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  finding: PreviewCheckDiagnostic,\n) -> () {\n  let mut target = output\n  let mut index = 0\n  while index < target.length {\n    let existing = target[index]\n    if sameFinding(existing, finding) {\n      return ()\n    }\n    if before(finding, existing) {\n      target.insert(index, finding)\n      return ()\n    }\n    index += 1\n  }\n  target.push(finding)\n  ()\n}\n\nfunction insertTypedFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  finding: PreviewCheckDiagnostic,\n) -> () {\n  let mut target = output\n  let mut index = 0\n  while index < target.length {\n    let existing = target[index]\n    if existing.moduleIndex == finding.moduleIndex &&\n      existing.lo == finding.lo &&\n      existing.hi == finding.hi {\n      return ()\n    }\n    if before(finding, existing) {\n      target.insert(index, finding)\n      return ()\n    }\n    index += 1\n  }\n  target.push(finding)\n  ()\n}\n\nfunction finding(\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  rule: string,\n  message: string,\n  primaryMessage: string,\n  notes: Array<string>,\n) -> PreviewCheckDiagnostic {\n  PreviewCheckDiagnostic {\n    moduleIndex: moduleIndex,\n    code: \"TPZ5801\",\n    message: message,\n    primaryMessage: primaryMessage,\n    lo: lo,\n    hi: hi,\n    secondary: [],\n    notes: notes,\n    profileRule: rule,\n  }\n}\n\nfunction sourceFinding(\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  rule: string,\n  message: string,\n) -> PreviewCheckDiagnostic {\n  finding(\n    moduleIndex,\n    lo,\n    hi,\n    rule,\n    message,\n    \"not in the deterministic compiler-kernel inventory\",\n    [\n      \"profile rule: {rule}\",\n      \"move this effect to the Rust host shell or use a deterministic admitted value/library leaf\",\n    ],\n  )\n}\n\nfunction typedFinding(\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  rule: string,\n  message: string,\n) -> PreviewCheckDiagnostic {\n  finding(\n    moduleIndex,\n    lo,\n    hi,\n    rule,\n    message,\n    \"Bootstrap Profile package boundary\",\n    [\"profile rule: {rule}\"],\n  )\n}\n\nrecord DirectChildIndexes {\n  byParent: Map<int, Map<string, int>>,\n}\n\nrecord ProfileSpanIndexes {\n  byModule: Map<int, Map<int, Map<int, int>>>,\n}\n\nfunction directChildIndexes(\n  nodes: Array<PreviewAstNode>,\n) -> DirectChildIndexes {\n  let mut byParent: Map<int, Map<string, int>> = map {}\n  let mut index = 0\n  for node in nodes {\n    match byParent.get(node.parent) {\n      case Some(found) => {\n        let mut byField = found\n        match byField.get(node.field) {\n          case Some(_) => ()\n          case None => byField.insert(node.field, index)\n        }\n      }\n      case None => {\n        let mut byField: Map<string, int> = map {}\n        byField.insert(node.field, index)\n        byParent.insert(node.parent, byField)\n      }\n    }\n    index += 1\n  }\n  DirectChildIndexes { byParent: byParent }\n}\n\nfunction directChildIndex(\n  indexes: DirectChildIndexes,\n  parent: int,\n  field: string,\n) -> Option<int> {\n  match indexes.byParent.get(parent) {\n    case Some(byField) => byField.get(field)\n    case None => None\n  }\n}\n\nfunction directChild(\n  nodes: Array<PreviewAstNode>,\n  indexes: DirectChildIndexes,\n  parent: int,\n  field: string,\n) -> Option<PreviewAstNode> {\n  match directChildIndex(indexes, parent, field) {\n    case Some(index) => Some(nodes[index])\n    case None => None\n  }\n}\n\nfunction insertProfileSpanIndex(\n  indexes: ProfileSpanIndexes,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  index: int,\n) -> () {\n  let mut byModule = indexes.byModule\n  let mut byLo = match byModule.get(moduleIndex) {\n    case Some(found) => found\n    case None => {\n      let value: Map<int, Map<int, int>> = map {}\n      byModule.insert(moduleIndex, value)\n      value\n    }\n  }\n  let mut byHi = match byLo.get(lo) {\n    case Some(found) => found\n    case None => {\n      let value: Map<int, int> = map {}\n      byLo.insert(lo, value)\n      value\n    }\n  }\n  match byHi.get(hi) {\n    case Some(_) => ()\n    case None => byHi.insert(hi, index)\n  }\n}\n\nfunction profileSpanIndex(\n  indexes: ProfileSpanIndexes,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<int> {\n  match indexes.byModule.get(moduleIndex) {\n    case Some(byLo) => match byLo.get(lo) {\n      case Some(byHi) => byHi.get(hi)\n      case None => None\n    }\n    case None => None\n  }\n}\n\nfunction memberReference(\n  catalog: ProfileReferenceCatalog,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n) -> Option<PreviewResolvedReference> {\n  match profileSpanIndex(catalog.memberReferences, moduleIndex, lo, hi) {\n    case Some(index) => Some(catalog.references[index])\n    case None => None\n  }\n}\n\nfunction memberIdentity(\n  reference: Option<PreviewResolvedReference>,\n  objectName: string,\n  fieldName: string,\n) -> string {\n  match reference {\n    case Some(found) => {\n      let reference = found\n      let targetName = if reference.targetName == \"\" {\n        fieldName\n      } else {\n        reference.targetName\n      }\n      \"{reference.targetModule}::{targetName}\"\n    }\n    case None => \"{objectName}::{fieldName}\"\n  }\n}\n\nfunction composeSpan(\n  module: PreviewModuleResult,\n  childIndexes: DirectChildIndexes,\n  node: PreviewAstNode,\n  ordinal: int,\n) -> ProfileSpan {\n  match [\n    directChild(module.ast, childIndexes, ordinal, \"left\"),\n    directChild(module.ast, childIndexes, ordinal, \"right\"),\n  ] {\n    case [Some(left), Some(right)] => for token in module.raw {\n      if token.kind == \"gt-gt\" &&\n        token.lo >= left.hi &&\n        token.hi <= right.lo {\n        return ProfileSpan { lo: token.lo, hi: token.hi }\n      }\n    }\n    case _ => ()\n  }\n  ProfileSpan { lo: node.lo, hi: node.hi }\n}\n\nfunction identityHasHead(identity: string, head: string) -> bool {\n  identity == head ||\n    identity.startsWith(\"{head}.\") ||\n    identity.startsWith(\"{head}::\")\n}\n\nfunction deniedModule(identity: string) -> bool {\n  identityHasHead(identity, \"std.fs\") ||\n    identityHasHead(identity, \"std.io\") ||\n    identityHasHead(identity, \"std.path\") ||\n    identityHasHead(identity, \"std.cli\") ||\n    identityHasHead(identity, \"std.test\") ||\n    identityHasHead(identity, \"std.regex\") ||\n    identityHasHead(identity, \"std.codec\") ||\n    identityHasHead(identity, \"std.crypto\") ||\n    identityHasHead(identity, \"std.time\") ||\n    identityHasHead(identity, \"std.random\") ||\n    identityHasHead(identity, \"std.process\") ||\n    identityHasHead(identity, \"std.database\")\n}\n\nfunction deniedLeaf(identity: string) -> bool {\n  deniedModule(identity) ||\n    identityHasHead(identity, \"FS\") ||\n    identityHasHead(identity, \"Cli\") ||\n    identityHasHead(identity, \"Path\") ||\n    identityHasHead(identity, \"HTTP\") ||\n    identityHasHead(identity, \"DOM\") ||\n    identityHasHead(identity, \"Test\") ||\n    identityHasHead(identity, \"Regex\") ||\n    identityHasHead(identity, \"Date\") ||\n    identityHasHead(identity, \"Math\") ||\n    identityHasHead(identity, \"HMAC\") ||\n    identityHasHead(identity, \"Base64\") ||\n    identityHasHead(identity, \"Deflate\") ||\n    identityHasHead(identity, \"Zlib\") ||\n    identityHasHead(identity, \"ReedSolomon\")\n}\n\nfunction testFrameworkIdentity(identity: string) -> bool {\n  identityHasHead(identity, \"std.test\") || identityHasHead(identity, \"Test\")\n}\n\nfunction testMember(name: string) -> bool {\n  name == \"assert\" ||\n    name == \"assertEq\" ||\n    name == \"assertNe\" ||\n    name == \"assertContains\" ||\n    name == \"assertOk\" ||\n    name == \"assertErr\" ||\n    name == \"assertSome\" ||\n    name == \"assertNone\" ||\n    name == \"assertGolden\"\n}\n\nfunction typeDenial(atoms: Array<PreviewTypeAtom>) -> Option<ProfileDenial> {\n  for atom in atoms {\n    if (atom.kind == \"primitive\" || atom.kind == \"literal\") &&\n      atom.name == \"float\" {\n      return Some(ProfileDenial {\n        rule: \"bootstrap/no-float\",\n        message: \"`float` is not available to the deterministic Bootstrap Profile\",\n      })\n    }\n    if atom.kind == \"file\" || atom.kind == \"path\" {\n      return Some(ProfileDenial {\n        rule: \"bootstrap/no-resource\",\n        message: \"host file and path values are not available to the Bootstrap Profile\",\n      })\n    }\n    if atom.kind == \"regex\" ||\n      atom.kind == \"match\" ||\n      atom.kind == \"toml-value\" ||\n      atom.kind == \"url\" ||\n      atom.kind == \"date\" ||\n      atom.kind == \"big-int\" ||\n      atom.kind == \"decimal\" ||\n      atom.kind == \"rounding-mode\" {\n      return Some(ProfileDenial {\n        rule: \"bootstrap/no-host-leaf\",\n        message: \"this runtime value family is outside the Bootstrap Profile inventory\",\n      })\n    }\n  }\n  None\n}\n\nfunction appendTypeFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  atoms: Array<PreviewTypeAtom>,\n) -> () {\n  match typeDenial(atoms) {\n    case Some(value) => insertTypedFinding(\n      output,\n      typedFinding(moduleIndex, lo, hi, value.rule, value.message),\n    )\n    case None => ()\n  }\n}\n\nfunction appendCallTypeFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  call: PreviewTypedCall,\n) -> () {\n  match typeDenial(call.calleeType) {\n    case Some(value) => insertTypedFinding(\n      output,\n      typedFinding(\n        call.moduleIndex,\n        call.lo,\n        call.hi,\n        value.rule,\n        value.message,\n      ),\n    )\n    case None => match typeDenial(call.resultType) {\n      case Some(value) => insertTypedFinding(\n        output,\n        typedFinding(\n          call.moduleIndex,\n          call.lo,\n          call.hi,\n          value.rule,\n          value.message,\n        ),\n      )\n      case None => ()\n    }\n  }\n}\n\nfunction appendTestFramework(\n  output: Array<PreviewCheckDiagnostic>,\n  profile: string,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  label: string,\n) -> () {\n  let rule = if profile == \"agent-pack\" {\n    \"agent-pack/no-test-framework\"\n  } else if profile == \"test-profile\" {\n    \"test-profile/no-test-framework\"\n  } else {\n    \"bootstrap/no-test-framework\"\n  }\n  insertFinding(\n    output,\n    finding(\n      moduleIndex,\n      lo,\n      hi,\n      rule,\n      \"test-framework APIs are not allowed by profile `{profile}`\",\n      label,\n      [\n        \"profile rule: {rule}\",\n        \"the executable test-profile grants the canonical assert function (std.test.assert in language mode 5.21)\",\n      ],\n    ),\n  )\n}\n\nrecord ProfileReferenceCatalog {\n  references: Array<PreviewResolvedReference>,\n  resolvedTargets: ProfileSpanIndexes,\n  memberReferences: ProfileSpanIndexes,\n}\n\nrecord ProfileModuleContext {\n  profile: string,\n  languageMode: string,\n  moduleIndex: int,\n  module: PreviewModuleResult,\n  source: Bytes,\n  referenceCatalog: ProfileReferenceCatalog,\n  childIndexes: DirectChildIndexes,\n}\n\nfunction profileReferenceCatalog(\n  references: Array<PreviewResolvedReference>,\n) -> ProfileReferenceCatalog {\n  let resolvedTargets = ProfileSpanIndexes { byModule: map {} }\n  let memberReferences = ProfileSpanIndexes { byModule: map {} }\n  let mut referenceIndex = 0\n  for reference in references {\n    if reference.targetModuleIndex >= 0 {\n      insertProfileSpanIndex(\n        resolvedTargets,\n        reference.moduleIndex,\n        reference.lo,\n        reference.hi,\n        referenceIndex,\n      )\n    }\n    if reference.targetModule != \"\" {\n      insertProfileSpanIndex(\n        memberReferences,\n        reference.moduleIndex,\n        reference.lo,\n        reference.hi,\n        referenceIndex,\n      )\n    }\n    referenceIndex += 1\n  }\n  ProfileReferenceCatalog {\n    references: references,\n    resolvedTargets: resolvedTargets,\n    memberReferences: memberReferences,\n  }\n}\n\nfunction appendCompositionFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  context: ProfileModuleContext,\n  node: PreviewAstNode,\n  ordinal: int,\n) -> () {\n  if node.kind != \"expression/compose\" ||\n    (context.profile != \"agent-pack\" && context.profile != \"test-profile\") {\n    return ()\n  }\n  let span = composeSpan(context.module, context.childIndexes, node, ordinal)\n  let rule = \"{context.profile}/no-composition\"\n  insertFinding(\n    output,\n    finding(\n      context.moduleIndex,\n      span.lo,\n      span.hi,\n      rule,\n      \"function composition is not allowed by profile `{context.profile}`\",\n      \"profile-disallowed `>>`\",\n      [\n        \"profile rule: {rule}\",\n        \"use an explicit lambda, or a pipeline only when it preserves the intended semantics\",\n      ],\n    ),\n  )\n}\n\nfunction appendIdentifierFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  context: ProfileModuleContext,\n  node: PreviewAstNode,\n) -> () {\n  if node.kind != \"expression/identifier\" {\n    return ()\n  }\n  if context.languageMode == \"topaz-5.21\" && context.profile == \"test-profile\" {\n    match profileSpanIndex(context.referenceCatalog.resolvedTargets, context.moduleIndex, node.lo, node.hi) {\n      case Some(index) => {\n        let reference = context.referenceCatalog.references[index]\n        if reference.targetModule == \"std.test\" && reference.targetName != \"assert\" {\n          appendTestFramework(output, context.profile, context.moduleIndex, node.lo, node.hi, \"test-only std.test function\")\n        }\n      }\n      case None => ()\n    }\n  }\n  let name = moduleText(context.source, node.lo, node.hi)\n  let unresolved = profileSpanIndex(\n    context.referenceCatalog.resolvedTargets,\n    context.moduleIndex,\n    node.lo,\n    node.hi,\n  ) == None\n  if context.profile == \"bootstrap\" && unresolved &&\n    (name == \"print\" || name == \"input\" || name == \"open\" || name == \"assert\") {\n    insertFinding(\n      output,\n      sourceFinding(\n        context.moduleIndex,\n        node.lo,\n        node.hi,\n        \"bootstrap/no-host-leaf\",\n        \"runtime leaf `{name}` is not available to the Bootstrap Profile\",\n      ),\n    )\n  } else if context.profile == \"agent-pack\" && unresolved && name == \"assert\" {\n    insertFinding(\n      output,\n      finding(\n        context.moduleIndex,\n        node.lo,\n        node.hi,\n        \"agent-pack/no-assert\",\n        \"`assert` is not allowed by profile `agent-pack`\",\n        \"test-only function reference\",\n        [\n          \"profile rule: agent-pack/no-assert\",\n          \"use `--profile test-profile` only for test code, or express the failure with canonical Result/control flow\",\n        ],\n      ),\n    )\n  }\n}\n\nfunction bootstrapSyntaxDenial(kind: string) -> Option<ProfileDenial> {\n  if kind == \"expression/float\" {\n    Some(ProfileDenial {\n      rule: \"bootstrap/no-float\",\n      message: \"`float` is not available to the deterministic Bootstrap Profile\",\n    })\n  } else if kind == \"expression/duration\" {\n    Some(ProfileDenial {\n      rule: \"bootstrap/no-duration\",\n      message: \"duration values are not available to the deterministic Bootstrap Profile\",\n    })\n  } else if kind == \"expression/concurrent\" {\n    Some(ProfileDenial {\n      rule: \"bootstrap/no-concurrency\",\n      message: \"`concurrent` is not available to the deterministic Bootstrap Profile\",\n    })\n  } else if kind == \"statement/using\" {\n    Some(ProfileDenial {\n      rule: \"bootstrap/no-resource\",\n      message: \"`using` and host resource values are not available to the Bootstrap Profile\",\n    })\n  } else {\n    None\n  }\n}\n\nfunction appendBootstrapSyntaxFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  context: ProfileModuleContext,\n  node: PreviewAstNode,\n) -> () {\n  if context.profile != \"bootstrap\" {\n    return ()\n  }\n  match bootstrapSyntaxDenial(node.kind) {\n    case Some(denial) => insertFinding(\n      output,\n      sourceFinding(\n        context.moduleIndex,\n        node.lo,\n        node.hi,\n        denial.rule,\n        denial.message,\n      ),\n    )\n    case None => ()\n  }\n}\n\nfunction appendImportFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  context: ProfileModuleContext,\n  node: PreviewAstNode,\n  ordinal: int,\n) -> () {\n  if node.kind != \"statement/import\" {\n    return ()\n  }\n  // The parser nests the module path under the statement's `import-item`.\n  let item = match directChildIndex(context.childIndexes, ordinal, \"import\") {\n    case Some(index) => index\n    case None => return ()\n  }\n  let pathIndex = match directChildIndex(context.childIndexes, item, \"path\") {\n    case Some(index) => index\n    case None => return ()\n  }\n  let path = context.module.ast[pathIndex]\n  let identity = modulePathIdentity(context, pathIndex)\n  if context.profile == \"bootstrap\" && deniedModule(identity) {\n    insertFinding(\n      output,\n      sourceFinding(\n        context.moduleIndex,\n        path.lo,\n        path.hi,\n        \"bootstrap/no-host-module\",\n        \"module `{identity}` is not available to the Bootstrap Profile\",\n      ),\n    )\n  }\n  let mut canonicalAssertion = context.languageMode == \"topaz-5.21\" && context.profile == \"test-profile\"\n  if canonicalAssertion {\n    let mut specIndex = item + 1\n    while specIndex < context.module.ast.length {\n      let spec = context.module.ast[specIndex]\n      if spec.parent == item && spec.kind == \"import-spec\" {\n        match directChildIndex(context.childIndexes, specIndex, \"name\") {\n          case Some(nameIndex) => {\n            let name = context.module.ast[nameIndex]\n            if moduleText(context.source, name.lo, name.hi) != \"assert\" { canonicalAssertion = false }\n          }\n          case None => { canonicalAssertion = false }\n        }\n      }\n      specIndex += 1\n    }\n  }\n  if identity == \"std.test\" && !canonicalAssertion {\n    appendTestFramework(\n      output,\n      context.profile,\n      context.moduleIndex,\n      path.lo,\n      path.hi,\n      \"test-only `std.test` import\",\n    )\n  }\n}\n\n// Joins the path segments, which directly follow their module path in the\n// flattened tree, so spacing or comments between segments keep one identity.\nfunction modulePathIdentity(context: ProfileModuleContext, path: int) -> string {\n  let mut segments: Array<string> = []\n  let mut index = path + 1\n  while index < context.module.ast.length {\n    let segment = context.module.ast[index]\n    if segment.parent != path {\n      break\n    }\n    segments.push(moduleText(context.source, segment.lo, segment.hi))\n    index += 1\n  }\n  segments.join(\".\")\n}\n\nfunction appendMemberFinding(\n  output: Array<PreviewCheckDiagnostic>,\n  context: ProfileModuleContext,\n  node: PreviewAstNode,\n  ordinal: int,\n) -> () {\n  if node.kind != \"expression/member\" && node.kind != \"expression/optional-access\" {\n    return ()\n  }\n  match [\n    directChild(context.module.ast, context.childIndexes, ordinal, \"object\"),\n    directChild(context.module.ast, context.childIndexes, ordinal, \"field\"),\n  ] {\n    case [Some(object), Some(field)] => if object.kind == \"expression/identifier\" {\n      let objectName = moduleText(context.source, object.lo, object.hi)\n      let fieldName = moduleText(context.source, field.lo, field.hi)\n      let objectResolved = profileSpanIndex(\n        context.referenceCatalog.resolvedTargets,\n        context.moduleIndex,\n        object.lo,\n        object.hi,\n      ) != None\n      let resolvedMember = memberReference(\n        context.referenceCatalog,\n        context.moduleIndex,\n        field.lo,\n        field.hi,\n      )\n      let memberResolved = match resolvedMember {\n        case Some(_) => true\n        case None => false\n      }\n      let identity = memberIdentity(\n        resolvedMember,\n        objectName,\n        fieldName,\n      )\n      if context.profile == \"bootstrap\" &&\n        (memberResolved || !objectResolved) && deniedLeaf(identity) {\n        insertFinding(\n          output,\n          sourceFinding(\n            context.moduleIndex,\n            node.lo,\n            node.hi,\n            \"bootstrap/no-host-leaf\",\n            \"runtime leaf `{identity}` is not available to the Bootstrap Profile\",\n          ),\n        )\n      }\n      let testNamespace = if memberResolved {\n        testFrameworkIdentity(identity)\n      } else {\n        !objectResolved && objectName == \"Test\"\n      }\n      let canonicalStd = context.languageMode == \"topaz-5.21\" && identityHasHead(identity, \"std.test\")\n      let canonicalAssert = canonicalStd && context.profile == \"test-profile\" && identity == \"std.test::assert\"\n      if !canonicalAssert && (canonicalStd || (testNamespace && testMember(fieldName))) {\n        appendTestFramework(\n          output,\n          context.profile,\n          context.moduleIndex,\n          node.lo,\n          node.hi,\n          \"test-only `Test.*` namespace member\",\n        )\n      }\n    }\n    case _ => ()\n  }\n}\n\nfunction appendSourceNodeFindings(\n  output: Array<PreviewCheckDiagnostic>,\n  context: ProfileModuleContext,\n  node: PreviewAstNode,\n  ordinal: int,\n) -> () {\n  appendCompositionFinding(output, context, node, ordinal)\n  appendIdentifierFinding(output, context, node)\n  appendBootstrapSyntaxFinding(output, context, node)\n  appendImportFinding(output, context, node, ordinal)\n  appendMemberFinding(output, context, node, ordinal)\n}\n\nfunction appendSourceFindings(\n  output: Array<PreviewCheckDiagnostic>,\n  profile: string,\n  languageMode: string,\n  modules: Array<PreviewModuleResult>,\n  referenceCatalog: ProfileReferenceCatalog,\n) -> () {\n  let mut moduleIndex = 0\n  for module in modules {\n    if module.identity != \"std\" && !module.identity.startsWith(\"std.\") {\n      let context = ProfileModuleContext {\n        profile: profile,\n        languageMode: languageMode,\n        moduleIndex: moduleIndex,\n        module: module,\n        source: (module.source).encodeUtf8(),\n        referenceCatalog: referenceCatalog,\n        childIndexes: directChildIndexes(module.ast),\n      }\n      let mut ordinal = 0\n      for node in module.ast {\n        appendSourceNodeFindings(output, context, node, ordinal)\n        ordinal += 1\n      }\n    }\n    moduleIndex += 1\n  }\n  ()\n}\n\nfunction appendBootstrapTypedFindings(\n  output: Array<PreviewCheckDiagnostic>,\n  typedNodes: Array<PreviewTypedNode>,\n  typedCalls: Array<PreviewTypedCall>,\n  typedCaptures: Array<PreviewTypedCapture>,\n) -> () {\n  let mut typedOutput: Array<PreviewCheckDiagnostic> = []\n  for node in typedNodes {\n    if node.ambient {\n      insertTypedFinding(\n        typedOutput,\n        typedFinding(\n          node.moduleIndex,\n          node.lo,\n          node.hi,\n          \"bootstrap/no-ambient-type\",\n          \"the compiler kernel may not retain an ambient or unexplained type\",\n        ),\n      )\n    }\n  }\n  for call in typedCalls {\n    if call.ambient {\n      insertTypedFinding(\n        typedOutput,\n        typedFinding(\n          call.moduleIndex,\n          call.lo,\n          call.hi,\n          \"bootstrap/no-ambient-type\",\n          \"the compiler kernel may not retain an unexplained callable or result type\",\n        ),\n      )\n    }\n  }\n  for node in typedNodes {\n    appendTypeFinding(typedOutput, node.moduleIndex, node.lo, node.hi, node.typeValue)\n  }\n  for call in typedCalls {\n    appendCallTypeFinding(typedOutput, call)\n  }\n  for capture in typedCaptures {\n    appendTypeFinding(\n      typedOutput,\n      capture.moduleIndex,\n      capture.referenceLo,\n      capture.referenceHi,\n      capture.typeValue,\n    )\n  }\n  for found in typedOutput {\n    insertFinding(output, found)\n  }\n  ()\n}\n\nexport function checkProfile(\n  profile: string,\n  modules: Array<PreviewModuleResult>,\n  references: Array<PreviewResolvedReference>,\n  typedNodes: Array<PreviewTypedNode>,\n  typedCalls: Array<PreviewTypedCall>,\n  typedCaptures: Array<PreviewTypedCapture>,\n  languageMode: string = \"topaz-5.20\",\n) -> Result<Array<PreviewCheckDiagnostic>, string> {\n  if profile == \"\" {\n    return Ok([])\n  }\n  if profile != \"agent-pack\" &&\n    profile != \"test-profile\" &&\n    profile != \"bootstrap\" {\n    return Err(\"unsupported compiler profile `{profile}`\")\n  }\n  let mut output: Array<PreviewCheckDiagnostic> = []\n  let referenceCatalog = profileReferenceCatalog(references)\n  appendSourceFindings(output, profile, languageMode, modules, referenceCatalog)\n  if profile == \"bootstrap\" {\n    appendBootstrapTypedFindings(output, typedNodes, typedCalls, typedCaptures)\n  }\n  Ok(output)\n}\n",
      "sourceSha256": "85a89e0c514a3d19a8eed35ba84b44c49e6632da9f573480fa0ab0d1de21eaa2"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/raw.tpz",
      "language": "topaz",
      "bytes": 22318,
      "sha256": "70e0df5df63c3639269249ee08312633813ca7dc3a71bbb9bd6294afe1ce4cb7",
      "content": "import literal { stringLayout }\nimport length { unitName }\nimport types { PreviewDiagnostic, PreviewToken, RawResult }\nimport unicode {\n  identifierContinueEnd,\n  identifierEnd,\n  identifierStartWidth,\n  utf8Width,\n}\n\nfunction token(kind: string, lo: int, hi: int) -> PreviewToken {\n  PreviewToken {\n    kind: kind,\n    lo: lo,\n    hi: hi,\n    stream: \"raw\",\n    synthetic: false,\n  }\n}\n\nfunction syntheticToken(kind: string, at: int) -> PreviewToken {\n  PreviewToken {\n    kind: kind,\n    lo: at,\n    hi: at,\n    stream: \"raw\",\n    synthetic: true,\n  }\n}\n\nfunction diagnostic(code: string, message: string, lo: int, hi: int) -> PreviewDiagnostic {\n  PreviewDiagnostic { code: code, message: message, lo: lo, hi: hi, notes: [] }\n}\n\nfunction byteAt(bytes: Bytes, index: int) -> int {\n  match bytes.get(index) {\n    case Some(value) => value\n    case None => -1\n  }\n}\n\nfunction isAsciiSpace(value: int) -> bool {\n  value == 32 || value == 9\n}\n\nfunction lineCommentEnd(bytes: Bytes, start: int) -> int {\n  let mut index = start + 2\n  while index < bytes.length() && byteAt(bytes, index) != 10 {\n    index += 1\n  }\n  index\n}\n\nfunction blockCommentEnd(bytes: Bytes, start: int) -> int {\n  let mut index = start + 2\n  while index < bytes.length() {\n    if byteAt(bytes, index) == 42 && byteAt(bytes, index + 1) == 47 {\n      return index + 2\n    }\n    index += 1\n  }\n  index\n}\n\nfunction isAsciiDigit(value: int) -> bool {\n  value >= 48 && value <= 57\n}\n\nexport function keywordKind(text: string) -> string {\n  match text {\n    case \"let\" => \"keyword/let\"\n    case \"mut\" => \"keyword/mut\"\n    case \"const\" => \"keyword/const\"\n    case \"type\" => \"keyword/type\"\n    case \"function\" => \"keyword/function\"\n    case \"return\" => \"keyword/return\"\n    case \"if\" => \"keyword/if\"\n    case \"else\" => \"keyword/else\"\n    case \"match\" => \"keyword/match\"\n    case \"case\" => \"keyword/case\"\n    case \"for\" => \"keyword/for\"\n    case \"in\" => \"keyword/in\"\n    case \"by\" => \"keyword/by\"\n    case \"while\" => \"keyword/while\"\n    case \"break\" => \"keyword/break\"\n    case \"continue\" => \"keyword/continue\"\n    case \"defer\" => \"keyword/defer\"\n    case \"concurrent\" => \"keyword/concurrent\"\n    case \"true\" => \"keyword/true\"\n    case \"false\" => \"keyword/false\"\n    case \"null\" => \"keyword/null\"\n    case \"_\" => \"underscore\"\n    case _ => \"identifier\"\n  }\n}\n\nfunction decode(bytes: Bytes, lo: int, hi: int) -> string {\n  match bytes.slice(lo, hi).decodeUtf8() {\n    case Ok(value) => value\n    case Err(_) => \"\"\n  }\n}\n\nfunction identifierHeadKind(bytes: Bytes, start: int, end: int) -> string {\n  let kind = keywordKind(decode(bytes, start, end))\n  if kind == \"identifier\" && byteAt(bytes, end) == 34 {\n    \"tagged-string\"\n  } else {\n    kind\n  }\n}\n\nfunction punctuation(bytes: Bytes, index: int) -> Option<PreviewToken> {\n  let a = byteAt(bytes, index)\n  let b = byteAt(bytes, index + 1)\n  let c = byteAt(bytes, index + 2)\n  match [a, b, c] {\n    case [46, 46, 46] => Some(token(\"ellipsis\", index, index + 3))\n    case [46, 46, 60] => Some(token(\"dot-dot-lt\", index, index + 3))\n    case [63, 63, 61] => Some(token(\"question-question-eq\", index, index + 3))\n    case [42, 42, _] => Some(token(\"star-star\", index, index + 2))\n    case [46, 46, _] => Some(token(\"dot-dot\", index, index + 2))\n    case [63, 46, _] => Some(token(\"question-dot\", index, index + 2))\n    case [63, 63, _] => Some(token(\"question-question\", index, index + 2))\n    case [60, 61, _] => Some(token(\"le\", index, index + 2))\n    case [62, 61, _] => Some(token(\"ge\", index, index + 2))\n    case [62, 62, _] => Some(token(\"gt-gt\", index, index + 2))\n    case [61, 61, _] => Some(token(\"eq-eq\", index, index + 2))\n    case [33, 61, _] => Some(token(\"not-eq\", index, index + 2))\n    case [43, 61, _] => Some(token(\"plus-eq\", index, index + 2))\n    case [45, 61, _] => Some(token(\"minus-eq\", index, index + 2))\n    case [42, 61, _] => Some(token(\"star-eq\", index, index + 2))\n    case [47, 61, _] => Some(token(\"slash-eq\", index, index + 2))\n    case [37, 61, _] => Some(token(\"percent-eq\", index, index + 2))\n    case [38, 38, _] => Some(token(\"and-and\", index, index + 2))\n    case [124, 124, _] => Some(token(\"or-or\", index, index + 2))\n    case [124, 62, _] => Some(token(\"pipe-gt\", index, index + 2))\n    case [61, 62, _] => Some(token(\"fat-arrow\", index, index + 2))\n    case [45, 62, _] => Some(token(\"thin-arrow\", index, index + 2))\n    case [40, _, _] => Some(token(\"left-paren\", index, index + 1))\n    case [41, _, _] => Some(token(\"right-paren\", index, index + 1))\n    case [91, _, _] => Some(token(\"left-bracket\", index, index + 1))\n    case [93, _, _] => Some(token(\"right-bracket\", index, index + 1))\n    case [123, _, _] => Some(token(\"left-brace\", index, index + 1))\n    case [125, _, _] => Some(token(\"right-brace\", index, index + 1))\n    case [43, _, _] => Some(token(\"plus\", index, index + 1))\n    case [45, _, _] => Some(token(\"minus\", index, index + 1))\n    case [42, _, _] => Some(token(\"star\", index, index + 1))\n    case [47, _, _] => Some(token(\"slash\", index, index + 1))\n    case [37, _, _] => Some(token(\"percent\", index, index + 1))\n    case [46, _, _] => Some(token(\"dot\", index, index + 1))\n    case [63, _, _] => Some(token(\"question\", index, index + 1))\n    case [60, _, _] => Some(token(\"lt\", index, index + 1))\n    case [62, _, _] => Some(token(\"gt\", index, index + 1))\n    case [61, _, _] => Some(token(\"eq\", index, index + 1))\n    case [33, _, _] => Some(token(\"bang\", index, index + 1))\n    case [126, _, _] => Some(token(\"tilde\", index, index + 1))\n    case [124, _, _] => Some(token(\"pipe\", index, index + 1))\n    case [44, _, _] => Some(token(\"comma\", index, index + 1))\n    case [58, _, _] => Some(token(\"colon\", index, index + 1))\n    case [59, _, _] => Some(token(\"semicolon\", index, index + 1))\n    case _ => None\n  }\n}\n\nfunction isValidEscape(value: int) -> bool {\n  value == 110 ||\n    value == 116 ||\n    value == 114 ||\n    value == 92 ||\n    value == 34 ||\n    value == 123 ||\n    value == 125\n}\n\nfunction startsTripleQuote(bytes: Bytes, index: int) -> bool {\n  byteAt(bytes, index) == 34 &&\n    byteAt(bytes, index + 1) == 34 &&\n    byteAt(bytes, index + 2) == 34\n}\n\nfunction multilineIndentDiagnostics(\n  bytes: Bytes,\n  lineStarts: Array<int>,\n  delimiter: int,\n) -> Array<PreviewDiagnostic> {\n  let mut diagnostics: Array<PreviewDiagnostic> = []\n  for line in stringLayout(bytes, 0, delimiter, lineStarts).offending {\n    diagnostics.push(diagnostic(\"TPZ0006\", \"line does not begin with the closing indent of its multiline string\", line.lo, line.hi))\n  }\n  diagnostics\n}\n\nrecord LexemeScan {\n  tokens: Array<PreviewToken>,\n  diagnostics: Array<PreviewDiagnostic>,\n  next: int,\n  propagatedLineBreak: bool,\n}\n\nrecord StringInterpolationOutcome {\n  next: int,\n  lineBreak: bool,\n}\n\nrecord StringScanState {\n  bytes: Bytes,\n  tokens: Array<PreviewToken>,\n  diagnostics: Array<PreviewDiagnostic>,\n  lineStarts: Array<int>,\n  quote: int,\n  multiline: bool,\n  lineBreakForbidden: bool,\n}\n\nfunction stringDelimiterEnd(start: int, multiline: bool) -> int {\n  start + if multiline { 3 } else { 1 }\n}\n\nfunction appendStringText(state: StringScanState, start: int, end: int) -> () {\n  if end > start {\n    let mut tokens = state.tokens\n    tokens.push(token(\"string-text\", start, end))\n  }\n  ()\n}\n\nfunction finishString(state: StringScanState, textStart: int, delimiter: int) -> LexemeScan {\n  appendStringText(state, textStart, delimiter)\n  let end = stringDelimiterEnd(delimiter, state.multiline)\n  let mut tokens = state.tokens\n  tokens.push(token(\"string-end\", delimiter, end))\n  if state.multiline {\n    let mut diagnostics = state.diagnostics\n    for found in multilineIndentDiagnostics(state.bytes, state.lineStarts, delimiter) {\n      diagnostics.push(found)\n    }\n  }\n  LexemeScan {\n    tokens: state.tokens,\n    diagnostics: state.diagnostics,\n    next: end,\n    propagatedLineBreak: false,\n  }\n}\n\nfunction scanStringEscape(state: StringScanState, start: int) -> int {\n  let mut index = start + 1\n  let escaped = byteAt(state.bytes, index)\n  if isValidEscape(escaped) {\n    return index + 1\n  }\n  let mut diagnostics = state.diagnostics\n  if escaped == 10 || escaped == 13 || escaped == -1 {\n    diagnostics.push(diagnostic(\n      \"TPZ0004\",\n      \"invalid escape: `\\\\` before the end of the line\",\n      start,\n      index,\n    ))\n    return index\n  }\n  let escapedWidth = utf8Width(escaped)\n  let consumed = if escapedWidth > 0 { escapedWidth } else { 1 }\n  let escapedText = decode(state.bytes, index, index + consumed)\n  index += consumed\n  diagnostics.push(diagnostic(\n    \"TPZ0004\",\n    \"invalid escape `\\\\{escapedText}` in a string literal\",\n    start,\n    index,\n  ))\n  index\n}\n\nfunction scanStringInterpolation(\n  state: StringScanState,\n  textStart: int,\n  start: int,\n) -> StringInterpolationOutcome {\n  appendStringText(state, textStart, start)\n  let mut tokens = state.tokens\n  tokens.push(token(\"interpolation-start\", start, start + 1))\n  let interpolation = scanCode(\n    state.bytes,\n    start + 1,\n    true,\n    state.lineBreakForbidden || !state.multiline,\n  )\n  let mut diagnostics = state.diagnostics\n  for found in interpolation.tokens {\n    tokens.push(found)\n  }\n  for found in interpolation.diagnostics {\n    diagnostics.push(found)\n  }\n  StringInterpolationOutcome {\n    next: interpolation.next,\n    lineBreak: interpolation.propagatedLineBreak,\n  }\n}\n\nfunction interruptedString(\n  state: StringScanState,\n  textStart: int,\n  end: int,\n  message: string,\n) -> LexemeScan {\n  appendStringText(state, textStart, end)\n  let mut diagnostics = state.diagnostics\n  diagnostics.push(diagnostic(\n    \"TPZ0003\",\n    message,\n    state.quote,\n    stringDelimiterEnd(state.quote, state.multiline),\n  ))\n  let mut tokens = state.tokens\n  tokens.push(syntheticToken(\"string-end\", end))\n  LexemeScan {\n    tokens: state.tokens,\n    diagnostics: state.diagnostics,\n    next: end,\n    propagatedLineBreak: false,\n  }\n}\n\nfunction propagateStringLineBreak(\n  state: StringScanState,\n  textStart: int,\n  end: int,\n) -> LexemeScan {\n  appendStringText(state, textStart, end)\n  let mut tokens = state.tokens\n  tokens.push(syntheticToken(\"string-end\", end))\n  LexemeScan {\n    tokens: state.tokens,\n    diagnostics: state.diagnostics,\n    next: end,\n    propagatedLineBreak: true,\n  }\n}\n\nfunction scanString(\n  bytes: Bytes,\n  tokenStart: int,\n  quote: int,\n  tagged: bool,\n  lineBreakForbidden: bool,\n) -> LexemeScan {\n  let multiline = startsTripleQuote(bytes, quote)\n  let mut index = stringDelimiterEnd(quote, multiline)\n  let mut textStart = index\n  let state = StringScanState {\n    bytes: bytes,\n    tokens: [token(\n      \"string-start/tagged={tagged}/multiline={multiline}\",\n      tokenStart,\n      index,\n    )],\n    diagnostics: [],\n    lineStarts: [],\n    quote: quote,\n    multiline: multiline,\n    lineBreakForbidden: lineBreakForbidden,\n  }\n  if multiline && index < bytes.length() && byteAt(bytes, index) != 10 &&\n    !(byteAt(bytes, index) == 13 && byteAt(bytes, index + 1) == 10) {\n    let mut lineStarts = state.lineStarts\n    lineStarts.push(index)\n  }\n  while index < bytes.length() {\n    if (multiline && startsTripleQuote(bytes, index)) ||\n      (!multiline && byteAt(bytes, index) == 34) {\n      return finishString(state, textStart, index)\n    }\n    let value = byteAt(bytes, index)\n    if value == 92 {\n      index = scanStringEscape(state, index)\n      continue\n    }\n    if value == 123 {\n      let interpolation = scanStringInterpolation(state, textStart, index)\n      if interpolation.lineBreak {\n        if state.multiline && state.lineBreakForbidden {\n          return propagateStringLineBreak(state, interpolation.next, interpolation.next)\n        }\n        return interruptedString(\n          state,\n          interpolation.next,\n          interpolation.next,\n          \"string interpolation in a single-line string cannot contain a line break\",\n        )\n      }\n      index = interpolation.next\n      textStart = index\n      continue\n    }\n    if multiline && state.lineBreakForbidden &&\n      (value == 10 || (value == 13 && byteAt(bytes, index + 1) == 10)) {\n      return propagateStringLineBreak(state, textStart, index)\n    }\n    if !multiline && (value == 10 ||\n      (value == 13 && byteAt(bytes, index + 1) == 10)) {\n      return interruptedString(\n        state,\n        textStart,\n        index,\n        \"single-line string literal is not closed before the line break\",\n      )\n    }\n    if !multiline && value == 125 {\n      let mut diagnostics = state.diagnostics\n      diagnostics.push(diagnostic(\n        \"TPZ0005\",\n        \"unescaped `\\}` in a string literal; write `\\\\\\}`\",\n        index,\n        index + 1,\n      ))\n    }\n    if multiline && value == 10 {\n      let mut lineStarts = state.lineStarts\n      lineStarts.push(index + 1)\n    }\n    index += 1\n  }\n  interruptedString(state, textStart, index, \"unterminated string literal\")\n}\n\nfunction appendScan(\n  targetTokens: Array<PreviewToken>,\n  targetDiagnostics: Array<PreviewDiagnostic>,\n  foundTokens: Array<PreviewToken>,\n  foundDiagnostics: Array<PreviewDiagnostic>,\n) -> () {\n  let mut tokens = targetTokens\n  for found in foundTokens {\n    tokens.push(found)\n  }\n  let mut diagnostics = targetDiagnostics\n  for found in foundDiagnostics {\n    diagnostics.push(found)\n  }\n  ()\n}\n\nfunction scanComment(bytes: Bytes, start: int) -> LexemeScan {\n  let mut index = start + 2\n  let mut diagnostics: Array<PreviewDiagnostic> = []\n  if byteAt(bytes, start + 1) == 47 {\n    index = lineCommentEnd(bytes, start)\n  } else {\n    index = blockCommentEnd(bytes, start)\n    let closed = index >= start + 4 &&\n      byteAt(bytes, index - 2) == 42 && byteAt(bytes, index - 1) == 47\n    if !closed {\n      diagnostics.push(diagnostic(\"TPZ0002\", \"unterminated block comment\", start, index))\n    }\n  }\n  LexemeScan {\n    tokens: [],\n    diagnostics: diagnostics,\n    next: index,\n    propagatedLineBreak: false,\n  }\n}\n\nfunction scanNumber(bytes: Bytes, start: int) -> LexemeScan {\n  let mut end = start\n  while isAsciiDigit(byteAt(bytes,end)) || byteAt(bytes,end) == 95 { end += 1 }\n  if byteAt(bytes,end) == 46 && (isAsciiDigit(byteAt(bytes,end+1)) || byteAt(bytes,end+1) == 95) {\n    end += 1\n    while isAsciiDigit(byteAt(bytes,end)) || byteAt(bytes,end) == 95 { end += 1 }\n  }\n  let unitEnd = identifierContinueEnd(bytes,end)\n  let suffix = decode(bytes,end,unitEnd)\n  if unitName(suffix) != \"\" {\n    return LexemeScan { tokens:[token(\"length/{unitName(suffix)}\",start,unitEnd)], diagnostics:[], next:unitEnd, propagatedLineBreak:false }\n  }\n\n  if suffix.startsWith(\"x\") || suffix.startsWith(\"X\") || suffix.startsWith(\"b\") || suffix.startsWith(\"B\") || suffix.startsWith(\"e\") || suffix.startsWith(\"E\") {\n    let unsupportedExponent = suffix.startsWith(\"e\") || suffix.startsWith(\"E\")\n    let mut invalidEnd=end\n    while invalidEnd<bytes.length() {\n      let b=byteAt(bytes,invalidEnd)\n      if isAsciiDigit(b) || (b>=65 && b<=90) || (b>=97 && b<=122) || b==95 {invalidEnd+=1;continue}\n      if b==46 && (isAsciiDigit(byteAt(bytes,invalidEnd+1)) || byteAt(bytes,invalidEnd+1)==95) {invalidEnd+=1;continue}\n      if (b==43 || b==45) && (byteAt(bytes,invalidEnd-1)==101 || byteAt(bytes,invalidEnd-1)==69) {invalidEnd+=1;continue}\n      break\n    }\n    let suffix=decode(bytes,invalidEnd-2,invalidEnd)\n    if unitName(suffix)!=\"\" {return LexemeScan {tokens:[token(\"length/{unitName(suffix)}\",start,invalidEnd)],diagnostics:[],next:invalidEnd,propagatedLineBreak:false}}\n    if unsupportedExponent {return LexemeScan {tokens:[token(\"float\",start,invalidEnd)],diagnostics:[],next:invalidEnd,propagatedLineBreak:false}}\n  }\n  let radix = byteAt(bytes,start)==48 && (byteAt(bytes,start+1)==120 || byteAt(bytes,start+1)==88 || byteAt(bytes,start+1)==98 || byteAt(bytes,start+1)==66)\n  let mut index = end\n  let mut kind = if decode(bytes,start,end).contains(\".\") { \"float\" } else { \"integer\" }\n  if radix {\n    index = start + 2\n    while isAsciiDigit(byteAt(bytes,index)) || (byteAt(bytes,index)>=65 && byteAt(bytes,index)<=90) || (byteAt(bytes,index)>=97 && byteAt(bytes,index)<=122) || byteAt(bytes,index)==95 { index += 1 }\n    if byteAt(bytes,index)==46 && (isAsciiDigit(byteAt(bytes,index+1)) || byteAt(bytes,index+1)==95) {\n      index += 1\n      while isAsciiDigit(byteAt(bytes,index)) || (byteAt(bytes,index)>=65 && byteAt(bytes,index)<=90) || (byteAt(bytes,index)>=97 && byteAt(bytes,index)<=122) || byteAt(bytes,index)==95 { index += 1 }\n    }\n    kind = \"integer\"\n  } else if kind == \"integer\" && (suffix == \"ms\" || suffix == \"s\" || suffix == \"m\") {\n    kind = \"duration/{suffix}\"\n    index = unitEnd\n  }\n  LexemeScan {\n    tokens: [token(kind, start, index)],\n    diagnostics: [],\n    next: index,\n    propagatedLineBreak: false,\n  }\n}\n\nfunction scanLabel(bytes: Bytes, start: int) -> LexemeScan {\n  let identifierStart = start + 1\n  let index = identifierEnd(bytes, identifierStart)\n  if index == identifierStart {\n    return LexemeScan {\n      tokens: [],\n      diagnostics: [diagnostic(\n        \"TPZ0001\",\n        \"a `'` begins a loop label `'name`; a bare `'` is not valid\",\n        start,\n        identifierStart,\n      )],\n      next: identifierStart,\n      propagatedLineBreak: false,\n    }\n  }\n  LexemeScan {\n    tokens: [token(\"label\", start, index)],\n    diagnostics: [],\n    next: index,\n    propagatedLineBreak: false,\n  }\n}\n\nfunction scanIdentifier(bytes: Bytes, start: int, lineBreakForbidden: bool) -> LexemeScan {\n  let index = identifierEnd(bytes, start)\n  let kind = identifierHeadKind(bytes, start, index)\n  if kind == \"tagged-string\" {\n    return scanString(bytes, start, index, true, lineBreakForbidden)\n  }\n  LexemeScan {\n    tokens: [token(kind, start, index)],\n    diagnostics: [],\n    next: index,\n    propagatedLineBreak: false,\n  }\n}\n\nfunction scanUnknown(bytes: Bytes, start: int) -> LexemeScan {\n  let scalarWidth = utf8Width(byteAt(bytes, start))\n  let consumed = if scalarWidth > 0 { scalarWidth } else { 1 }\n  let found = decode(bytes, start, start + consumed)\n  LexemeScan {\n    tokens: [],\n    diagnostics: [diagnostic(\n      \"TPZ0001\",\n      \"unknown character `{found}`\",\n      start,\n      start + consumed,\n    )],\n    next: start + consumed,\n    propagatedLineBreak: false,\n  }\n}\n\nfunction scanCode(\n  bytes: Bytes,\n  startIndex: int,\n  interpolation: bool,\n  lineBreakForbidden: bool,\n) -> LexemeScan {\n  let mut tokens: Array<PreviewToken> = []\n  let mut diagnostics: Array<PreviewDiagnostic> = []\n  let mut index = startIndex\n  let mut braceDepth = 0\n\n  while index < bytes.length() {\n    let value = byteAt(bytes, index)\n    if interpolation && value == 125 {\n      if braceDepth == 0 {\n        tokens.push(token(\"interpolation-end\", index, index + 1))\n        return LexemeScan {\n          tokens: tokens,\n          diagnostics: diagnostics,\n          next: index + 1,\n          propagatedLineBreak: false,\n        }\n      }\n      tokens.push(token(\"right-brace\", index, index + 1))\n      braceDepth -= 1\n      index += 1\n      continue\n    }\n    if interpolation && lineBreakForbidden &&\n      (value == 10 || (value == 13 && byteAt(bytes, index + 1) == 10)) {\n      tokens.push(syntheticToken(\"interpolation-end\", index))\n      return LexemeScan {\n        tokens: tokens,\n        diagnostics: diagnostics,\n        next: index,\n        propagatedLineBreak: true,\n      }\n    }\n    if isAsciiSpace(value) {\n      index += 1\n      continue\n    }\n    if value == 10 {\n      let lo = if index > 0 && byteAt(bytes, index - 1) == 13 { index - 1 } else { index }\n      tokens.push(token(\"newline\", lo, index + 1))\n      index += 1\n      continue\n    }\n    if value == 13 && byteAt(bytes, index + 1) == 10 {\n      tokens.push(token(\"newline\", index, index + 2))\n      index += 2\n      continue\n    }\n    if value == 13 {\n      index += 1\n      continue\n    }\n    if value == 47 &&\n      (byteAt(bytes, index + 1) == 47 || byteAt(bytes, index + 1) == 42) {\n      let found = scanComment(bytes, index)\n      appendScan(tokens, diagnostics, found.tokens, found.diagnostics)\n      index = found.next\n      continue\n    }\n    if value == 34 {\n      let result = scanString(bytes, index, index, false, lineBreakForbidden)\n      appendScan(tokens, diagnostics, result.tokens, result.diagnostics)\n      index = result.next\n      if result.propagatedLineBreak {\n        tokens.push(syntheticToken(\"interpolation-end\", index))\n        return LexemeScan {\n          tokens: tokens,\n          diagnostics: diagnostics,\n          next: index,\n          propagatedLineBreak: true,\n        }\n      }\n      continue\n    }\n    if isAsciiDigit(value) {\n      let found = scanNumber(bytes, index)\n      appendScan(tokens, diagnostics, found.tokens, found.diagnostics)\n      index = found.next\n      continue\n    }\n    if value == 39 {\n      let found = scanLabel(bytes, index)\n      appendScan(tokens, diagnostics, found.tokens, found.diagnostics)\n      index = found.next\n      continue\n    }\n    let startWidth = identifierStartWidth(bytes, index)\n    if startWidth > 0 {\n      let found = scanIdentifier(bytes, index, lineBreakForbidden)\n      appendScan(tokens, diagnostics, found.tokens, found.diagnostics)\n      index = found.next\n      if found.propagatedLineBreak {\n        tokens.push(syntheticToken(\"interpolation-end\", index))\n        return LexemeScan {\n          tokens: tokens,\n          diagnostics: diagnostics,\n          next: index,\n          propagatedLineBreak: true,\n        }\n      }\n      continue\n    }\n    match punctuation(bytes, index) {\n      case Some(found) => {\n        tokens.push(found)\n        if interpolation && found.kind == \"left-brace\" {\n          braceDepth += 1\n        }\n        index = found.hi\n      }\n      case None => {\n        let found = scanUnknown(bytes, index)\n        appendScan(tokens, diagnostics, found.tokens, found.diagnostics)\n        index = found.next\n      }\n    }\n  }\n  if interpolation {\n    tokens.push(syntheticToken(\"interpolation-end\", index))\n  } else {\n    tokens.push(token(\"eof\", bytes.length(), bytes.length()))\n  }\n  LexemeScan {\n    tokens: tokens,\n    diagnostics: diagnostics,\n    next: index,\n    propagatedLineBreak: false,\n  }\n}\n\nexport function lex(source: string) -> RawResult {\n  let bytes = (source).encodeUtf8()\n  let result = scanCode(bytes, 0, false, false)\n  RawResult { tokens: result.tokens, diagnostics: result.diagnostics }\n}\n",
      "sourceSha256": "70e0df5df63c3639269249ee08312633813ca7dc3a71bbb9bd6294afe1ce4cb7"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/resolver.tpz",
      "language": "topaz",
      "bytes": 3863,
      "sha256": "183dfd85626272277b3ed20c251940cbb0d45dc27277919a0717106667d69ca5",
      "content": "// Resolution entry point for the embedded self compiler.\n// Graph discovery and scope walking are delegated to resolver leaves; this file\n// admits host facts and assembles the public resolved preview.\n\nimport types {\n  PreviewGeneratedStdModule,\n  PreviewHostFact,\n  PreviewHostQuery,\n  PreviewResolvedDiagnostic,\n  ResolveResult,\n}\nimport resolver.graph {\n  dependencyOrder,\n  diagnoseCycles,\n  discoverModuleGraph,\n  moduleDependencyCatalog,\n  moduleIdentity,\n  parseModule,\n  pendingResult,\n  readEntrySource,\n  validateEntryPath,\n  validateEntryPhysicalContainment,\n}\nimport resolver.model_facts {\n  ResolverInputs,\n  ResolverHostFactCatalog,\n  addQuery,\n  resolverHostFacts,\n}\nimport resolver.modules_tables { buildModuleTables }\nimport resolver.validation_init {\n  rejectedResult,\n  resolvedResult,\n  validateImportSurfaces,\n}\n\n// Resolves an entry module from explicit host facts without performing I/O.\nexport function resolvePreview(\n  entry: string,\n  root: string,\n  facts: Array<PreviewHostFact>,\n  externModules: Array<string>,\n  generatedStdModules: Array<PreviewGeneratedStdModule>,\n  maxAstNodes: int,\n  maxAstDepth: int,\n  languageMode: string = \"topaz-5.20\",\n) -> Result<ResolveResult, string> {\n  resolveWithFacts(entry, root, resolverHostFacts(facts), externModules,\n    generatedStdModules, maxAstNodes, maxAstDepth, languageMode)\n}\n\n// The catalog and its callback belong to this invocation. Graph discovery\n// continues at each fact request without restarting parsing or resolution.\nexport function resolveWithFacts(\n  entry: string,\n  root: string,\n  hostFacts: ResolverHostFactCatalog,\n  externModules: Array<string>,\n  generatedStdModules: Array<PreviewGeneratedStdModule>,\n  maxAstNodes: int,\n  maxAstDepth: int,\n  languageMode: string = \"topaz-5.20\",\n) -> Result<ResolveResult, string> {\n  let mut diagnostics: Array<PreviewResolvedDiagnostic> = []\n  if !validateEntryPath(entry, root, diagnostics) {\n    return Ok(rejectedResult([], [], diagnostics))\n  }\n  let inputs = ResolverInputs {\n    languageMode: languageMode,\n    root: root,\n    hostFacts: hostFacts,\n    externModules: externModules,\n    generatedStdModules: generatedStdModules,\n    maxAstNodes: maxAstNodes,\n    maxAstDepth: maxAstDepth,\n  }\n  let mut queries: Array<PreviewHostQuery> = []\n  addQuery(queries, inputs.hostFacts, \"physical-containment\", entry)\n  addQuery(queries, inputs.hostFacts, \"read-source\", entry)\n  if hostFacts.errors.length > 0 { return Err(hostFacts.errors[0]) }\n  if queries.length > 0 {\n    return Ok(pendingResult(queries))\n  }\n  if !validateEntryPhysicalContainment(entry, inputs.hostFacts, diagnostics) {\n    return Ok(rejectedResult([], [], diagnostics))\n  }\n  let entrySource = match readEntrySource(entry, inputs.hostFacts, diagnostics) {\n    case Some(source) => source\n    case None => return Ok(rejectedResult([], [], diagnostics))\n  }\n\n  let entryDraft = parseModule(\n    0,\n    moduleIdentity(entry, root),\n    entry,\n    entrySource,\n    true,\n    false,\n    false,\n    maxAstNodes,\n    maxAstDepth,\n    languageMode,\n  )?\n  let graph = discoverModuleGraph(entryDraft, inputs, queries, diagnostics)?\n  if hostFacts.errors.length > 0 { return Err(hostFacts.errors[0]) }\n  if queries.length > 0 {\n    return Ok(pendingResult(queries))\n  }\n\n  let discovered = graph.modules\n  let edges = graph.edges\n  let dependencies = moduleDependencyCatalog(discovered, edges)\n  diagnoseCycles(dependencies, edges, diagnostics)\n  let ordered = if diagnostics.length == 0 {\n    dependencyOrder(discovered, dependencies)\n  } else {\n    discovered\n  }\n  if diagnostics.length > 0 {\n    return Ok(rejectedResult(ordered, dependencies.publicEdges, diagnostics))\n  }\n  let tables = buildModuleTables(ordered, diagnostics)\n  validateImportSurfaces(ordered, tables, diagnostics)\n  resolvedResult(ordered, dependencies.publicEdges, tables, diagnostics)\n}\n",
      "sourceSha256": "183dfd85626272277b3ed20c251940cbb0d45dc27277919a0717106667d69ca5"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/resolver/graph.tpz",
      "language": "topaz",
      "bytes": 24958,
      "sha256": "4c8c43e9336c2c298bf57693a38634368e000cd17d3d65f6842373fbbe54ebc3",
      "content": "import common.standard_migration { removedModuleHint }\n// Entry admission, module loading, dependency order, and cycle diagnosis.\n// Host queries are derived from explicit facts; scope tables and initializer\n// validation are left to sibling resolver leaves.\n\nimport layout { normalize }\nimport parser { parse }\nimport raw { lex }\nimport types {\n  PreviewGeneratedStdModule,\n  PreviewHostQuery,\n  PreviewImportEdge,\n  PreviewModuleResult,\n  PreviewResolvedDiagnostic,\n  ResolveResult,\n}\nimport unicode { caseFold, nfd }\nimport resolver.model_facts {\n  DiscoveredGraph,\n  EdgeDraft,\n  ImportDraft,\n  ImportPathDisposition,\n  ModuleDependencyCatalog,\n  ModuleDraft,\n  PreparedImport,\n  ResolverHostFactCatalog,\n  ResolverInputs,\n  addQuery,\n  appendModuleDiagnostics,\n  contains,\n  diagnostic,\n  hasParentPathSegment,\n  pathJoin,\n  sortQueries,\n  sourceFact,\n  stringJoin,\n}\nimport resolver.modules_tables { importDrafts }\n\nfunction generatedStdModule(\n  modules: Array<PreviewGeneratedStdModule>,\n  identity: string,\n) -> Option<PreviewGeneratedStdModule> {\n  for module in modules {\n    if module.identity == identity {\n      return Some(module)\n    }\n  }\n  None\n}\n\nfunction modulePath(root: string, segments: Array<string>) -> string {\n  pathJoin(root, \"{stringJoin(segments, \"/\")}.tpz\")\n}\n\nexport function moduleIdentity(entry: string, root: string) -> string {\n  let mut relative = entry\n  if root != \"\" && entry.startsWith(\"{root}/\") {\n    let bytes = (entry).encodeUtf8()\n    match bytes.slice((root).encodeUtf8().length() + 1, bytes.length()).decodeUtf8() {\n      case Ok(value) => {\n        relative = value\n      }\n      case Err(_) => ()\n    }\n  }\n  if relative.endsWith(\".tpz\") {\n    let bytes = (relative).encodeUtf8()\n    match bytes.slice(0, bytes.length() - 4).decodeUtf8() {\n      case Ok(value) => {\n        relative = value\n      }\n      case Err(_) => ()\n    }\n  }\n  relative.replace(\"/\", \".\")\n}\n\nexport function parseModule(\n  sourceOrdinal: int,\n  identity: string,\n  path: string,\n  source: string,\n  entry: bool,\n  externModule: bool,\n  generatedStd: bool,\n  maxAstNodes: int,\n  maxAstDepth: int,\n  languageMode: string = \"topaz-5.20\",\n) -> Result<ModuleDraft, string> {\n  let raw = lex(source)\n  let layout = normalize(raw.tokens, source)\n  let parsed = parse(layout.tokens, source, maxAstNodes, maxAstDepth, languageMode)?\n  let mut diagnostics = raw.diagnostics\n  for found in layout.diagnostics {\n    diagnostics.push(found)\n  }\n  for found in parsed.diagnostics {\n    diagnostics.push(found)\n  }\n  let sourceBytes = (source).encodeUtf8()\n  Ok(ModuleDraft {\n    result: PreviewModuleResult {\n      sourceOrdinal: sourceOrdinal,\n      identity: identity,\n      path: path,\n      source: source,\n      entry: entry,\n      extern: externModule,\n      generatedStd: generatedStd,\n      raw: raw.tokens,\n      layout: layout.tokens,\n      ast: parsed.nodes,\n    },\n    source: sourceBytes,\n    root: parsed.root,\n    imports: importDrafts(parsed.root, sourceBytes),\n    diagnostics: diagnostics,\n  })\n}\n\nfunction isExtern(externModules: Array<string>, identity: string) -> bool {\n  contains(externModules, identity)\n}\n\nfunction isExternNamespace(externModules: Array<string>, identity: string) -> bool {\n  let root = match identity.split(\".\").get(0) {\n    case Some(value) => value\n    case None => identity\n  }\n  for module in externModules {\n    if module == root || module.startsWith(\"{root}.\") {\n      return true\n    }\n  }\n  false\n}\n\nfunction validateSegment(\n  facts: ResolverHostFactCatalog,\n  dir: string,\n  name: string,\n  directory: bool,\n) -> ImportPathDisposition {\n  let fact = match sourceFact(facts, \"list-directory\", dir) {\n    case Some(value) => value\n    case None => return ImportPathDisposition { kind: \"pending\", collisionDetail: \"\" }\n  }\n  if fact.status == \"unreadable\" {\n    return ImportPathDisposition {\n      kind: \"unreadable\",\n      collisionDetail: fact.reasonCode,\n    }\n  }\n  if fact.status != \"present\" {\n    return ImportPathDisposition { kind: \"missing\", collisionDetail: \"\" }\n  }\n  let mut exact = false\n  let mut matches: Array<string> = []\n  let normalized = nfd(name)\n  let folded = caseFold(normalized)\n  for entry in fact.entries {\n    let sameKind = (directory && entry.kind == \"directory\") ||\n      (!directory && entry.kind == \"file\")\n    if sameKind {\n      if entry.name == name {\n        exact = true\n      }\n      let candidate = nfd(entry.name)\n      if candidate == normalized || caseFold(candidate) == folded {\n        matches.push(entry.name)\n      }\n    }\n  }\n  if matches.length > 1 {\n    ImportPathDisposition {\n      kind: \"collision\",\n      collisionDetail: \": {stringJoin(matches, \" / \")}\",\n    }\n  } else if exact {\n    ImportPathDisposition { kind: \"ok\", collisionDetail: \"\" }\n  } else {\n    ImportPathDisposition { kind: \"missing\", collisionDetail: \"\" }\n  }\n}\n\nfunction prepareImport(\n  inputs: ResolverInputs,\n  import: ImportDraft,\n  generated: Option<PreviewGeneratedStdModule>,\n  queries: Array<PreviewHostQuery>,\n) -> Result<PreparedImport, ImportPathDisposition> {\n  if inputs.languageMode == \"topaz-5.21\" && import.target == \"std.math\" { return Err(ImportPathDisposition { kind: \"missing\", collisionDetail: \"\" }) }\n  match generated {\n    case Some(value) => return Ok(PreparedImport {\n      path: value.path,\n      source: value.source,\n      physicalAlias: \"\",\n      generatedStd: true,\n    })\n    case None => ()\n  }\n  let first = match import.segments.get(0) {\n    case Some(value) => value\n    case None => return Err(ImportPathDisposition {\n      kind: \"missing\",\n      collisionDetail: \"\",\n    })\n  }\n  let path = modulePath(if first == \"std\" { \"\" } else { inputs.root }, import.segments)\n  if first == \"std\" {\n    addQuery(queries, inputs.hostFacts, \"read-source\", path)\n    return match sourceFact(inputs.hostFacts, \"read-source\", path) {\n      case Some(value) => if value.status == \"present\" {\n        Ok(PreparedImport {\n          path: path,\n          source: value.source,\n          physicalAlias: \"\",\n          generatedStd: false,\n        })\n      } else if value.status == \"unreadable\" {\n        Err(ImportPathDisposition {\n          kind: \"source-unreadable\",\n          collisionDetail: value.reasonCode,\n        })\n      } else if value.status == \"invalid-utf8\" {\n        Err(ImportPathDisposition {\n          kind: \"source-invalid-utf8\",\n          collisionDetail: \"\",\n        })\n      } else {\n        Err(ImportPathDisposition { kind: \"missing\", collisionDetail: \"\" })\n      }\n      case None => Err(ImportPathDisposition {\n        kind: \"pending\",\n        collisionDetail: \"\",\n      })\n    }\n  }\n  addQuery(queries, inputs.hostFacts, \"physical-containment\", path)\n  let containment = match sourceFact(inputs.hostFacts, \"physical-containment\", path) {\n    case Some(value) => if value.status == \"outside\" {\n      return Err(ImportPathDisposition { kind: \"outside\", collisionDetail: \"\" })\n    } else {\n      value\n    }\n    case None => return Err(ImportPathDisposition {\n      kind: \"pending\",\n      collisionDetail: \"\",\n    })\n  }\n  let mut dir = inputs.root\n  let mut index = 0\n  for segment in import.segments {\n    addQuery(queries, inputs.hostFacts, \"list-directory\", dir)\n    let name = if index + 1 == import.segments.length {\n      \"{segment}.tpz\"\n    } else {\n      segment\n    }\n    let disposition = validateSegment(\n      inputs.hostFacts,\n      dir,\n      name,\n      index + 1 < import.segments.length,\n    )\n    if disposition.kind != \"ok\" {\n      return Err(disposition)\n    }\n    if index + 1 < import.segments.length {\n      dir = pathJoin(dir, segment)\n    }\n    index += 1\n  }\n  addQuery(queries, inputs.hostFacts, \"read-source\", path)\n  match sourceFact(inputs.hostFacts, \"read-source\", path) {\n    case Some(value) => if value.status == \"present\" {\n      Ok(PreparedImport {\n        path: path,\n        source: value.source,\n        physicalAlias: if containment.status == \"inside\" {\n          containment.aliasClass\n        } else {\n          \"\"\n        },\n        generatedStd: false,\n      })\n    } else if value.status == \"unreadable\" {\n      Err(ImportPathDisposition {\n        kind: \"source-unreadable\",\n        collisionDetail: value.reasonCode,\n      })\n    } else if value.status == \"invalid-utf8\" {\n      Err(ImportPathDisposition {\n        kind: \"source-invalid-utf8\",\n        collisionDetail: \"\",\n      })\n    } else {\n      Err(ImportPathDisposition { kind: \"missing\", collisionDetail: \"\" })\n    }\n    case None => Err(ImportPathDisposition {\n      kind: \"pending\",\n      collisionDetail: \"\",\n    })\n  }\n}\n\nexport function dependencyOrder(\n  modules: Array<ModuleDraft>,\n  catalog: ModuleDependencyCatalog,\n) -> Array<ModuleDraft> {\n  let mut remaining: Set<string> = set {}\n  for identity in catalog.identities {\n    remaining.add(identity)\n  }\n  let mut done: Set<string> = set {}\n  let mut output: Array<ModuleDraft> = []\n  while output.length < modules.length {\n    let mut ready: Option<int> = None\n    for identity in catalog.identities {\n      if !remaining.contains(identity) {\n        continue\n      }\n      let mut blocked = false\n      match catalog.dependencies.get(identity) {\n        case Some(targets) => for target in targets {\n          if !done.contains(target) {\n            blocked = true\n          }\n        }\n        case None => ()\n      }\n      if !blocked {\n        ready = catalog.moduleIndexes.get(identity)\n        break\n      }\n    }\n    let selected = match ready {\n      case Some(index) => modules[index]\n      case None => return modules\n    }\n    remaining.remove(selected.result.identity)\n    output.push(selected)\n    done.add(selected.result.identity)\n  }\n  output\n}\n\nexport function moduleDependencyCatalog(\n  modules: Array<ModuleDraft>,\n  edges: Array<EdgeDraft>,\n) -> ModuleDependencyCatalog {\n  let mut identities: Array<string> = []\n  let mut moduleIndexes: Map<string, int> = map {}\n  let mut dependencies: Map<string, Set<string>> = map {}\n  let mut dependents: Map<string, Set<string>> = map {}\n  let mut publicEdges: Array<PreviewImportEdge> = []\n  let mut moduleIndexValue = 0\n  for module in modules {\n    identities.push(module.result.identity)\n    moduleIndexes.insert(module.result.identity, moduleIndexValue)\n    dependencies.insert(module.result.identity, set {})\n    dependents.insert(module.result.identity, set {})\n    moduleIndexValue += 1\n  }\n  identities.sort()\n  for edge in edges {\n    if moduleIndexes.containsKey(edge.from) && moduleIndexes.containsKey(edge.to) {\n      publicEdges.push(PreviewImportEdge { from: edge.from, to: edge.to })\n      match dependencies.get(edge.from) {\n        case Some(found) => {\n          let mut targets = found\n          targets.add(edge.to)\n        }\n        case None => ()\n      }\n      match dependents.get(edge.to) {\n        case Some(found) => {\n          let mut sources = found\n          sources.add(edge.from)\n        }\n        case None => ()\n      }\n    }\n  }\n  ModuleDependencyCatalog {\n    identities: identities,\n    moduleIndexes: moduleIndexes,\n    dependencies: dependencies,\n    dependents: dependents,\n    publicEdges: publicEdges,\n  }\n}\n\nfunction cycleFrom(\n  start: string,\n  current: string,\n  catalog: ModuleDependencyCatalog,\n  path: Array<string>,\n  visited: Set<string>,\n) -> Option<Array<string>> {\n  let mut targets = match catalog.dependencies.get(current) {\n    case Some(found) => found.toArray()\n    case None => []\n  }\n  targets.sort()\n  let mut activePath = path\n  let mut activeVisited = visited\n  for target in targets {\n    if target == start {\n      if path.length == 1 {\n        continue\n      }\n      let mut result: Array<string> = []\n      for item in path {\n        result.push(item)\n      }\n      result.push(start)\n      return Some(result)\n    }\n    if activeVisited.contains(target) {\n      continue\n    }\n    activePath.push(target)\n    activeVisited.add(target)\n    let found = cycleFrom(start, target, catalog, activePath, activeVisited)\n    activePath.pop()\n    activeVisited.remove(target)\n    match found {\n      case Some(result) => return Some(result)\n      case None => ()\n    }\n  }\n  None\n}\n\nfunction collectReachable(\n  current: string,\n  graph: Map<string, Set<string>>,\n  visited: Set<string>,\n) -> () {\n  let targets = match graph.get(current) {\n    case Some(found) => found\n    case None => return ()\n  }\n  let mut activeVisited = visited\n  for next in targets {\n    if !activeVisited.contains(next) {\n      activeVisited.add(next)\n      let _ = collectReachable(next, graph, activeVisited)\n    }\n  }\n  ()\n}\n\nfunction reachableFrom(\n  start: string,\n  graph: Map<string, Set<string>>,\n) -> Set<string> {\n  let mut reachable: Set<string> = set {}\n  reachable.add(start)\n  collectReachable(start, graph, reachable)\n  reachable\n}\n\nexport function diagnoseCycles(\n  catalog: ModuleDependencyCatalog,\n  edges: Array<EdgeDraft>,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  let mut covered: Set<string> = set {}\n  for identity in catalog.identities {\n    if covered.contains(identity) {\n      continue\n    }\n    let mut pathVisited: Set<string> = set {}\n    pathVisited.add(identity)\n    match cycleFrom(identity, identity, catalog, [identity], pathVisited) {\n      case Some(path) => {\n        let next = path[1]\n        let cycleText = stringJoin(path, \" -> \")\n        for edge in edges {\n          if edge.from == identity && edge.to == next {\n            diagnostic(\n              diagnostics,\n              edge.moduleIndex,\n              \"TPZ3006\",\n              \"import cycle: {cycleText}\",\n              edge.lo,\n              edge.hi,\n            )\n            break\n          }\n          ()\n        }\n        let forward = reachableFrom(identity, catalog.dependencies)\n        let reverse = reachableFrom(identity, catalog.dependents)\n        for candidate in catalog.identities {\n          if forward.contains(candidate) && reverse.contains(candidate) {\n            covered.add(candidate)\n          }\n        }\n        ()\n      }\n      case None => {\n        for edge in edges {\n          if edge.from == identity && edge.to == identity {\n            diagnostic(\n              diagnostics,\n              edge.moduleIndex,\n              \"TPZ3006\",\n              \"module imports itself: `{identity}`\",\n              edge.lo,\n              edge.hi,\n            )\n            covered.add(identity)\n            break\n          }\n          ()\n        }\n        ()\n      }\n    }\n    ()\n  }\n  ()\n}\n\nexport function pendingResult(queries: Array<PreviewHostQuery>) -> ResolveResult {\n  ResolveResult {\n    queries: sortQueries(queries),\n    modules: [],\n    edges: [],\n    scopes: [],\n    declarations: [],\n    references: [],\n    exports: [],\n    diagnostics: [],\n  }\n}\n\nexport function validateEntryPath(\n  entry: string,\n  root: string,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> bool {\n  let parentSegment = hasParentPathSegment(entry) || hasParentPathSegment(root)\n  let rootIsEntry = root != \"\" && entry == root\n  if parentSegment ||\n    rootIsEntry ||\n    (root != \"\" && !entry.startsWith(\"{root}/\")) {\n    diagnostic(\n      diagnostics,\n      0,\n      \"TPZ3002\",\n      if parentSegment {\n        \"entry and root paths must not contain parent (`..`) segments\"\n      } else if rootIsEntry {\n        \"the source root `{root}` must be a directory containing the entry, not the entry file itself\"\n      } else {\n        \"the root `{root}` does not contain the entry `{entry}`\"\n      },\n      0,\n      0,\n    )\n    return false\n  }\n  true\n}\n\nexport function validateEntryPhysicalContainment(\n  entry: string,\n  facts: ResolverHostFactCatalog,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> bool {\n  match sourceFact(facts, \"physical-containment\", entry) {\n    case Some(value) => if value.status == \"outside\" {\n      diagnostic(\n        diagnostics,\n        0,\n        \"TPZ3005\",\n        \"the entry `{entry}` resolves outside the root (symlink/alias containment)\",\n        0,\n        0,\n      )\n      false\n    } else {\n      true\n    }\n    case None => true\n  }\n}\n\nexport function readEntrySource(\n  entry: string,\n  facts: ResolverHostFactCatalog,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> Option<string> {\n  match sourceFact(facts, \"read-source\", entry) {\n    case Some(value) => if value.status == \"present\" {\n      Some(value.source)\n    } else if value.status == \"unreadable\" {\n      diagnostic(\n        diagnostics,\n        0,\n        \"TPZ3003\",\n        \"cannot load entry `{entry}`: {value.reasonCode}\",\n        0,\n        0,\n      )\n      None\n    } else if value.status == \"invalid-utf8\" {\n      diagnostic(\n        diagnostics,\n        0,\n        \"TPZ3003\",\n        \"cannot load entry `{entry}`: source is not valid UTF-8\",\n        0,\n        0,\n      )\n      None\n    } else {\n      diagnostic(\n        diagnostics,\n        0,\n        \"TPZ3001\",\n        \"entry file `{entry}` does not exist\",\n        0,\n        0,\n      )\n      None\n    }\n    case None => {\n      diagnostic(\n        diagnostics,\n        0,\n        \"TPZ3001\",\n        \"entry file `{entry}` does not exist\",\n        0,\n        0,\n      )\n      None\n    }\n  }\n}\n\nfunction validateImportedTopLevel(\n  module: ModuleDraft,\n  target: string,\n  moduleIndexValue: int,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  for statement in module.root.children {\n    let allowed = statement.kind == \"statement/import\" ||\n      statement.kind == \"statement/export\" ||\n      statement.kind == \"statement/function\" ||\n      statement.kind == \"statement/impl\" ||\n      statement.kind == \"statement/protocol\" ||\n      statement.kind == \"statement/type-alias\" ||\n      statement.kind == \"statement/enum\" ||\n      statement.kind == \"statement/record\" ||\n      statement.kind == \"statement/newtype\" ||\n      statement.kind == \"statement/let\" ||\n      statement.kind == \"statement/const\"\n    if !allowed {\n      diagnostic(\n        diagnostics,\n        moduleIndexValue,\n        \"TPZ3007\",\n        \"imported module `{target}` contains a top-level free statement; free statements are entry-only (the same file is valid as an entry)\",\n        statement.lo,\n        statement.hi,\n      )\n    }\n  }\n  ()\n}\n\nfunction recordImportEdge(\n  module: ModuleDraft,\n  moduleIndexValue: int,\n  import: ImportDraft,\n  importedHere: Array<string>,\n  edges: Array<EdgeDraft>,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> bool {\n  let firstSegment = match import.segments.get(0) {\n    case Some(value) => value\n    case None => \"\"\n  }\n  if firstSegment == \"topaz\" {\n    diagnostic(\n      diagnostics,\n      moduleIndexValue,\n      \"TPZ3016\",\n      \"the module path root `topaz` is reserved; user modules cannot live under it\",\n      import.pathLo,\n      import.pathHi,\n    )\n    return false\n  }\n  let mut graphEdges = edges\n  graphEdges.push(EdgeDraft {\n    from: module.result.identity,\n    to: import.target,\n    moduleIndex: moduleIndexValue,\n    lo: import.pathLo,\n    hi: import.pathHi,\n  })\n  if contains(importedHere, import.target) {\n    diagnostic(\n      diagnostics,\n      moduleIndexValue,\n      \"TPZ3017\",\n      \"`{import.target}` is already imported by this module; a logical module may appear in at most one import item\",\n      import.pathLo,\n      import.pathHi,\n    )\n    return false\n  }\n  let mut admitted = importedHere\n  admitted.push(import.target)\n  true\n}\n\nfunction reportImportDisposition(\n  inputs: ResolverInputs,\n  import: ImportDraft,\n  disposition: ImportPathDisposition,\n  moduleIndexValue: int,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  if disposition.kind == \"pending\" {\n    return ()\n  }\n  if disposition.kind == \"outside\" {\n    diagnostic(\n      diagnostics,\n      moduleIndexValue,\n      \"TPZ3005\",\n      \"`{import.target}` resolves outside the root (symlink/alias containment)\",\n      import.pathLo,\n      import.pathHi,\n    )\n    return ()\n  }\n  if disposition.kind == \"collision\" {\n    diagnostic(\n      diagnostics,\n      moduleIndexValue,\n      \"TPZ3004\",\n      \"the path `{import.target}` collides with another candidate under the module name keys{disposition.collisionDetail}\",\n      import.pathLo,\n      import.pathHi,\n    )\n    return ()\n  }\n  if disposition.kind == \"unreadable\" {\n    diagnostic(\n      diagnostics,\n      moduleIndexValue,\n      \"TPZ3003\",\n      \"cannot inspect module path for `{import.target}`: {disposition.collisionDetail}\",\n      import.pathLo,\n      import.pathHi,\n    )\n    return ()\n  }\n  if disposition.kind == \"source-unreadable\" ||\n    disposition.kind == \"source-invalid-utf8\" {\n    diagnostic(\n      diagnostics,\n      moduleIndexValue,\n      \"TPZ3003\",\n      if disposition.kind == \"source-invalid-utf8\" {\n        \"cannot load module `{import.target}`: source is not valid UTF-8\"\n      } else {\n        \"cannot load module `{import.target}`: {disposition.collisionDetail}\"\n      },\n      import.pathLo,\n      import.pathHi,\n    )\n    return ()\n  }\n  if disposition.kind == \"missing\" {\n    let standard = match import.segments.get(0) {\n      case Some(value) => value == \"std\"\n      case None => false\n    }\n    let externNamespace = !standard &&\n      isExternNamespace(inputs.externModules, import.target)\n    diagnostic(\n      diagnostics,\n      moduleIndexValue,\n      if externNamespace { \"TPZ5030\" } else { \"TPZ3001\" },\n      if externNamespace {\n        \"extern module `{import.target}` is not declared in topaz.toml\"\n      } else if standard {\n        \"no std module for `{import.target}` (expected virtual `{stringJoin(import.segments, \"/\")}.tpz`)\" + if inputs.languageMode == \"topaz-5.21\" { removedModuleHint(import.target) } else { \"\" }\n      } else {\n        \"no module file for `{import.target}` (expected `{modulePath(inputs.root, import.segments)}` by exact scalars)\"\n      },\n      import.pathLo,\n      import.pathHi,\n    )\n  }\n  ()\n}\n\nfunction loadImportedModule(\n  inputs: ResolverInputs,\n  import: ImportDraft,\n  prepared: PreparedImport,\n  moduleIndexValue: int,\n) -> Result<ModuleDraft, string> {\n  parseModule(\n    moduleIndexValue,\n    import.target,\n    prepared.path,\n    prepared.source,\n    false,\n    isExtern(inputs.externModules, import.target),\n    prepared.generatedStd,\n    inputs.maxAstNodes,\n    inputs.maxAstDepth,\n    inputs.languageMode,\n  )\n}\n\nexport function discoverModuleGraph(\n  entryDraft: ModuleDraft,\n  inputs: ResolverInputs,\n  queries: Array<PreviewHostQuery>,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> Result<DiscoveredGraph, string> {\n  let mut discovered: Array<ModuleDraft> = [entryDraft]\n  let mut queued: Set<string> = set { entryDraft.result.identity }\n  let mut physicalIdentities: Map<string, string> = map {}\n  match sourceFact(inputs.hostFacts, \"physical-containment\", entryDraft.result.path) {\n    case Some(fact) => if fact.status == \"inside\" && fact.aliasClass != \"\" {\n      physicalIdentities.insert(fact.aliasClass, entryDraft.result.identity)\n    }\n    case None => ()\n  }\n  appendModuleDiagnostics(diagnostics, 0, entryDraft.diagnostics)\n  let mut edges: Array<EdgeDraft> = []\n  let mut next = 0\n  while next < discovered.length {\n    let module = discovered[next]\n    let mut importedHere: Array<string> = []\n    for import in module.imports {\n      if !recordImportEdge(\n        module,\n        next,\n        import,\n        importedHere,\n        edges,\n        diagnostics,\n      ) {\n        continue\n      }\n      if queued.contains(import.target) {\n        continue\n      }\n      queued.add(import.target)\n      let generated = generatedStdModule(inputs.generatedStdModules, import.target)\n      match prepareImport(inputs, import, generated, queries) {\n        case Ok(prepared) => {\n          if prepared.physicalAlias != \"\" {\n            match physicalIdentities.get(prepared.physicalAlias) {\n              case Some(existing) => {\n                diagnostic(\n                  diagnostics,\n                  next,\n                  \"TPZ3004\",\n                  \"the modules `{existing}` and `{import.target}` resolve to the same physical file; one physical file cannot have two module identities\",\n                  import.pathLo,\n                  import.pathHi,\n                )\n                continue\n              }\n              case None => physicalIdentities.insert(prepared.physicalAlias, import.target)\n            }\n          }\n          let imported = loadImportedModule(\n            inputs,\n            import,\n            prepared,\n            discovered.length,\n          )?\n          let importedIndex = discovered.length\n          appendModuleDiagnostics(diagnostics, importedIndex, imported.diagnostics)\n          validateImportedTopLevel(imported, import.target, importedIndex, diagnostics)\n          discovered.push(imported)\n        }\n        case Err(disposition) => {\n          reportImportDisposition(\n            inputs,\n            import,\n            disposition,\n            next,\n            diagnostics,\n          )\n        }\n      }\n    }\n    next += 1\n  }\n  Ok(DiscoveredGraph {\n    modules: discovered,\n    edges: edges,\n  })\n}\n",
      "sourceSha256": "4c8c43e9336c2c298bf57693a38634368e000cd17d3d65f6842373fbbe54ebc3"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/resolver/model_facts.tpz",
      "language": "topaz",
      "bytes": 10788,
      "sha256": "fcca75169f6867a3581ad6b94f7d8f54d3f00a73b593fc4928d79b88b7665fda",
      "content": "// Data contracts for resolver drafts, tables, host facts, and outputs.\n// The records keep graph discovery and scope walking acyclic while the facade\n// retains ownership of the public ResolveResult.\n\nimport types {\n  PreviewDiagnostic,\n  PreviewGeneratedStdModule,\n  PreviewHostFact,\n  PreviewHostQuery,\n  PreviewImportEdge,\n  PreviewModuleResult,\n  PreviewResolvedDeclaration,\n  PreviewResolvedDiagnostic,\n  PreviewResolvedExport,\n  PreviewResolvedReference,\n  PreviewResolvedScope,\n  SyntaxNode,\n}\n\nexport record ImportDraft {\n  target: string,\n  segments: Array<string>,\n  pathLo: int,\n  pathHi: int,\n  selectedNames: Array<string>,\n  selectedLos: Array<int>,\n  selectedHis: Array<int>,\n}\n\nexport record EdgeDraft {\n  from: string,\n  to: string,\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n}\n\nexport record ModuleDraft {\n  result: PreviewModuleResult,\n  source: Bytes,\n  root: SyntaxNode,\n  imports: Array<ImportDraft>,\n  diagnostics: Array<PreviewDiagnostic>,\n}\n\nexport record Binding {\n  moduleIndex: int,\n  scopeOrdinal: int,\n  name: string,\n  namespace: string,\n  declarationKind: string,\n  lo: int,\n  hi: int,\n  exported: bool,\n  targetModule: string,\n  targetName: string,\n  mutable: bool,\n}\n\nexport record ExportBinding {\n  bindingIndex: int,\n  namespace: string,\n}\n\nexport record ModuleTable {\n  moduleIndex: int,\n  identity: string,\n  bindings: Array<Binding>,\n  bindingIndexes: Map<string, int>,\n  exportedBindings: Map<string, ExportBinding>,\n  exportedNames: Array<string>,\n}\n\nexport record ModuleTableCatalog {\n  tables: Array<ModuleTable>,\n  indexes: Map<string, int>,\n}\n\nexport record LocalScope {\n  ordinal: int,\n  values: Map<string, Binding>,\n  types: Map<string, Binding>,\n}\n\nexport record ResolverWalkContext {\n  moduleIndex: int,\n  source: Bytes,\n  table: ModuleTable,\n  tables: ModuleTableCatalog,\n  nextScope: Array<int>,\n  scopeOutput: Array<PreviewResolvedScope>,\n  declarationOutput: Array<PreviewResolvedDeclaration>,\n  referenceOutput: Array<PreviewResolvedReference>,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n  recordDefaultStack: Array<bool>,\n}\n\n// Admitted entry, mount, and host-fact view for one resolution pass.\nexport record ResolverInputs {\n  languageMode: string,\n  root: string,\n  hostFacts: ResolverHostFactCatalog,\n  externModules: Array<string>,\n  generatedStdModules: Array<PreviewGeneratedStdModule>,\n  maxAstNodes: int,\n  maxAstDepth: int,\n}\n\nexport record ResolverHostFactCatalog {\n  values: Array<PreviewHostFact>,\n  readSources: Map<string, int>,\n  directoryListings: Map<string, int>,\n  physicalContainments: Map<string, int>,\n  provider: Option<(PreviewHostQuery) -> Result<PreviewHostFact, string>>,\n  errors: Array<string>,\n}\n\n// Loaded module drafts and dependency edges before scope resolution.\nexport record DiscoveredGraph {\n  modules: Array<ModuleDraft>,\n  edges: Array<EdgeDraft>,\n}\n\nexport record ModuleDependencyCatalog {\n  identities: Array<string>,\n  moduleIndexes: Map<string, int>,\n  dependencies: Map<string, Set<string>>,\n  dependents: Map<string, Set<string>>,\n  publicEdges: Array<PreviewImportEdge>,\n}\n\n// Internal scope and reference catalogs used to build the public projection.\nexport record ResolverOutputs {\n  modules: Array<PreviewModuleResult>,\n  scopes: Array<PreviewResolvedScope>,\n  declarations: Array<PreviewResolvedDeclaration>,\n  references: Array<PreviewResolvedReference>,\n  exports: Array<PreviewResolvedExport>,\n}\n\n// This phase mirrors Stage 0 init_rule: it scans only\n// each imported item's own immediately evaluated positions. Short-circuit RHS,\n// optional-call arguments, and function, lambda, defer, branch, arm, and loop\n// bodies stay delayed; top-level consts are ready before runtime initialization\n// and the entry module has the separate §4 rule.\nexport record InitViolation {\n  name: string,\n  lo: int,\n  hi: int,\n}\n\nexport record ReferenceResolution {\n  referenceNamespace: string,\n  targetModuleIndex: int,\n  targetLo: int,\n  targetHi: int,\n  targetNamespace: string,\n  targetModule: string,\n  targetName: string,\n}\n\nexport record ImportPathDisposition {\n  kind: string,\n  collisionDetail: string,\n}\n\nexport record PreparedImport {\n  path: string,\n  source: string,\n  physicalAlias: string,\n  generatedStd: bool,\n}\nexport function text(source: Bytes, node: SyntaxNode) -> string {\n  spanText(source, node.lo, node.hi)\n}\n\nexport function child(value: SyntaxNode, field: string) -> Option<SyntaxNode> {\n  for found in value.children {\n    if found.field == field {\n      return Some(found)\n    }\n  }\n  None\n}\n\nexport function children(value: SyntaxNode, field: string) -> Array<SyntaxNode> {\n  let mut output: Array<SyntaxNode> = []\n  for found in value.children {\n    if found.field == field {\n      output.push(found)\n    }\n  }\n  output\n}\n\nexport function attribute(value: SyntaxNode, name: string) -> string {\n  for found in value.attributes {\n    if found.name == name {\n      return found.value\n    }\n  }\n  \"\"\n}\n\nexport function boolAttribute(value: SyntaxNode, name: string) -> bool {\n  attribute(value, name) == \"true\"\n}\n\nexport function contains(values: Array<string>, needle: string) -> bool {\n  for value in values {\n    if value == needle {\n      return true\n    }\n  }\n  false\n}\n\nexport function hasParentPathSegment(path: string) -> bool {\n  for segment in path.split(\"/\") {\n    if segment == \"..\" {\n      return true\n    }\n  }\n  false\n}\n\nexport function isNone<T>(value: Option<T>) -> bool {\n  match value {\n    case Some(_) => false\n    case None => true\n  }\n}\n\nexport function stringJoin(values: Array<string>, separator: string) -> string {\n  let mut output = \"\"\n  let mut index = 0\n  for value in values {\n    if index > 0 {\n      output = \"{output}{separator}\"\n    }\n    output = \"{output}{value}\"\n    index += 1\n  }\n  output\n}\n\nexport function pathJoin(left: string, right: string) -> string {\n  if left == \"\" {\n    right\n  } else {\n    \"{left}/{right}\"\n  }\n}\n\nexport function resolverHostFacts(\n  facts: Array<PreviewHostFact>,\n) -> ResolverHostFactCatalog {\n  let mut readSources: Map<string, int> = map {}\n  let mut directoryListings: Map<string, int> = map {}\n  let mut physicalContainments: Map<string, int> = map {}\n  let mut index = 0\n  for fact in facts {\n    if fact.mountId == \"root\" {\n      if fact.kind == \"read-source\" &&\n        !readSources.containsKey(fact.logicalPath) {\n        readSources.insert(fact.logicalPath, index)\n      } else if fact.kind == \"list-directory\" &&\n        !directoryListings.containsKey(fact.logicalPath) {\n        directoryListings.insert(fact.logicalPath, index)\n      } else if fact.kind == \"physical-containment\" &&\n        !physicalContainments.containsKey(fact.logicalPath) {\n        physicalContainments.insert(fact.logicalPath, index)\n      }\n    }\n    index += 1\n  }\n  ResolverHostFactCatalog {\n    values: facts,\n    readSources: readSources,\n    directoryListings: directoryListings,\n    physicalContainments: physicalContainments,\n    provider: None,\n    errors: [],\n  }\n}\n\nexport function sourceFact(\n  facts: ResolverHostFactCatalog,\n  kind: string,\n  path: string,\n) -> Option<PreviewHostFact> {\n  let index = if kind == \"read-source\" {\n    facts.readSources.get(path)\n  } else if kind == \"list-directory\" {\n    facts.directoryListings.get(path)\n  } else if kind == \"physical-containment\" {\n    facts.physicalContainments.get(path)\n  } else {\n    None\n  }\n  match index {\n    case Some(value) => Some(facts.values[value])\n    case None => None\n  }\n}\n\nexport function addQuery(\n  output: Array<PreviewHostQuery>,\n  catalog: ResolverHostFactCatalog,\n  kind: string,\n  path: string,\n) -> () {\n  let mut facts = catalog\n  let mut target = output\n  match sourceFact(facts, kind, path) {\n    case Some(_) => return ()\n    case None => ()\n  }\n  for query in output {\n    if query.kind == kind && query.mountId == \"root\" && query.logicalPath == path {\n      return ()\n    }\n  }\n  let query = PreviewHostQuery {\n    kind: kind,\n    mountId: \"root\",\n    logicalPath: path,\n  }\n  match facts.provider {\n    case Some(provide) => {\n      if facts.errors.length > 0 { return () }\n      match provide(query) {\n        case Ok(fact) => {\n          if fact.kind != query.kind || fact.mountId != query.mountId ||\n            fact.logicalPath != query.logicalPath {\n            facts.errors.push(\"host fact does not answer the requested query\")\n            return ()\n          }\n          let index = facts.values.length\n          facts.values.push(fact)\n          if kind == \"read-source\" {\n            facts.readSources.insert(path, index)\n          } else if kind == \"list-directory\" {\n            facts.directoryListings.insert(path, index)\n          } else {\n            facts.physicalContainments.insert(path, index)\n          }\n        }\n        case Err(error) => facts.errors.push(error)\n      }\n    }\n    case None => target.push(query)\n  }\n}\n\nfunction queryRank(kind: string) -> int {\n  match kind {\n    case \"read-source\" => 0\n    case \"list-directory\" => 1\n    case \"physical-containment\" => 2\n    case _ => 3\n  }\n}\n\nfunction queryBefore(left: PreviewHostQuery, right: PreviewHostQuery) -> bool {\n  let leftRank = queryRank(left.kind)\n  let rightRank = queryRank(right.kind)\n  leftRank < rightRank ||\n    (leftRank == rightRank && left.mountId < right.mountId) ||\n    (leftRank == rightRank && left.mountId == right.mountId &&\n      left.logicalPath < right.logicalPath)\n}\n\nexport function sortQueries(values: Array<PreviewHostQuery>) -> Array<PreviewHostQuery> {\n  let mut output: Array<PreviewHostQuery> = []\n  for value in values {\n    let mut inserted = false\n    let mut index = 0\n    while index < output.length {\n      let existing = output[index]\n      if queryBefore(value, existing) {\n        output.insert(index, value)\n        inserted = true\n        break\n      }\n      index += 1\n    }\n    if !inserted {\n      output.push(value)\n    }\n  }\n  output\n}\n\nexport function diagnostic(\n  output: Array<PreviewResolvedDiagnostic>,\n  moduleIndex: int,\n  code: string,\n  message: string,\n  lo: int,\n  hi: int,\n) -> () {\n  let mut target = output\n  target.push(PreviewResolvedDiagnostic {\n    moduleIndex: moduleIndex,\n    code: code,\n    message: message,\n    lo: lo,\n    hi: hi,\n    notes: [],\n  })\n}\n\nexport function appendModuleDiagnostics(\n  output: Array<PreviewResolvedDiagnostic>,\n  moduleIndexValue: int,\n  values: Array<PreviewDiagnostic>,\n) -> () {\n  for value in values {\n    let mut target = output\n    target.push(PreviewResolvedDiagnostic {\n      moduleIndex: moduleIndexValue,\n      code: value.code,\n      message: value.message,\n      lo: value.lo,\n      hi: value.hi,\n      notes: value.notes,\n    })\n  }\n  ()\n}\n\nexport function spanText(source: Bytes, lo: int, hi: int) -> string {\n  match source.slice(lo, hi).decodeUtf8() {\n    case Ok(found) => found\n    case Err(_) => \"\"\n  }\n}\n",
      "sourceSha256": "8aefd2eac6b4d40c8fd3b6cd6ba90181b59807d61dac6af85afb617564a9b222"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/resolver/modules_tables.tpz",
      "language": "topaz",
      "bytes": 12461,
      "sha256": "220ebdf4288adbe9ed0670c47898b552664161f6a72576cd5e9ad03d5aa4b0fe",
      "content": "// Import drafts and module binding and export tables.\n// Graph discovery provides parsed roots; scope walking consumes the canonical\n// table catalog produced here.\n\nimport types {\n  PreviewResolvedDiagnostic,\n  PreviewResolvedExport,\n  SyntaxNode,\n}\nimport resolver.model_facts {\n  Binding,\n  ExportBinding,\n  ImportDraft,\n  ModuleDraft,\n  ModuleTable,\n  ModuleTableCatalog,\n  boolAttribute,\n  child,\n  children,\n  contains,\n  diagnostic,\n  isNone,\n  stringJoin,\n  text,\n}\n\nexport function importDrafts(root: SyntaxNode, source: Bytes) -> Array<ImportDraft> {\n  let mut output: Array<ImportDraft> = []\n  for statement in root.children {\n    if statement.kind != \"statement/import\" {\n      continue\n    }\n    let itemOption = child(statement, \"import\")\n    if isNone(itemOption) {\n      continue\n    }\n    let item = match itemOption {\n      case Some(value) => value\n      case None => statement\n    }\n    let pathOption = child(item, \"path\")\n    if isNone(pathOption) {\n      continue\n    }\n    let path = match pathOption {\n      case Some(value) => value\n      case None => item\n    }\n    let mut segments: Array<string> = []\n    for segment in children(path, \"segments\") {\n      segments.push(text(source, segment))\n    }\n    let mut selectedNames: Array<string> = []\n    let mut selectedLos: Array<int> = []\n    let mut selectedHis: Array<int> = []\n    for spec in children(item, \"specs\") {\n      let nameNode = child(spec, \"name\")\n      let name = match nameNode {\n        case Some(value) => text(source, value)\n        case None => \"\"\n      }\n      selectedNames.push(name)\n      selectedLos.push(match nameNode {\n        case Some(value) => value.lo\n        case None => spec.lo\n      })\n      selectedHis.push(match nameNode {\n        case Some(value) => value.hi\n        case None => spec.hi\n      })\n    }\n    output.push(ImportDraft {\n      target: stringJoin(segments, \".\"),\n      segments: segments,\n      pathLo: path.lo,\n      pathHi: path.hi,\n      selectedNames: selectedNames,\n      selectedLos: selectedLos,\n      selectedHis: selectedHis,\n    })\n  }\n  output\n}\n\nexport function collectPatternBindings(\n  pattern: SyntaxNode,\n  source: Bytes,\n  output: Array<SyntaxNode>,\n) -> () {\n  let mut target = output\n  if pattern.kind == \"pattern/binding\" || pattern.kind == \"pattern/typed\" {\n    match child(pattern, \"name\") {\n      case Some(name) => target.push(name)\n      case None => ()\n    }\n    return ()\n  }\n  if pattern.kind == \"record-pattern-field\" {\n    match child(pattern, \"pattern\") {\n      case Some(value) => collectPatternBindings(value, source, output)\n      case None => match child(pattern, \"name\") {\n        case Some(name) => target.push(name)\n        case None => ()\n      }\n    }\n    return ()\n  }\n  let mut alternatives: Array<string> = []\n  for found in pattern.children {\n    if pattern.kind == \"pattern/or\" && found.field == \"alternatives\" {\n      let mut local: Array<SyntaxNode> = []\n      collectPatternBindings(found, source, local)\n      let mut seenHere: Array<string> = []\n      for binding in local {\n        let name = text(source, binding)\n        let repeatedHere = contains(seenHere, name)\n        let firstAlternative = !contains(alternatives, name)\n        if repeatedHere || firstAlternative {\n          target.push(binding)\n        }\n        if !repeatedHere {\n          seenHere.push(name)\n        }\n        if firstAlternative {\n          alternatives.push(name)\n        }\n      }\n    } else if found.kind.startsWith(\"pattern/\") ||\n      found.kind == \"record-pattern-field\" ||\n      found.kind == \"list-pattern/rest\" {\n      collectPatternBindings(found, source, output)\n    }\n    ()\n  }\n  ()\n}\n\nexport function unwrapExport(statement: SyntaxNode) -> SyntaxNode {\n  if statement.kind == \"statement/export\" {\n    return match child(statement, \"item\") {\n      case Some(value) => value\n      case None => statement\n    }\n  }\n  statement\n}\n\nfunction importBindings(\n  moduleIndexValue: int,\n  item: SyntaxNode,\n  source: Bytes,\n) -> Array<Binding> {\n  let mut output: Array<Binding> = []\n  let importItem = match child(item, \"import\") {\n    case Some(value) => value\n    case None => return output\n  }\n  let path = match child(importItem, \"path\") {\n    case Some(value) => value\n    case None => return output\n  }\n  let mut segments: Array<string> = []\n  for segment in children(path, \"segments\") {\n    segments.push(text(source, segment))\n  }\n  let target = stringJoin(segments, \".\")\n  let specs = children(importItem, \"specs\")\n  if specs.length == 0 {\n    let nameNode = match child(importItem, \"alias\") {\n      case Some(value) => value\n      case None => match path.children.get(path.children.length - 1) {\n        case Some(value) => value\n        case None => return output\n      }\n    }\n    output.push(Binding {\n      moduleIndex: moduleIndexValue,\n      scopeOrdinal: 0,\n      name: text(source, nameNode),\n      namespace: \"module\",\n      declarationKind: \"namespace-import\",\n      lo: nameNode.lo,\n      hi: nameNode.hi,\n      exported: false,\n      targetModule: target,\n      targetName: \"\",\n      mutable: false,\n    })\n    return output\n  }\n  for spec in specs {\n    let sourceName = match child(spec, \"name\") {\n      case Some(value) => text(source, value)\n      case None => \"\"\n    }\n    let bound = match child(spec, \"alias\") {\n      case Some(value) => Some(value)\n      case None => child(spec, \"name\")\n    }\n    match bound {\n      case Some(name) => output.push(Binding {\n        moduleIndex: moduleIndexValue,\n        scopeOrdinal: 0,\n        name: text(source, name),\n        namespace: \"value\",\n        declarationKind: \"selected-import\",\n        lo: name.lo,\n        hi: name.hi,\n        exported: false,\n        targetModule: target,\n        targetName: sourceName,\n        mutable: false,\n      })\n      case None => ()\n    }\n  }\n  output\n}\n\nfunction namedStatementBinding(\n  moduleIndexValue: int,\n  item: SyntaxNode,\n  source: Bytes,\n  exported: bool,\n) -> Option<Binding> {\n  let kind = match item.kind {\n    case \"statement/function\" => \"function\"\n    case \"statement/type-alias\" => \"type-alias\"\n    case \"statement/enum\" | \"statement/record\" | \"statement/newtype\" =>\n      \"nominal-type\"\n    case \"statement/const\" => \"const\"\n    case _ => return None\n  }\n  let holder = if item.kind == \"statement/function\" {\n    match child(item, \"declaration\") {\n      case Some(value) => value\n      case None => item\n    }\n  } else {\n    item\n  }\n  match child(holder, \"name\") {\n    case Some(name) => Some(Binding {\n      moduleIndex: moduleIndexValue,\n      scopeOrdinal: 0,\n      name: text(source, name),\n      namespace: if kind == \"type-alias\" || kind == \"nominal-type\" {\n        \"type\"\n      } else {\n        \"value\"\n      },\n      declarationKind: kind,\n      lo: name.lo,\n      hi: name.hi,\n      exported: exported,\n      targetModule: \"\",\n      targetName: \"\",\n      mutable: false,\n    })\n    case None => None\n  }\n}\n\nfunction letBindings(\n  moduleIndexValue: int,\n  item: SyntaxNode,\n  source: Bytes,\n  exported: bool,\n) -> Array<Binding> {\n  let mut output: Array<Binding> = []\n  let pattern = match child(item, \"pattern\") {\n    case Some(value) => value\n    case None => return output\n  }\n  let mut names: Array<SyntaxNode> = []\n  collectPatternBindings(pattern, source, names)\n  let mutable = boolAttribute(item, \"mutable\")\n  for name in names {\n    output.push(Binding {\n      moduleIndex: moduleIndexValue,\n      scopeOrdinal: 0,\n      name: text(source, name),\n      namespace: \"value\",\n      declarationKind: \"let\",\n      lo: name.lo,\n      hi: name.hi,\n      exported: exported && !mutable,\n      targetModule: \"\",\n      targetName: \"\",\n      mutable: mutable,\n    })\n  }\n  output\n}\n\nexport function bindingForStatement(\n  moduleIndexValue: int,\n  statement: SyntaxNode,\n  source: Bytes,\n  exported: bool,\n) -> Array<Binding> {\n  let item = unwrapExport(statement)\n  if item.kind == \"statement/import\" {\n    return importBindings(moduleIndexValue, item, source)\n  }\n  match namedStatementBinding(moduleIndexValue, item, source, exported) {\n    case Some(binding) => return [binding]\n    case None => ()\n  }\n  if item.kind == \"statement/let\" {\n    return letBindings(moduleIndexValue, item, source, exported)\n  }\n  []\n}\n\nfunction buildTable(\n  moduleIndexValue: int,\n  module: ModuleDraft,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> ModuleTable {\n  let source = module.source\n  let mut bindings: Array<Binding> = []\n  let mut bindingIndexes: Map<string, int> = map {}\n  let mut exportedBindings: Map<string, ExportBinding> = map {}\n  for statement in module.root.children {\n    let exported = statement.kind == \"statement/export\"\n    for binding in bindingForStatement(moduleIndexValue, statement, source, exported) {\n      let existingIndex = bindingIndexes.get(binding.name)\n      if exported && binding.declarationKind == \"let\" && binding.mutable {\n        diagnostic(\n          diagnostics,\n          moduleIndexValue,\n          \"TPZ3011\",\n          \"`export let mut` is a static error: exported bindings are immutable views\",\n          binding.lo,\n          binding.hi,\n        )\n      }\n      if binding.exported {\n        let exportIndex = match existingIndex {\n          case Some(index) => index\n          case None => bindings.length\n        }\n        exportedBindings.insert(binding.name, ExportBinding {\n          bindingIndex: exportIndex,\n          namespace: binding.namespace,\n        })\n      }\n      match existingIndex {\n        case Some(index) => {\n          let firstLo = bindings[index].lo\n          diagnostic(\n            diagnostics,\n            moduleIndexValue,\n            \"TPZ3008\",\n            \"`{binding.name}` is already bound at this module's top level (first binding at byte {firstLo})\",\n            binding.lo,\n            binding.hi,\n          )\n        }\n        case None => {\n          let bindingIndexValue = bindings.length\n          bindingIndexes.insert(binding.name, bindingIndexValue)\n          bindings.push(binding)\n        }\n      }\n    }\n  }\n  let mut exportedNames: Array<string> = []\n  for binding in bindings {\n    if !isNone(exportedBindings.get(binding.name)) {\n      exportedNames.push(binding.name)\n    }\n  }\n  exportedNames.sort()\n  ModuleTable {\n    moduleIndex: moduleIndexValue,\n    identity: module.result.identity,\n    bindings: bindings,\n    bindingIndexes: bindingIndexes,\n    exportedBindings: exportedBindings,\n    exportedNames: exportedNames,\n  }\n}\n\nexport function catalogTable(\n  catalog: ModuleTableCatalog,\n  identity: string,\n) -> Option<ModuleTable> {\n  match catalog.indexes.get(identity) {\n    case Some(index) => Some(catalog.tables[index])\n    case None => None\n  }\n}\n\nexport function tableBinding(table: ModuleTable, name: string) -> Option<Binding> {\n  match table.bindingIndexes.get(name) {\n    case Some(index) => Some(table.bindings[index])\n    case None => None\n  }\n}\n\nexport function exportedBinding(table: ModuleTable, name: string) -> Option<ExportBinding> {\n  table.exportedBindings.get(name)\n}\n\nexport function exportedNames(\n  table: ModuleTable,\n  namespace: string,\n) -> Array<string> {\n  if namespace == \"\" {\n    return table.exportedNames\n  }\n  let mut candidates: Array<string> = []\n  for name in table.exportedNames {\n    let namespaceValue = match exportedBinding(table, name) {\n      case Some(binding) => binding.namespace\n      case None => \"\"\n    }\n    if (namespace == \"type\" && namespaceValue == \"type\") ||\n      (namespace == \"value\" && namespaceValue != \"type\") {\n      candidates.push(name)\n    }\n  }\n  candidates\n}\n\nexport function effectiveNamespace(binding: Binding, tables: ModuleTableCatalog) -> string {\n  if binding.declarationKind != \"selected-import\" {\n    return binding.namespace\n  }\n  let targetTable = match catalogTable(tables, binding.targetModule) {\n    case Some(found) => found\n    case None => return binding.namespace\n  }\n  match exportedBinding(targetTable, binding.targetName) {\n    case Some(found) => found.namespace\n    case None => binding.namespace\n  }\n}\n\nexport function buildModuleTables(\n  modules: Array<ModuleDraft>,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> ModuleTableCatalog {\n  let mut tables: Array<ModuleTable> = []\n  let mut indexes: Map<string, int> = map {}\n  let mut index = 0\n  for module in modules {\n    indexes.insert(module.result.identity, index)\n    tables.push(buildTable(index, module, diagnostics))\n    index += 1\n  }\n  ModuleTableCatalog { tables: tables, indexes: indexes }\n}\n",
      "sourceSha256": "220ebdf4288adbe9ed0670c47898b552664161f6a72576cd5e9ad03d5aa4b0fe"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/resolver/scopes_walk.tpz",
      "language": "topaz",
      "bytes": 29435,
      "sha256": "5abef63784bb71504858d07e806a0c7512f274f0becb44caa3a5045c56b59ae4",
      "content": "// Lexical scope construction and resolved-reference traversal.\n// Module tables define cross-file bindings, while this leaf owns local scopes,\n// declarations, captures, and reference observations.\n\nimport raw { keywordKind }\nimport types {\n  PreviewResolvedDeclaration,\n  PreviewResolvedExport,\n  PreviewResolvedReference,\n  PreviewResolvedScope,\n  SyntaxNode,\n}\nimport unicode { didYouMean }\nimport resolver.model_facts {\n  Binding,\n  LocalScope,\n  ModuleTable,\n  ReferenceResolution,\n  ResolverWalkContext,\n  boolAttribute,\n  child,\n  children,\n  diagnostic,\n  isNone,\n  text,\n}\nimport resolver.modules_tables {\n  bindingForStatement,\n  catalogTable,\n  collectPatternBindings,\n  effectiveNamespace,\n  exportedBinding,\n  exportedNames,\n  tableBinding,\n}\n\nfunction localBinding(scopes: Array<LocalScope>, name: string, namespace: string) -> Option<Binding> {\n  let mut index = scopes.length\n  while index > 0 {\n    index -= 1\n    let scope = scopes[index]\n    let bindings = if namespace == \"type\" { scope.types } else { scope.values }\n    match bindings.get(name) {\n      case Some(binding) => return Some(binding)\n      case None => ()\n    }\n  }\n  None\n}\n\nfunction currentScope(scopes: Array<LocalScope>) -> int {\n  if scopes.length == 0 {\n    return 0\n  }\n  scopes[scopes.length - 1].ordinal\n}\n\nexport function addDeclaration(\n  output: Array<PreviewResolvedDeclaration>,\n  binding: Binding,\n  namespace: string,\n  exported: bool,\n) -> () {\n  let mut target = output\n  target.push(PreviewResolvedDeclaration {\n    moduleIndex: binding.moduleIndex,\n    scopeOrdinal: binding.scopeOrdinal,\n    name: binding.name,\n    namespace: namespace,\n    declarationKind: binding.declarationKind,\n    lo: binding.lo,\n    hi: binding.hi,\n    exported: exported,\n    targetModule: binding.targetModule,\n    targetName: binding.targetName,\n  })\n}\n\nfunction addLocalBinding(\n  scopes: Array<LocalScope>,\n  declarations: Array<PreviewResolvedDeclaration>,\n  binding: Binding,\n) -> () {\n  let mut activeScopes = scopes\n  let scope = activeScopes[activeScopes.length - 1]\n  if binding.namespace == \"type\" {\n    let mut types = scope.types\n    types.insert(binding.name, binding)\n  } else {\n    let mut values = scope.values\n    values.insert(binding.name, binding)\n  }\n  addDeclaration(\n    declarations,\n    binding,\n    binding.namespace,\n    binding.exported,\n  )\n}\n\nexport function appendModuleExports(\n  output: Array<PreviewResolvedExport>,\n  moduleIndexValue: int,\n  table: ModuleTable,\n) -> () {\n  let mut target = output\n  for name in exportedNames(table, \"\") {\n    match exportedBinding(table, name) {\n      case Some(exported) => {\n        let binding = table.bindings[exported.bindingIndex]\n        target.push(PreviewResolvedExport {\n          moduleIndex: moduleIndexValue,\n          name: name,\n          namespace: exported.namespace,\n          declarationLo: binding.lo,\n          declarationHi: binding.hi,\n        })\n      }\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction unresolvedReference(namespace: string) -> ReferenceResolution {\n  ReferenceResolution {\n    referenceNamespace: namespace,\n    targetModuleIndex: -1,\n    targetLo: 0,\n    targetHi: 0,\n    targetNamespace: \"\",\n    targetModule: \"\",\n    targetName: \"\",\n  }\n}\n\nfunction appendReference(\n  context: ResolverWalkContext,\n  scopes: Array<LocalScope>,\n  name: string,\n  role: string,\n  lo: int,\n  hi: int,\n  resolved: ReferenceResolution,\n) -> () {\n  let mut output = context.referenceOutput\n  output.push(PreviewResolvedReference {\n    moduleIndex: context.moduleIndex,\n    scopeOrdinal: currentScope(scopes),\n    name: name,\n    namespace: resolved.referenceNamespace,\n    role: role,\n    lo: lo,\n    hi: hi,\n    targetModuleIndex: resolved.targetModuleIndex,\n    targetLo: resolved.targetLo,\n    targetHi: resolved.targetHi,\n    targetNamespace: resolved.targetNamespace,\n    targetModule: resolved.targetModule,\n    targetName: resolved.targetName,\n  })\n}\n\nfunction localReferenceResolution(\n  context: ResolverWalkContext,\n  scopes: Array<LocalScope>,\n  name: string,\n  namespace: string,\n) -> Option<ReferenceResolution> {\n  match localBinding(scopes, name, namespace) {\n    case Some(target) => Some(ReferenceResolution {\n      referenceNamespace: namespace,\n      targetModuleIndex: context.moduleIndex,\n      targetLo: target.lo,\n      targetHi: target.hi,\n      targetNamespace: target.namespace,\n      targetModule: context.table.identity,\n      targetName: name,\n    })\n    case None => None\n  }\n}\n\nfunction moduleReferenceResolution(\n  context: ResolverWalkContext,\n  found: Binding,\n  name: string,\n  namespace: string,\n  role: string,\n) -> ReferenceResolution {\n  if found.declarationKind == \"selected-import\" {\n    return ReferenceResolution {\n      referenceNamespace: namespace,\n      targetModuleIndex: context.moduleIndex,\n      targetLo: found.lo,\n      targetHi: found.hi,\n      targetNamespace: if role == \"type\" {\n        namespace\n      } else {\n        effectiveNamespace(found, context.tables)\n      },\n      targetModule: if role == \"type\" {\n        context.table.identity\n      } else {\n        found.targetModule\n      },\n      targetName: if role == \"type\" { name } else { found.targetName },\n    }\n  } else if found.declarationKind == \"namespace-import\" {\n    return ReferenceResolution {\n      referenceNamespace: \"module\",\n      targetModuleIndex: context.moduleIndex,\n      targetLo: found.lo,\n      targetHi: found.hi,\n      targetNamespace: found.namespace,\n      targetModule: found.targetModule,\n      targetName: \"\",\n    }\n  }\n  ReferenceResolution {\n    referenceNamespace: namespace,\n    targetModuleIndex: context.moduleIndex,\n    targetLo: found.lo,\n    targetHi: found.hi,\n    targetNamespace: found.namespace,\n    targetModule: context.table.identity,\n    targetName: name,\n  }\n}\n\nfunction reference(\n  context: ResolverWalkContext,\n  scopes: Array<LocalScope>,\n  name: string,\n  namespace: string,\n  role: string,\n  lo: int,\n  hi: int,\n) -> Option<Binding> {\n  let mut moduleBinding: Option<Binding> = None\n  let resolved = match localReferenceResolution(\n    context,\n    scopes,\n    name,\n    namespace,\n  ) {\n    case Some(value) => value\n    case None => match tableBinding(context.table, name) {\n      case Some(binding) => {\n        moduleBinding = Some(binding)\n        moduleReferenceResolution(\n          context,\n          binding,\n          name,\n          namespace,\n          role,\n        )\n      }\n      case None => unresolvedReference(namespace)\n    }\n  }\n  appendReference(context, scopes, name, role, lo, hi, resolved)\n  moduleBinding\n}\n\nfunction namespaceMemberResolution(\n  context: ResolverWalkContext,\n  binding: Binding,\n  member: string,\n  namespace: string,\n  field: SyntaxNode,\n) -> ReferenceResolution {\n  let targetTable = match catalogTable(context.tables, binding.targetModule) {\n    case Some(found) => found\n    case None => return unresolvedReference(namespace)\n  }\n  let targetBinding = tableBinding(targetTable, member)\n  let targetExport = exportedBinding(targetTable, member)\n  let targetNamespace = match targetExport {\n    case Some(exported) => exported.namespace\n    case None => \"\"\n  }\n  let memberExported = !isNone(targetExport)\n  let keywordNamed = namespace == \"value\" &&\n    keywordKind(member).startsWith(\"keyword/\")\n  if keywordNamed {\n    diagnostic(\n      context.diagnostics,\n      context.moduleIndex,\n      \"TPZ3013\",\n      \"namespace members are exported declarations and cannot be keyword-named (`{binding.name}.{member}`)\",\n      field.lo,\n      field.hi,\n    )\n  } else if !memberExported {\n    let mut recordDefaultPrivateValue = false\n    if namespace == \"value\" && context.recordDefaultStack.length > 0 {\n      match targetBinding {\n        case Some(privateBinding) => if privateBinding.declarationKind == \"let\" &&\n          !privateBinding.mutable && !privateBinding.exported {\n          recordDefaultPrivateValue = true\n        }\n        case None => ()\n      }\n    }\n    if !recordDefaultPrivateValue {\n      let hint = didYouMean(\n        member,\n        exportedNames(targetTable, namespace),\n      )\n      diagnostic(\n        context.diagnostics,\n        context.moduleIndex,\n        \"TPZ3009\",\n        \"`{member}` is not exported by `{binding.targetModule}`{hint}\",\n        field.lo,\n        field.hi,\n      )\n    }\n  }\n  let target = match targetBinding {\n    case Some(found) => found\n    case None => return unresolvedReference(namespace)\n  }\n  // Nominal constructor heads retain their type-space declaration identity.\n  // Pure aliases remain forbidden as values; construction is checked later.\n  if !keywordNamed && memberExported && namespace == \"value\" &&\n    targetNamespace == \"type\" && target.declarationKind != \"nominal-type\" {\n    diagnostic(\n      context.diagnostics,\n      context.moduleIndex,\n      \"TPZ3013\",\n      \"`{member}` is an exported type alias of `{binding.targetModule}`, not a value; use it in type position\",\n      field.lo,\n      field.hi,\n    )\n  } else if !keywordNamed && memberExported && namespace == \"type\" &&\n    targetNamespace != \"type\" {\n    diagnostic(\n      context.diagnostics,\n      context.moduleIndex,\n      \"TPZ3013\",\n      \"`{member}` is exported by `{binding.targetModule}` but is not a type alias\",\n      field.lo,\n      field.hi,\n    )\n  }\n  ReferenceResolution {\n    referenceNamespace: namespace,\n    targetModuleIndex: target.moduleIndex,\n    targetLo: target.lo,\n    targetHi: target.hi,\n    targetNamespace: if namespace == \"type\" || targetNamespace == \"type\" {\n      \"type\"\n    } else {\n      \"value\"\n    },\n    targetModule: binding.targetModule,\n    targetName: member,\n  }\n}\n\nfunction namespaceMember(\n  context: ResolverWalkContext,\n  scopes: Array<LocalScope>,\n  object: SyntaxNode,\n  field: SyntaxNode,\n  namespace: string,\n  role: string,\n) -> bool {\n  let head = text(context.source, object)\n  if match localBinding(scopes, head, \"value\") {\n    case Some(_) => true\n    case None => false\n  } {\n    return false\n  }\n  let binding = match tableBinding(context.table, head) {\n    case Some(found) => found\n    case None => return false\n  }\n  if binding.declarationKind != \"namespace-import\" {\n    return false\n  }\n  let member = text(context.source, field)\n  let resolved = namespaceMemberResolution(\n    context,\n    binding,\n    member,\n    namespace,\n    field,\n  )\n  appendReference(\n    context,\n    scopes,\n    \"{head}.{member}\",\n    role,\n    field.lo,\n    field.hi,\n    resolved,\n  )\n  true\n}\n\nfunction pushScope(\n  moduleIndexValue: int,\n  owner: SyntaxNode,\n  kind: string,\n  scopes: Array<LocalScope>,\n  nextScope: Array<int>,\n  output: Array<PreviewResolvedScope>,\n) -> int {\n  let ordinal = nextScope[0]\n  let mut nextScopeBox = nextScope\n  nextScopeBox[0] = ordinal + 1\n  let mut rows = output\n  rows.push(PreviewResolvedScope {\n    moduleIndex: moduleIndexValue,\n    ordinal: ordinal,\n    parentOrdinal: currentScope(scopes),\n    kind: kind,\n    lo: owner.lo,\n    hi: owner.hi,\n  })\n  let mut active = scopes\n  active.push(LocalScope {\n    ordinal: ordinal,\n    values: map {},\n    types: map {},\n  })\n  ordinal\n}\n\nfunction popScope(scopes: Array<LocalScope>) -> () {\n  let mut activeScopes = scopes\n  match activeScopes.pop() {\n    case Some(_) => ()\n    case None => ()\n  }\n}\n\nfunction bindPattern(\n  moduleIndexValue: int,\n  pattern: SyntaxNode,\n  source: Bytes,\n  declarationKind: string,\n  scopes: Array<LocalScope>,\n  declarations: Array<PreviewResolvedDeclaration>,\n) -> () {\n  let mut names: Array<SyntaxNode> = []\n  collectPatternBindings(pattern, source, names)\n  for name in names {\n    addLocalBinding(scopes, declarations, Binding {\n      moduleIndex: moduleIndexValue,\n      scopeOrdinal: currentScope(scopes),\n      name: text(source, name),\n      namespace: \"value\",\n      declarationKind: declarationKind,\n      lo: name.lo,\n      hi: name.hi,\n      exported: false,\n      targetModule: \"\",\n      targetName: \"\",\n      mutable: false,\n    })\n  }\n  ()\n}\n\nfunction walkProtocolStatement(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  match child(node, \"name\") {\n    case Some(name) => {\n      let protocolName = text(context.source, name)\n      let alreadyBound = match localBinding(scopes, protocolName, \"type\") {\n        case Some(binding) => binding.scopeOrdinal == currentScope(scopes) &&\n          binding.lo == name.lo && binding.hi == name.hi\n        case None => false\n      }\n      if !alreadyBound {\n        let mut declarations = context.declarationOutput\n        declarations.push(PreviewResolvedDeclaration {\n          moduleIndex: context.moduleIndex,\n          scopeOrdinal: currentScope(scopes),\n          name: protocolName,\n          namespace: \"type\",\n          declarationKind: \"protocol\",\n          lo: name.lo,\n          hi: name.hi,\n          exported: false,\n          targetModule: \"\",\n          targetName: \"\",\n        })\n      }\n    }\n    case None => ()\n  }\n  for method in children(node, \"methods\") {\n    for parameter in children(method, \"parameters\") {\n      match child(parameter, \"type\") {\n        case Some(parameterType) => walkNode(context, parameterType, scopes)\n        case None => ()\n      }\n    }\n    match child(method, \"returnType\") {\n      case Some(returnType) => walkNode(context, returnType, scopes)\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction walkUsingStatement(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  match child(node, \"value\") {\n    case Some(value) => walkNode(context, value, scopes)\n    case None => ()\n  }\n  match child(node, \"body\") {\n    case Some(body) => {\n      pushScope(\n        context.moduleIndex,\n        body,\n        \"using\",\n        scopes,\n        context.nextScope,\n        context.scopeOutput,\n      )\n      match child(node, \"name\") {\n        case Some(name) => addLocalBinding(\n          scopes,\n          context.declarationOutput,\n          Binding {\n            moduleIndex: context.moduleIndex,\n            scopeOrdinal: currentScope(scopes),\n            name: text(context.source, name),\n            namespace: \"value\",\n            declarationKind: \"using\",\n            lo: name.lo,\n            hi: name.hi,\n            exported: false,\n            targetModule: \"\",\n            targetName: \"\",\n            mutable: false,\n          },\n        )\n        case None => ()\n      }\n      walkNode(context, body, scopes)\n      popScope(scopes)\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction walkComprehensionExpression(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  let mut opened = 0\n  for clause in children(node, \"clauses\") {\n    if clause.kind == \"comprehension-clause/for\" {\n      match child(clause, \"iterator\") {\n        case Some(iterator) => walkNode(context, iterator, scopes)\n        case None => ()\n      }\n      match child(clause, \"pattern\") {\n        case Some(pattern) => {\n          pushScope(\n            context.moduleIndex,\n            pattern,\n            \"comprehension\",\n            scopes,\n            context.nextScope,\n            context.scopeOutput,\n          )\n          bindPattern(\n            context.moduleIndex,\n            pattern,\n            context.source,\n            \"pattern\",\n            scopes,\n            context.declarationOutput,\n          )\n          walkNode(context, pattern, scopes)\n          opened += 1\n        }\n        case None => ()\n      }\n    } else {\n      for part in clause.children {\n        walkNode(context, part, scopes)\n      }\n    }\n  }\n  for found in node.children {\n    if found.field == \"body\" || found.field == \"bodyKey\" ||\n      found.field == \"bodyValue\" {\n      walkNode(context, found, scopes)\n    }\n  }\n  while opened > 0 {\n    popScope(scopes)\n    opened -= 1\n  }\n  ()\n}\n\nfunction openPatternScope(\n  context: ResolverWalkContext,\n  pattern: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  walkNode(context, pattern, scopes)\n  pushScope(\n    context.moduleIndex,\n    pattern,\n    \"pattern\",\n    scopes,\n    context.nextScope,\n    context.scopeOutput,\n  )\n  bindPattern(\n    context.moduleIndex,\n    pattern,\n    context.source,\n    \"pattern\",\n    scopes,\n    context.declarationOutput,\n  )\n  ()\n}\n\nfunction walkMatchCase(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  let mut opened = false\n  match child(node, \"pattern\") {\n    case Some(pattern) => {\n      openPatternScope(context, pattern, scopes)\n      opened = true\n    }\n    case None => ()\n  }\n  for found in node.children {\n    if found.field != \"pattern\" {\n      walkNode(context, found, scopes)\n    }\n  }\n  if opened {\n    popScope(scopes)\n  }\n  ()\n}\n\nfunction walkForExpression(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  match child(node, \"iterator\") {\n    case Some(iterator) => walkNode(context, iterator, scopes)\n    case None => ()\n  }\n  let mut opened = false\n  match child(node, \"pattern\") {\n    case Some(pattern) => {\n      openPatternScope(context, pattern, scopes)\n      opened = true\n    }\n    case None => ()\n  }\n  for found in node.children {\n    if found.field != \"iterator\" && found.field != \"pattern\" {\n      walkNode(context, found, scopes)\n    }\n  }\n  if opened {\n    popScope(scopes)\n  }\n  ()\n}\n\nfunction resolveAssignmentIdentifier(\n  context: ResolverWalkContext,\n  target: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  let name = text(context.source, target)\n  let binding = match reference(\n    context,\n    scopes,\n    name,\n    \"value\",\n    \"write\",\n    target.lo,\n    target.hi,\n  ) {\n    case Some(found) => found\n    case None => return ()\n  }\n  if binding.declarationKind == \"selected-import\" {\n    diagnostic(\n      context.diagnostics,\n      context.moduleIndex,\n      \"TPZ3015\",\n      \"`{name}` is an imported binding and cannot be assigned\",\n      target.lo,\n      target.hi,\n    )\n  } else if binding.declarationKind == \"namespace-import\" {\n    diagnostic(\n      context.diagnostics,\n      context.moduleIndex,\n      \"TPZ3012\",\n      \"`{name}` is a namespace, not a value; it may appear only as `{name}.member`\",\n      target.lo,\n      target.hi,\n    )\n  }\n  ()\n}\n\nfunction rejectNamespaceAssignment(\n  context: ResolverWalkContext,\n  target: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> bool {\n  if target.kind != \"expression/member\" {\n    return false\n  }\n  let object = match child(target, \"object\") {\n    case Some(found) => found\n    case None => return false\n  }\n  if object.kind != \"expression/identifier\" {\n    return false\n  }\n  let name = text(context.source, object)\n  if !isNone(localBinding(scopes, name, \"value\")) {\n    return false\n  }\n  let binding = match tableBinding(context.table, name) {\n    case Some(found) => found\n    case None => return false\n  }\n  if binding.declarationKind != \"namespace-import\" {\n    return false\n  }\n  let member = match child(target, \"field\") {\n    case Some(field) => text(context.source, field)\n    case None => \"\"\n  }\n  diagnostic(\n    context.diagnostics,\n    context.moduleIndex,\n    \"TPZ3015\",\n    \"`{name}.{member}` is an exported binding viewed through a namespace and cannot be assigned\",\n    target.lo,\n    target.hi,\n  )\n  true\n}\n\nfunction walkAssignmentStatement(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  match child(node, \"target\") {\n    case Some(target) => if target.kind == \"expression/identifier\" {\n      resolveAssignmentIdentifier(context, target, scopes)\n    } else if !rejectNamespaceAssignment(context, target, scopes) {\n      walkNode(context, target, scopes)\n    }\n    case None => ()\n  }\n  match child(node, \"value\") {\n    case Some(value) => walkNode(context, value, scopes)\n    case None => ()\n  }\n  ()\n}\n\nfunction resolveNamedTypeReference(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  match child(node, \"name\") {\n    case Some(name) => {\n      reference(\n        context,\n        scopes,\n        text(context.source, name),\n        \"type\",\n        \"type\",\n        name.lo,\n        name.hi,\n      )\n      ()\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction resolveQualifiedTypeReference(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  match child(node, \"namespace\") {\n    case Some(namespaceNode) => match child(node, \"name\") {\n      case Some(name) => if !namespaceMember(\n        context,\n        scopes,\n        namespaceNode,\n        name,\n        \"type\",\n        \"type\",\n      ) {\n        diagnostic(\n          context.diagnostics,\n          context.moduleIndex,\n          \"TPZ3013\",\n          \"the head of a qualified type must be a namespace binding; `{text(context.source, namespaceNode)}` is not one here\",\n          namespaceNode.lo,\n          namespaceNode.hi,\n        )\n      }\n      case None => ()\n    }\n    case None => ()\n  }\n  ()\n}\n\nfunction resolveValueIdentifier(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  let name = text(context.source, node)\n  let binding = match reference(\n    context,\n    scopes,\n    name,\n    \"value\",\n    \"read\",\n    node.lo,\n    node.hi,\n  ) {\n    case Some(found) => found\n    case None => return ()\n  }\n  if binding.declarationKind == \"namespace-import\" {\n    diagnostic(\n      context.diagnostics,\n      context.moduleIndex,\n      \"TPZ3012\",\n      \"`{name}` is a namespace, not a value; it may appear only as `{name}.member`\",\n      node.lo,\n      node.hi,\n    )\n  }\n  ()\n}\n\nfunction resolveNamespaceMemberReference(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> bool {\n  if node.kind != \"expression/member\" {\n    return false\n  }\n  match child(node, \"object\") {\n    case Some(object) => match child(node, \"field\") {\n      case Some(field) => object.kind == \"expression/identifier\" &&\n        namespaceMember(\n          context,\n          scopes,\n          object,\n          field,\n          \"value\",\n          \"namespace-member\",\n        )\n      case None => false\n    }\n    case None => false\n  }\n}\n\nfunction walkCallableSignature(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  if node.kind != \"function-declaration\" &&\n    node.kind != \"expression/lambda\" {\n    return ()\n  }\n  for parameter in children(node, \"parameters\") {\n    for part in parameter.children {\n      if part.field == \"type\" || part.field == \"default\" {\n        walkNode(context, part, scopes)\n      }\n    }\n  }\n  match child(node, \"returnType\") {\n    case Some(returnType) => walkNode(context, returnType, scopes)\n    case None => ()\n  }\n  ()\n}\n\nfunction openNodeScope(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> bool {\n  let kind = match node.kind {\n    case \"function-declaration\" => \"function\"\n    case \"expression/lambda\" => \"lambda\"\n    case \"block\" => \"block\"\n    case _ => \"\"\n  }\n  if kind == \"\" {\n    return false\n  }\n  let ordinal = pushScope(\n    context.moduleIndex,\n    node,\n    kind,\n    scopes,\n    context.nextScope,\n    context.scopeOutput,\n  )\n  if node.kind == \"function-declaration\" ||\n    node.kind == \"expression/lambda\" {\n    for parameter in children(node, \"parameters\") {\n      match child(parameter, \"name\") {\n        case Some(name) => addLocalBinding(\n          scopes,\n          context.declarationOutput,\n          Binding {\n            moduleIndex: context.moduleIndex,\n            scopeOrdinal: ordinal,\n            name: text(context.source, name),\n            namespace: \"value\",\n            declarationKind: \"parameter\",\n            lo: name.lo,\n            hi: name.hi,\n            exported: false,\n            targetModule: \"\",\n            targetName: \"\",\n            mutable: false,\n          },\n        )\n        case None => ()\n      }\n    }\n  }\n  true\n}\n\nfunction prebindChildDeclaration(\n  context: ResolverWalkContext,\n  childNode: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  if scopes.length == 0 {\n    return ()\n  }\n  for candidate in bindingForStatement(\n    context.moduleIndex,\n    childNode,\n    context.source,\n    false,\n  ) {\n    if candidate.declarationKind != \"let\" &&\n      candidate.declarationKind != \"const\" &&\n      candidate.declarationKind != \"namespace-import\" &&\n      candidate.declarationKind != \"selected-import\" {\n      addLocalBinding(\n        scopes,\n        context.declarationOutput,\n        Binding {\n          moduleIndex: context.moduleIndex,\n          scopeOrdinal: currentScope(scopes),\n          name: candidate.name,\n          namespace: candidate.namespace,\n          declarationKind: candidate.declarationKind,\n          lo: candidate.lo,\n          hi: candidate.hi,\n          exported: false,\n          targetModule: \"\",\n          targetName: \"\",\n          mutable: candidate.mutable,\n        },\n      )\n    }\n  }\n  ()\n}\n\nfunction bindStatementAfterWalk(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  if node.kind == \"statement/let\" {\n    match child(node, \"pattern\") {\n      case Some(pattern) => {\n        let mut names: Array<SyntaxNode> = []\n        collectPatternBindings(pattern, context.source, names)\n        for name in names {\n          addLocalBinding(\n            scopes,\n            context.declarationOutput,\n            Binding {\n              moduleIndex: context.moduleIndex,\n              scopeOrdinal: currentScope(scopes),\n              name: text(context.source, name),\n              namespace: \"value\",\n              declarationKind: \"let\",\n              lo: name.lo,\n              hi: name.hi,\n              exported: false,\n              targetModule: \"\",\n              targetName: \"\",\n              mutable: boolAttribute(node, \"mutable\"),\n            },\n          )\n        }\n      }\n      case None => ()\n    }\n  } else if node.kind == \"statement/const\" && scopes.length > 0 {\n    match child(node, \"name\") {\n      case Some(name) => addLocalBinding(\n        scopes,\n        context.declarationOutput,\n        Binding {\n          moduleIndex: context.moduleIndex,\n          scopeOrdinal: currentScope(scopes),\n          name: text(context.source, name),\n          namespace: \"value\",\n          declarationKind: \"const\",\n          lo: name.lo,\n          hi: name.hi,\n          exported: false,\n          targetModule: \"\",\n          targetName: \"\",\n          mutable: false,\n        },\n      )\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction walkNodeChildren(\n  context: ResolverWalkContext,\n  node: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  if node.kind == \"block\" {\n    for statement in children(node, \"statements\") {\n      if statement.kind == \"statement/function\" {\n        prebindChildDeclaration(context, statement, scopes)\n      }\n    }\n  }\n  for found in node.children {\n    if found.kind == \"identifier\" {\n      continue\n    }\n    // Explicit call type arguments need the same declaration references as an\n    // annotation. In particular, a namespace-qualified nominal must retain its\n    // defining module rather than falling through to an opaque foreign type.\n    if (node.kind == \"function-declaration\" ||\n      node.kind == \"expression/lambda\") &&\n      (found.field == \"parameters\" || found.field == \"returnType\") {\n      continue\n    }\n    if !(node.kind == \"block\" && found.kind == \"statement/function\") {\n      prebindChildDeclaration(context, found, scopes)\n    }\n    let recordDefault = node.kind == \"record-field-declaration\" &&\n      found.field == \"default\"\n    if recordDefault {\n      let mut stack = context.recordDefaultStack\n      stack.push(true)\n    }\n    walkNode(context, found, scopes)\n    if recordDefault {\n      let mut stack = context.recordDefaultStack\n      stack.pop()\n    }\n    bindStatementAfterWalk(context, found, scopes)\n  }\n  ()\n}\n\nexport function walkNode(\n  context: ResolverWalkContext,\n  nodeValue: SyntaxNode,\n  scopes: Array<LocalScope>,\n) -> () {\n  let mut activeScopes = scopes\n  if nodeValue.kind == \"identifier\" {\n    return ()\n  }\n  if nodeValue.kind == \"statement/protocol\" {\n    walkProtocolStatement(context, nodeValue, activeScopes)\n    return ()\n  }\n  if nodeValue.kind == \"statement/using\" {\n    walkUsingStatement(context, nodeValue, activeScopes)\n    return ()\n  }\n  if nodeValue.kind == \"expression/comprehension\" {\n    walkComprehensionExpression(context, nodeValue, activeScopes)\n    return ()\n  }\n  if nodeValue.kind == \"match-case\" {\n    walkMatchCase(context, nodeValue, activeScopes)\n    return ()\n  }\n  if nodeValue.kind == \"expression/for\" {\n    walkForExpression(context, nodeValue, activeScopes)\n    return ()\n  }\n  if nodeValue.kind == \"statement/assign\" {\n    walkAssignmentStatement(context, nodeValue, scopes)\n    return ()\n  }\n  if nodeValue.kind == \"type/named\" {\n    resolveNamedTypeReference(context, nodeValue, scopes)\n  } else if nodeValue.kind == \"pattern/nominal-record\" {\n    resolveNamedTypeReference(context, nodeValue, scopes)\n  } else if nodeValue.kind == \"type/qualified\" {\n    resolveQualifiedTypeReference(context, nodeValue, scopes)\n  } else if nodeValue.kind == \"expression/identifier\" {\n    resolveValueIdentifier(context, nodeValue, scopes)\n  } else if resolveNamespaceMemberReference(context, nodeValue, scopes) {\n    return ()\n  }\n\n  walkCallableSignature(context, nodeValue, scopes)\n  let opened = openNodeScope(context, nodeValue, activeScopes)\n  walkNodeChildren(context, nodeValue, activeScopes)\n  if opened {\n    popScope(activeScopes)\n  }\n}\n",
      "sourceSha256": "5abef63784bb71504858d07e806a0c7512f274f0becb44caa3a5045c56b59ae4"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/resolver/validation_init.tpz",
      "language": "topaz",
      "bytes": 23320,
      "sha256": "05bccf54250f6586d5aad861cc9c1b16271bf130a760b95f4b08bb25d2ec545f",
      "content": "// Public type-surface checks and top-level initialization analysis.\n// It consumes completed module and scope catalogs, then assembles accepted or\n// rejected resolver outputs for the facade.\n\nimport types {\n  PreviewImportEdge,\n  PreviewModuleResult,\n  PreviewResolvedDeclaration,\n  PreviewResolvedDiagnostic,\n  PreviewResolvedExport,\n  PreviewResolvedReference,\n  PreviewResolvedScope,\n  ResolveResult,\n  SyntaxNode,\n}\nimport unicode { didYouMean }\nimport resolver.model_facts {\n  InitViolation,\n  LocalScope,\n  ModuleDraft,\n  ModuleTable,\n  ModuleTableCatalog,\n  ResolverOutputs,\n  ResolverWalkContext,\n  attribute,\n  child,\n  children,\n  diagnostic,\n  isNone,\n  spanText,\n  stringJoin,\n  text,\n}\nimport resolver.modules_tables {\n  catalogTable,\n  effectiveNamespace,\n  exportedBinding,\n  exportedNames,\n  tableBinding,\n  unwrapExport,\n}\nimport resolver.scopes_walk {\n  addDeclaration,\n  appendModuleExports,\n  walkNode,\n}\n\nfunction privatePublicSurfaceTypeBinding(\n  table: ModuleTable,\n  name: string,\n) -> bool {\n  let binding = match tableBinding(table, name) {\n    case Some(found) => found\n    case None => return false\n  }\n  binding.namespace == \"type\" &&\n    !binding.exported &&\n    (binding.declarationKind == \"type-alias\" ||\n      binding.declarationKind == \"nominal-type\")\n}\n\nfunction validatePublicTypeTree(\n  source: Bytes,\n  nodeValue: SyntaxNode,\n  table: ModuleTable,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  if nodeValue.kind == \"type/named\" {\n    match child(nodeValue, \"name\") {\n      case Some(name) => {\n        let nameText = text(source, name)\n        if privatePublicSurfaceTypeBinding(table, nameText) {\n          diagnostic(\n            diagnostics,\n            table.moduleIndex,\n            \"TPZ3014\",\n            \"`{nameText}` is a module-private type and may not appear in an exported public surface; export the type or use an inline structural type\",\n            name.lo,\n            name.hi,\n          )\n        }\n      }\n      case None => ()\n    }\n  }\n  for found in nodeValue.children {\n    validatePublicTypeTree(source, found, table, diagnostics)\n  }\n  ()\n}\n\nfunction validateExportSignature(\n  source: Bytes,\n  statement: SyntaxNode,\n  table: ModuleTable,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  if statement.kind != \"statement/export\" {\n    return ()\n  }\n  let item = unwrapExport(statement)\n  if item.kind == \"statement/function\" {\n    match child(item, \"declaration\") {\n      case Some(declaration) => {\n        for parameter in children(declaration, \"parameters\") {\n          match child(parameter, \"type\") {\n            case Some(typeNode) =>\n              validatePublicTypeTree(source, typeNode, table, diagnostics)\n            case None => ()\n          }\n        }\n        match child(declaration, \"returnType\") {\n          case Some(typeNode) =>\n            validatePublicTypeTree(source, typeNode, table, diagnostics)\n          case None => ()\n        }\n      }\n      case None => ()\n    }\n    return ()\n  }\n  if item.kind == \"statement/type-alias\" {\n    match child(item, \"type\") {\n      case Some(typeNode) => validatePublicTypeTree(source, typeNode, table, diagnostics)\n      case None => ()\n    }\n    return ()\n  }\n  if item.kind == \"statement/enum\" {\n    for variant in children(item, \"variants\") {\n      for typeNode in children(variant, \"payload\") {\n        validatePublicTypeTree(source, typeNode, table, diagnostics)\n      }\n    }\n    return ()\n  }\n  if item.kind == \"statement/record\" {\n    for field in children(item, \"fields\") {\n      match child(field, \"type\") {\n        case Some(typeNode) => validatePublicTypeTree(source, typeNode, table, diagnostics)\n        case None => ()\n      }\n    }\n    return ()\n  }\n  if item.kind == \"statement/newtype\" {\n    match child(item, \"base\") {\n      case Some(typeNode) => validatePublicTypeTree(source, typeNode, table, diagnostics)\n      case None => ()\n    }\n    return ()\n  }\n  if item.kind == \"statement/let\" {\n    match child(item, \"type\") {\n      case Some(typeNode) => validatePublicTypeTree(source, typeNode, table, diagnostics)\n      case None => ()\n    }\n  }\n  ()\n}\n\nfunction validateExportSignatures(\n  module: ModuleDraft,\n  table: ModuleTable,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  let source = module.source\n  for statement in module.root.children {\n    validateExportSignature(source, statement, table, diagnostics)\n  }\n  ()\n}\n\nexport function validateImportSurfaces(\n  modules: Array<ModuleDraft>,\n  tables: ModuleTableCatalog,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  let mut importingIndex = 0\n  for module in modules {\n    for import in module.imports {\n      match catalogTable(tables, import.target) {\n        case Some(targetTable) => if targetTable.exportedNames.length == 0 {\n          diagnostic(\n            diagnostics,\n            importingIndex,\n            \"TPZ3010\",\n            \"`{import.target}` exports nothing; v5.2 has no side-effect-only imports\",\n            import.pathLo,\n            import.pathHi,\n          )\n        } else {\n          let mut selectedIndex = 0\n          for selected in import.selectedNames {\n            if isNone(exportedBinding(targetTable, selected)) {\n              let hint = didYouMean(\n                selected,\n                exportedNames(targetTable, \"\"),\n              )\n              diagnostic(\n                diagnostics,\n                importingIndex,\n                \"TPZ3009\",\n                \"`{selected}` is not exported by `{import.target}`{hint}\",\n                import.selectedLos[selectedIndex],\n                import.selectedHis[selectedIndex],\n              )\n            }\n            selectedIndex += 1\n          }\n        }\n        case None => ()\n      }\n    }\n    validateExportSignatures(module, tables.tables[importingIndex], diagnostics)\n    importingIndex += 1\n  }\n  ()\n}\n\nfunction resolveModuleFacts(\n  module: ModuleDraft,\n  index: int,\n  tables: ModuleTableCatalog,\n  outputs: ResolverOutputs,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  let mut moduleResults = outputs.modules\n  moduleResults.push(module.result)\n  let mut scopes = outputs.scopes\n  scopes.push(PreviewResolvedScope {\n    moduleIndex: index,\n    ordinal: 0,\n    parentOrdinal: -1,\n    kind: \"module\",\n    lo: module.root.lo,\n    hi: module.root.hi,\n  })\n  let table = tables.tables[index]\n  for binding in table.bindings {\n    if binding.declarationKind != \"protocol\" {\n      addDeclaration(\n        outputs.declarations,\n        binding,\n        effectiveNamespace(binding, tables),\n        !isNone(exportedBinding(table, binding.name)),\n      )\n    }\n  }\n  appendModuleExports(outputs.exports, index, table)\n  let mut localScopes: Array<LocalScope> = []\n  let mut nextScope: Array<int> = [1]\n  let walkContext = ResolverWalkContext {\n    moduleIndex: index,\n    source: module.source,\n    table: table,\n    tables: tables,\n    nextScope: nextScope,\n    scopeOutput: outputs.scopes,\n    declarationOutput: outputs.declarations,\n    referenceOutput: outputs.references,\n    diagnostics: diagnostics,\n    recordDefaultStack: [],\n  }\n  for statement in module.root.children {\n    let item = unwrapExport(statement)\n    if item.kind != \"statement/import\" {\n      walkNode(walkContext, item, localScopes)\n    }\n  }\n  ()\n}\n\nfunction initPatternNames(\n  pattern: SyntaxNode,\n  source: Bytes,\n  output: Array<string>,\n) -> () {\n  if pattern.kind == \"pattern/binding\" || pattern.kind == \"pattern/typed\" {\n    match child(pattern, \"name\") {\n      case Some(name) => {\n        let mut names = output\n        names.push(text(source, name))\n      }\n      case None => ()\n    }\n    return ()\n  }\n  if pattern.kind == \"pattern/or\" {\n    for alternative in children(pattern, \"alternatives\") {\n      initPatternNames(alternative, source, output)\n    }\n    return ()\n  }\n  if pattern.kind == \"pattern/constructor\" {\n    for argument in children(pattern, \"arguments\") {\n      initPatternNames(argument, source, output)\n    }\n    return ()\n  }\n  if pattern.kind == \"pattern/list\" {\n    for element in children(pattern, \"elements\") {\n      if element.kind == \"list-pattern/rest\" {\n        match element.children.get(0) {\n          case Some(binding) => initPatternNames(binding, source, output)\n          case None => ()\n        }\n      } else {\n        initPatternNames(element, source, output)\n      }\n    }\n    return ()\n  }\n  if pattern.kind == \"pattern/record\" ||\n    pattern.kind == \"pattern/nominal-record\" {\n    for field in children(pattern, \"fields\") {\n      match child(field, \"pattern\") {\n        case Some(found) => initPatternNames(found, source, output)\n        case None => match child(field, \"name\") {\n          case Some(name) => {\n            let mut names = output\n            names.push(text(source, name))\n          }\n          case None => ()\n        }\n      }\n    }\n  }\n  ()\n}\n\nfunction initItemNames(item: SyntaxNode, source: Bytes) -> Array<string> {\n  let mut output: Array<string> = []\n  if item.kind == \"statement/let\" {\n    match child(item, \"pattern\") {\n      case Some(pattern) => initPatternNames(pattern, source, output)\n      case None => ()\n    }\n  } else if item.kind == \"statement/function\" {\n    match child(item, \"declaration\") {\n      case Some(declaration) => match child(declaration, \"name\") {\n        case Some(name) => output.push(text(source, name))\n        case None => ()\n      }\n      case None => ()\n    }\n  }\n  output\n}\n\nfunction initLocalContains(locals: Array<string>, name: string) -> bool {\n  for local in locals {\n    if local == name {\n      return true\n    }\n  }\n  false\n}\n\nfunction initObserveReference(\n  node: SyntaxNode,\n  source: Bytes,\n  table: ModuleTable,\n  itemLo: int,\n  locals: Array<string>,\n  violation: Array<InitViolation>,\n) -> () {\n  if violation.length > 0 {\n    return ()\n  }\n  let name = text(source, node)\n  if initLocalContains(locals, name) {\n    return ()\n  }\n  // ModuleTable already owns every unique top-level binding. Since item spans\n  // are ordered and non-overlapping, declaration byte >= current item byte is\n  // the self-host form of Stage 0's textual binding index >= item index rule.\n  let binding = match tableBinding(table, name) {\n    case Some(found) => found\n    case None => return ()\n  }\n  if (binding.declarationKind == \"let\" ||\n    binding.declarationKind == \"function\") && binding.lo >= itemLo {\n    let mut found = violation\n    found.push(InitViolation { name: name, lo: node.lo, hi: node.hi })\n  }\n  ()\n}\n\nfunction initScanChild(\n  owner: SyntaxNode,\n  field: string,\n  source: Bytes,\n  table: ModuleTable,\n  itemLo: int,\n  locals: Array<string>,\n  violation: Array<InitViolation>,\n) -> () {\n  match child(owner, field) {\n    case Some(found) => initScanExpression(\n      found,\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n    case None => ()\n  }\n  ()\n}\n\nfunction initScanTwoChildren(\n  owner: SyntaxNode,\n  first: string,\n  second: string,\n  source: Bytes,\n  table: ModuleTable,\n  itemLo: int,\n  locals: Array<string>,\n  violation: Array<InitViolation>,\n) -> () {\n  initScanChild(owner, first, source, table, itemLo, locals, violation)\n  initScanChild(owner, second, source, table, itemLo, locals, violation)\n  ()\n}\n\nfunction initScanThreeChildren(\n  owner: SyntaxNode,\n  first: string,\n  second: string,\n  third: string,\n  source: Bytes,\n  table: ModuleTable,\n  itemLo: int,\n  locals: Array<string>,\n  violation: Array<InitViolation>,\n) -> () {\n  initScanTwoChildren(\n    owner,\n    first,\n    second,\n    source,\n    table,\n    itemLo,\n    locals,\n    violation,\n  )\n  initScanChild(owner, third, source, table, itemLo, locals, violation)\n  ()\n}\n\nfunction initScanExpression(\n  expression: SyntaxNode,\n  source: Bytes,\n  table: ModuleTable,\n  itemLo: int,\n  locals: Array<string>,\n  violation: Array<InitViolation>,\n) -> () {\n  if expression.kind == \"expression/identifier\" {\n    return initObserveReference(\n      expression,\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n  }\n  if expression.kind == \"expression/call\" {\n    let mut argumentsImmediate = true\n    match child(expression, \"callee\") {\n      case Some(callee) => {\n        if callee.kind == \"expression/optional-access\" {\n          argumentsImmediate = false\n        }\n        if callee.kind == \"expression/identifier\" {\n          initObserveReference(callee, source, table, itemLo, locals, violation)\n        } else if callee.kind != \"expression/lambda\" {\n          initScanExpression(callee, source, table, itemLo, locals, violation)\n        }\n      }\n      case None => ()\n    }\n    if argumentsImmediate {\n      for argument in children(expression, \"arguments\") {\n        if argument.kind == \"call-argument/spread\" ||\n          argument.kind == \"call-argument/named\" {\n          initScanChild(argument, \"value\", source, table, itemLo, locals, violation)\n        } else {\n          initScanExpression(argument, source, table, itemLo, locals, violation)\n        }\n      }\n    }\n    return ()\n  }\n  if expression.kind == \"expression/lambda\" {\n    return ()\n  }\n  if expression.kind == \"expression/block\" {\n    match child(expression, \"block\") {\n      case Some(block) => initScanBlock(block, source, table, itemLo, locals, violation)\n      case None => ()\n    }\n    return ()\n  }\n  let immediateField = match expression.kind {\n    case \"expression/if\" => \"condition\"\n    case \"expression/match\" => \"scrutinee\"\n    case \"expression/for\" => \"iterator\"\n    case \"expression/concurrent\" => \"timeout\"\n    case \"expression/unary\" | \"expression/try\" => \"operand\"\n    case \"expression/member\" | \"expression/optional-access\" => \"object\"\n    case _ => \"\"\n  }\n  if immediateField != \"\" {\n    initScanChild(\n      expression,\n      immediateField,\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n    return ()\n  }\n  if expression.kind == \"expression/comprehension\" {\n    match children(expression, \"clauses\").get(0) {\n      case Some(clause) => if clause.kind == \"comprehension-clause/for\" {\n        initScanChild(clause, \"iterator\", source, table, itemLo, locals, violation)\n      }\n      case None => ()\n    }\n    return ()\n  }\n  if expression.kind == \"expression/parenthesized\" {\n    match expression.children.get(0) {\n      case Some(inner) => initScanExpression(\n        inner,\n        source,\n        table,\n        itemLo,\n        locals,\n        violation,\n      )\n      case None => ()\n    }\n    return ()\n  }\n  if expression.kind == \"expression/index\" {\n    initScanTwoChildren(\n      expression,\n      \"object\",\n      \"index\",\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n    return ()\n  }\n  if expression.kind == \"expression/binary\" {\n    initScanChild(expression, \"left\", source, table, itemLo, locals, violation)\n    let operator = attribute(expression, \"operator\")\n    if operator != \"and\" && operator != \"or\" && operator != \"coalesce\" {\n      initScanChild(expression, \"right\", source, table, itemLo, locals, violation)\n    }\n    return ()\n  }\n  if expression.kind == \"expression/compose\" {\n    initScanTwoChildren(\n      expression,\n      \"left\",\n      \"right\",\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n    return ()\n  }\n  if expression.kind == \"expression/range\" {\n    initScanThreeChildren(\n      expression,\n      \"low\",\n      \"high\",\n      \"step\",\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n    return ()\n  }\n  if expression.kind == \"expression/pipe\" {\n    initScanTwoChildren(\n      expression,\n      \"left\",\n      \"right\",\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n    return ()\n  }\n  if expression.kind == \"expression/record-update\" {\n    initScanTwoChildren(\n      expression,\n      \"base\",\n      \"spread\",\n      source,\n      table,\n      itemLo,\n      locals,\n      violation,\n    )\n  }\n  if expression.kind == \"expression/record-literal\" ||\n    expression.kind == \"expression/record-update\" {\n    for field in children(expression, \"fields\") {\n      initScanChild(field, \"value\", source, table, itemLo, locals, violation)\n    }\n    return ()\n  }\n  if expression.kind == \"expression/array\" || expression.kind == \"expression/set\" {\n    for element in children(expression, \"elements\") {\n      if element.kind == \"array-element/spread\" {\n        initScanChild(element, \"value\", source, table, itemLo, locals, violation)\n      } else {\n        initScanExpression(element, source, table, itemLo, locals, violation)\n      }\n    }\n    return ()\n  }\n  if expression.kind == \"expression/map\" {\n    for entry in children(expression, \"entries\") {\n      initScanTwoChildren(\n        entry,\n        \"key\",\n        \"value\",\n        source,\n        table,\n        itemLo,\n        locals,\n        violation,\n      )\n    }\n    return ()\n  }\n  if expression.kind == \"expression/string\" || expression.kind == \"expression/template\" {\n    for part in children(expression, \"parts\") {\n      if part.kind == \"string-part/interpolation\" {\n        initScanChild(part, \"value\", source, table, itemLo, locals, violation)\n      }\n    }\n  }\n  ()\n}\n\nfunction initBindPattern(\n  pattern: SyntaxNode,\n  source: Bytes,\n  locals: Array<string>,\n) -> () {\n  let mut bound: Array<string> = []\n  initPatternNames(pattern, source, bound)\n  let mut active = locals\n  for name in bound {\n    active.push(name)\n  }\n  ()\n}\n\nfunction initScanBlock(\n  block: SyntaxNode,\n  source: Bytes,\n  table: ModuleTable,\n  itemLo: int,\n  locals: Array<string>,\n  violation: Array<InitViolation>,\n) -> () {\n  let priorLocalCount = locals.length\n  let mut active = locals\n  for statement in children(block, \"statements\") {\n    if statement.kind == \"statement/function\" {\n      match child(statement, \"declaration\") {\n        case Some(declaration) => match child(declaration, \"name\") {\n          case Some(name) => active.push(text(source, name))\n          case None => ()\n        }\n        case None => ()\n      }\n    } else if statement.kind == \"statement/let\" {\n      initScanChild(statement, \"value\", source, table, itemLo, active, violation)\n      match child(statement, \"pattern\") {\n        case Some(pattern) => initBindPattern(pattern, source, active)\n        case None => ()\n      }\n    } else if statement.kind == \"statement/const\" {\n      initScanChild(statement, \"value\", source, table, itemLo, active, violation)\n      match child(statement, \"name\") {\n        case Some(name) => active.push(text(source, name))\n        case None => ()\n      }\n    } else if statement.kind == \"statement/using\" {\n      initScanChild(statement, \"value\", source, table, itemLo, active, violation)\n      let priorUsingLocalCount = active.length\n      match child(statement, \"name\") {\n        case Some(name) => active.push(text(source, name))\n        case None => ()\n      }\n      match child(statement, \"body\") {\n        case Some(body) => initScanBlock(\n          body,\n          source,\n          table,\n          itemLo,\n          active,\n          violation,\n        )\n        case None => ()\n      }\n      while active.length > priorUsingLocalCount {\n        active.pop()\n      }\n    } else if statement.kind == \"statement/assign\" {\n      match child(statement, \"target\") {\n        case Some(target) => if target.kind == \"expression/identifier\" {\n          initObserveReference(target, source, table, itemLo, active, violation)\n        } else {\n          initScanExpression(target, source, table, itemLo, active, violation)\n        }\n        case None => ()\n      }\n      initScanChild(statement, \"value\", source, table, itemLo, active, violation)\n    } else if statement.kind == \"statement/return\" ||\n      statement.kind == \"statement/expression\" {\n      initScanChild(statement, \"value\", source, table, itemLo, active, violation)\n    } else if statement.kind == \"statement/while\" {\n      initScanChild(statement, \"condition\", source, table, itemLo, active, violation)\n    }\n  }\n  initScanChild(block, \"tail\", source, table, itemLo, active, violation)\n  while active.length > priorLocalCount {\n    active.pop()\n  }\n  ()\n}\n\nfunction initScanItem(\n  item: SyntaxNode,\n  source: Bytes,\n  table: ModuleTable,\n  violation: Array<InitViolation>,\n) -> () {\n  let mut locals: Array<string> = []\n  if item.kind == \"statement/let\" || item.kind == \"statement/expression\" ||\n    item.kind == \"statement/return\" {\n    initScanChild(item, \"value\", source, table, item.lo, locals, violation)\n  } else if item.kind == \"statement/assign\" {\n    initScanTwoChildren(\n      item,\n      \"target\",\n      \"value\",\n      source,\n      table,\n      item.lo,\n      locals,\n      violation,\n    )\n  } else if item.kind == \"statement/while\" {\n    initScanChild(item, \"condition\", source, table, item.lo, locals, violation)\n  }\n  ()\n}\n\nfunction validateImportedInitializers(\n  modules: Array<ModuleDraft>,\n  tables: ModuleTableCatalog,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> () {\n  let mut moduleIndexValue = 0\n  for module in modules {\n    if !module.result.entry {\n      let source = module.source\n      let table = tables.tables[moduleIndexValue]\n      for statement in module.root.children {\n        let item = unwrapExport(statement)\n        let mut violation: Array<InitViolation> = []\n        initScanItem(item, source, table, violation)\n        match violation.get(0) {\n          case Some(found) => {\n            let owners = initItemNames(item, source)\n            let owner = if owners.length == 0 {\n              spanText(source, found.lo, found.hi)\n            } else {\n              stringJoin(owners, \", \")\n            }\n            diagnostic(\n              diagnostics,\n              moduleIndexValue,\n              \"TPZ3018\",\n              \"the initializer of `{owner}` reaches `{found.name}`, whose initializer has not completed (v5.2 defines no partially initialized module binding)\",\n              found.lo,\n              found.hi,\n            )\n          }\n          case None => ()\n        }\n      }\n    }\n    moduleIndexValue += 1\n  }\n  ()\n}\n\nexport function resolvedResult(\n  modules: Array<ModuleDraft>,\n  publicEdges: Array<PreviewImportEdge>,\n  tables: ModuleTableCatalog,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> Result<ResolveResult, string> {\n  let outputs = ResolverOutputs {\n    modules: [],\n    scopes: [],\n    declarations: [],\n    references: [],\n    exports: [],\n  }\n  let mut index = 0\n  for module in modules {\n    resolveModuleFacts(module, index, tables, outputs, diagnostics)\n    index += 1\n  }\n  if diagnostics.length == 0 {\n    validateImportedInitializers(modules, tables, diagnostics)\n  }\n  Ok(ResolveResult {\n    queries: [],\n    modules: outputs.modules,\n    edges: publicEdges,\n    scopes: outputs.scopes,\n    declarations: outputs.declarations,\n    references: outputs.references,\n    exports: outputs.exports,\n    diagnostics: diagnostics,\n  })\n}\n\nexport function rejectedResult(\n  modules: Array<ModuleDraft>,\n  publicEdges: Array<PreviewImportEdge>,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n) -> ResolveResult {\n  let mut moduleResults: Array<PreviewModuleResult> = []\n  for module in modules {\n    moduleResults.push(module.result)\n  }\n  ResolveResult {\n    queries: [],\n    modules: moduleResults,\n    edges: publicEdges,\n    scopes: [],\n    declarations: [],\n    references: [],\n    exports: [],\n    diagnostics: diagnostics,\n  }\n}\n",
      "sourceSha256": "05bccf54250f6586d5aad861cc9c1b16271bf130a760b95f4b08bb25d2ec545f"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/src/main.tpz",
      "language": "topaz",
      "bytes": 16969,
      "sha256": "7ec1062435670c6fa75abc9135025cab17a4bdbccb9303c391261230b05c8b54",
      "content": "import std.json as jsonBoundary\n\nimport checker { check }\nimport emitter { emitRust, emitStep }\nimport layout { normalize }\nimport lowering { lowerStep, lowerValue }\nimport parser { parse }\nimport profile { checkProfile }\nimport raw { lex }\nimport resolver { resolvePreview, resolveWithFacts }\nimport resolver.model_facts { ResolverHostFactCatalog, resolverHostFacts }\nimport stage1_types { LoweringOutput, STAGE1_EXCHANGE_SCHEMA, Stage1Provenance, compilerProvenance }\nimport types {\n  CheckResult,\n  LowerBridgeRequest,\n  encodeLowerBridgeRequest,\n  LayoutResult,\n  ParseResult,\n  PreviewAstNode,\n  PreviewCallArgument,\n  PreviewCallEvaluation,\n  PreviewCheckLabel,\n  PreviewDiagnostic,\n  PreviewDirectoryEntry,\n  PreviewGeneratedStdModule,\n  PreviewHostFact,\n  PreviewHostQuery,\n  PreviewImportEdge,\n  PreviewModuleResult,\n  PreviewResolvedDeclaration,\n  PreviewResolvedDiagnostic,\n  PreviewResolvedExport,\n  PreviewResolvedReference,\n  PreviewResolvedScope,\n  PreviewToken,\n  PreviewTypeAtom,\n  PreviewTypedCall,\n  PreviewTypedCapture,\n  PreviewTypedNode,\n  PreviewCheckDiagnostic,\n  RawResult,\n  ResolveResult,\n}\n\nconst EXCHANGE_SCHEMA = \"topaz.compiler.frontend-preview-exchange/v1\"\n\nexport record RequestPackageFacts derives JSON {\n  buildRole: string,\n  externModules: Array<string>,\n  externReplayModules: Array<string>,\n  externReplayErrors: Array<string>,\n  generatedStdModules: Array<PreviewGeneratedStdModule>,\n}\n\nrecord PreviewRequest derives JSON {\n  languageMode: string = \"topaz-5.20\",\n  schema: string,\n  terminal: string,\n  entry: string,\n  root: string,\n  source: string,\n  sourceId: string,\n  facts: Array<PreviewHostFact>,\n  package: RequestPackageFacts,\n  maxAstNodes: int,\n  maxAstDepth: int,\n}\n\nexport record PreviewResponse derives JSON {\n  schema: string,\n  status: string,\n  sourceId: string,\n  raw: Array<PreviewToken>,\n  layout: Array<PreviewToken>,\n  ast: Array<PreviewAstNode>,\n  diagnostics: Array<PreviewDiagnostic>,\n  queries: Array<PreviewHostQuery>,\n  modules: Array<PreviewModuleResult>,\n  edges: Array<PreviewImportEdge>,\n  scopes: Array<PreviewResolvedScope>,\n  declarations: Array<PreviewResolvedDeclaration>,\n  references: Array<PreviewResolvedReference>,\n  exports: Array<PreviewResolvedExport>,\n  resolverDiagnostics: Array<PreviewResolvedDiagnostic>,\n  typedNodes: Array<PreviewTypedNode>,\n  typedCalls: Array<PreviewTypedCall>,\n  typedCaptures: Array<PreviewTypedCapture>,\n  checkerDiagnostics: Array<PreviewCheckDiagnostic>,\n}\n\nexport record Stage1Request derives JSON {\n  schema: string,\n  producer: string,\n  compilerSourceSetId: string,\n  terminal: string,\n  entry: string,\n  root: string,\n  source: string,\n  sourceId: string,\n  languageMode: string,\n  profile: string,\n  facts: Array<PreviewHostFact>,\n  package: RequestPackageFacts,\n  maxSourceFacts: int,\n  maxTotalSourceBytes: int,\n  maxAstNodes: int,\n  maxAstDepth: int,\n  maxRawTokens: int,\n  maxLayoutTokens: int,\n  maxHirNodes: int,\n  maxLoweredNodes: int,\n  maxDiagnostics: int,\n  maxGeneratedRustBytes: int,\n  maxFactRounds: int,\n}\n\nrecord SyntaxPreview {\n  ast: Array<PreviewAstNode>,\n  diagnostics: Array<PreviewDiagnostic>,\n}\n\nrecord CompilerTypedResponse derives JSON {\n  schema: string,\n  status: string,\n  frontEnd: string,\n  provenance: Stage1Provenance,\n}\n\nfunction emptyCheckResult() -> CheckResult {\n  CheckResult { nodes: [], calls: [], captures: [], diagnostics: [] }\n}\n\nfunction resolveRequest(request: PreviewRequest) -> Result<ResolveResult, string> {\n  resolvePreview(\n    request.entry,\n    request.root,\n    request.facts,\n    request.package.externModules,\n    request.package.generatedStdModules,\n    request.maxAstNodes,\n    request.maxAstDepth,\n    request.languageMode,\n  )\n}\n\nfunction checkResolvedRequest(\n  request: PreviewRequest,\n  resolved: ResolveResult,\n) -> Result<CheckResult, string> {\n  if request.terminal == \"typed\" &&\n    resolved.queries.length == 0 && resolved.diagnostics.length == 0 {\n    check(\n      resolved,\n      request.package.externReplayModules,\n      request.package.externReplayErrors,\n      request.maxAstNodes,\n      request.maxAstDepth,\n      request.languageMode,\n    )\n  } else {\n    Ok(emptyCheckResult())\n  }\n}\n\nfunction resolvedStatus(resolved: ResolveResult, checked: CheckResult) -> string {\n  if resolved.queries.length > 0 {\n    \"need-facts\"\n  } else if resolved.diagnostics.length > 0 || checked.diagnostics.length > 0 {\n    \"rejected\"\n  } else {\n    \"completed\"\n  }\n}\n\nfunction resolvedResponse(\n  request: PreviewRequest,\n  resolved: ResolveResult,\n  checked: CheckResult,\n) -> PreviewResponse {\n  PreviewResponse {\n    schema: EXCHANGE_SCHEMA,\n    status: resolvedStatus(resolved, checked),\n    sourceId: request.sourceId,\n    raw: [],\n    layout: [],\n    ast: [],\n    diagnostics: [],\n    queries: resolved.queries,\n    modules: resolved.modules,\n    edges: resolved.edges,\n    scopes: resolved.scopes,\n    declarations: resolved.declarations,\n    references: resolved.references,\n    exports: resolved.exports,\n    resolverDiagnostics: resolved.diagnostics,\n    typedNodes: checked.nodes,\n    typedCalls: checked.calls,\n    typedCaptures: checked.captures,\n    checkerDiagnostics: checked.diagnostics,\n  }\n}\n\nfunction processResolvedRequest(request: PreviewRequest) -> Result<PreviewResponse, string> {\n  let resolved = resolveRequest(request)?\n  let checked = checkResolvedRequest(request, resolved)?\n  Ok(resolvedResponse(request, resolved, checked))\n}\n\nfunction parseSyntax(\n  request: PreviewRequest,\n  raw: RawResult,\n  layout: LayoutResult,\n) -> Result<SyntaxPreview, string> {\n  let mut diagnostics = raw.diagnostics\n  for found in layout.diagnostics {\n    diagnostics.push(found)\n  }\n  let parsed = parse(\n    layout.tokens,\n    request.source,\n    request.maxAstNodes,\n    request.maxAstDepth,\n    request.languageMode,\n  )?\n  for found in parsed.diagnostics {\n    diagnostics.push(found)\n  }\n  Ok(SyntaxPreview { ast: parsed.nodes, diagnostics: diagnostics })\n}\n\nfunction syntaxResponse(\n  request: PreviewRequest,\n  raw: RawResult,\n  layout: LayoutResult,\n  syntax: SyntaxPreview,\n) -> PreviewResponse {\n  PreviewResponse {\n    schema: EXCHANGE_SCHEMA,\n    status: if syntax.diagnostics.length == 0 { \"completed\" } else { \"rejected\" },\n    sourceId: request.sourceId,\n    raw: raw.tokens,\n    layout: layout.tokens,\n    ast: syntax.ast,\n    diagnostics: syntax.diagnostics,\n    queries: [],\n    modules: [],\n    edges: [],\n    scopes: [],\n    declarations: [],\n    references: [],\n    exports: [],\n    resolverDiagnostics: [],\n    typedNodes: [],\n    typedCalls: [],\n    typedCaptures: [],\n    checkerDiagnostics: [],\n  }\n}\n\nfunction processSyntaxRequest(request: PreviewRequest) -> Result<PreviewResponse, string> {\n  let raw = lex(request.source)\n  let layout = normalize(raw.tokens, request.source)\n  let syntax = parseSyntax(request, raw, layout)?\n  Ok(syntaxResponse(request, raw, layout, syntax))\n}\n\nfunction process(request: PreviewRequest) -> Result<PreviewResponse, string> {\n  if request.schema != EXCHANGE_SCHEMA {\n    return Err(\"unsupported front-end preview exchange schema\")\n  }\n  if request.terminal == \"resolved\" || request.terminal == \"typed\" {\n    processResolvedRequest(request)\n  } else if request.terminal == \"ast\" {\n    processSyntaxRequest(request)\n  } else {\n    Err(\"unsupported front-end preview terminal `{request.terminal}`\")\n  }\n}\n\nexport function frontEndStep(request: Bytes) -> Result<Bytes, string> {\n  let text = request.decodeUtf8()?\n  let decoded = jsonBoundary.parseAs<PreviewRequest>(text)?\n  let response = process(decoded)?\n  let encoded = jsonBoundary.stringify(response)?\n  Ok((encoded).encodeUtf8())\n}\n\nfunction supportsSelfHostedLanguage(mode: string) -> bool {\n  mode == \"topaz-5.16\" ||\n    mode == \"topaz-5.17\" ||\n    mode == \"topaz-5.18\" ||\n    mode == \"topaz-5.19\" ||\n    mode == \"topaz-5.20\" || mode == \"topaz-5.21\"\n}\n\nfunction validateStage1Request(request: Stage1Request) -> Result<int, string> {\n  if request.schema != STAGE1_EXCHANGE_SCHEMA {\n    return Err(\"unsupported Stage 1 exchange schema\")\n  }\n  let producerStage = if request.producer == \"topaz-stage1\" {\n    1\n  } else if request.producer == \"topaz-stage2\" {\n    2\n  } else {\n    return Err(\"unsupported compiler producer\")\n  }\n  if request.terminal != \"typed\" && request.terminal != \"lowered\" && request.terminal != \"rust-source\" {\n    return Err(\"Stage 1 supports typed, lowered and rust-source terminals\")\n  }\n  if !supportsSelfHostedLanguage(request.languageMode) {\n    return Err(\"unsupported self-hosted language mode `{request.languageMode}`\")\n  }\n  if request.maxFactRounds < 1 {\n    return Err(\"Stage 1 fact-round budget must be positive\")\n  }\n  Ok(producerStage)\n}\n\nfunction stage1PreviewRequest(request: Stage1Request) -> PreviewRequest {\n  PreviewRequest {\n    schema: EXCHANGE_SCHEMA,\n    languageMode: request.languageMode,\n    terminal: \"typed\",\n    entry: request.entry,\n    root: request.root,\n    source: \"\",\n    sourceId: \"\",\n    facts: request.facts,\n    package: request.package,\n    maxAstNodes: request.maxAstNodes,\n    maxAstDepth: request.maxAstDepth,\n  }\n}\n\nfunction applyCompilerProfile(\n  profile: string,\n  languageMode: string,\n  base: PreviewResponse,\n) -> Result<PreviewResponse, string> {\n  let mut checkerDiagnostics = base.checkerDiagnostics\n  if base.queries.length == 0 {\n    for diagnostic in checkProfile(\n      profile,\n      base.modules,\n      base.references,\n      base.typedNodes,\n      base.typedCalls,\n      base.typedCaptures,\n      languageMode,\n    )? {\n      checkerDiagnostics.push(diagnostic)\n    }\n  }\n  Ok(PreviewResponse {\n    ...base,\n    status: if base.status == \"completed\" && checkerDiagnostics.length > 0 {\n      \"rejected\"\n    } else {\n      base.status\n    },\n    checkerDiagnostics: checkerDiagnostics,\n  })\n}\n\n// Lowering follows imported names to their declarations, which live in module\n// scope; local declarations stay out of the bridge.\nfunction moduleScopeDeclarations(\n  values: Array<PreviewResolvedDeclaration>,\n) -> Array<PreviewResolvedDeclaration> {\n  let mut declarations: Array<PreviewResolvedDeclaration> = []\n  for value in values {\n    if value.scopeOrdinal == 0 {\n      declarations.push(value)\n    }\n  }\n  declarations\n}\n\nfunction lowerBridgeRequest(\n  request: Stage1Request,\n  producerStage: int,\n  frontEnd: PreviewResponse,\n) -> Result<Bytes, string> {\n  encodeLowerBridgeRequest(LowerBridgeRequest {\n    ...lowerBridgeValue(request, producerStage, frontEnd),\n    frontEnd: jsonBoundary.stringify(frontEnd)?,\n  })\n}\n\nfunction lowerBridgeValue(\n  request: Stage1Request,\n  producerStage: int,\n  frontEnd: PreviewResponse,\n) -> LowerBridgeRequest {\n  LowerBridgeRequest {\n    producer: request.producer,\n    producerStage: producerStage,\n    frontEnd: \"\",\n    frontEndStatus: frontEnd.status,\n    modules: frontEnd.modules,\n    references: frontEnd.references,\n    typedNodes: frontEnd.typedNodes,\n    typedCalls: frontEnd.typedCalls,\n    typedCaptures: frontEnd.typedCaptures,\n    edges: frontEnd.edges,\n    moduleDeclarations: moduleScopeDeclarations(frontEnd.declarations),\n    languageMode: request.languageMode,\n    sourceSetId: request.compilerSourceSetId,\n    maxLoweredNodes: request.maxLoweredNodes,\n  }\n}\n\nfunction finishCompilerRequest(\n  request: Stage1Request,\n  lowered: Bytes,\n) -> Result<Bytes, string> {\n  if request.terminal == \"rust-source\" {\n    emitStep(lowered, request.maxGeneratedRustBytes)\n  } else {\n    Ok(lowered)\n  }\n}\n\nexport function compilerStep(input: Bytes) -> Result<Bytes, string> {\n  let text = input.decodeUtf8()?\n  let decoded = jsonBoundary.parseAs<Stage1Request>(text)?\n  let producerStage = validateStage1Request(decoded)?\n  let baseFrontEnd = process(stage1PreviewRequest(decoded))?\n  let frontEnd = applyCompilerProfile(decoded.profile, decoded.languageMode, baseFrontEnd)?\n  if decoded.terminal == \"typed\" {\n    let response = CompilerTypedResponse {\n      schema: STAGE1_EXCHANGE_SCHEMA,\n      status: frontEnd.status,\n      frontEnd: jsonBoundary.stringify(frontEnd)?,\n      provenance: compilerProvenance(decoded.compilerSourceSetId, decoded.producer, producerStage),\n    }\n    return Ok((jsonBoundary.stringify(response)?).encodeUtf8())\n  }\n  let bridge = lowerBridgeRequest(decoded, producerStage, frontEnd)?\n  let lowered = lowerStep(bridge)?\n  finishCompilerRequest(decoded, lowered)\n}\n\n// Results are values. Whole frontend observations and lowered tables are\n// returned only when requested; a typed completion never denotes Rust output.\nexport record CompilerResult {\n  status: string,\n  kind: string,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n  checkerDiagnostics: Array<PreviewCheckDiagnostic>,\n  exports: Array<PreviewResolvedExport>,\n  provenance: Stage1Provenance,\n  generatedRust: Option<string>,\n  lowered: Option<LoweringOutput>,\n  observation: Option<PreviewResponse>,\n}\n\nfunction resourceLimit(label: string, observed: int, limit: int) -> Result<(), string> {\n  if observed > limit {\n    Err(\"front-end resolver preview {label} resource limit: observed {observed}, limit {limit}\")\n  } else {\n    Ok(())\n  }\n}\n\nfunction accountSourceFact(\n  request: Stage1Request,\n  totals: Array<int>,\n  fact: PreviewHostFact,\n) -> Result<(), string> {\n  let mut counts = totals\n  if fact.kind == \"read-source\" {\n    counts[0] += 1\n    if fact.status == \"present\" { counts[1] += fact.source.byteLength() }\n    resourceLimit(\"source-fact\", counts[0], request.maxSourceFacts)?\n    resourceLimit(\"total-source-byte\", counts[1], request.maxTotalSourceBytes)?\n  }\n  Ok(())\n}\n\nfunction resolverBudgets(request: Stage1Request, resolved: ResolveResult) -> Result<(), string> {\n  let mut raw = 0\n  let mut layout = 0\n  let mut ast = 0\n  for module in resolved.modules {\n    raw += module.raw.length\n    layout += module.layout.length\n    ast += module.ast.length\n  }\n  resourceLimit(\"raw-token\", raw, request.maxRawTokens)?\n  resourceLimit(\"layout-token\", layout, request.maxLayoutTokens)?\n  resourceLimit(\"ast-node\", ast, request.maxAstNodes)?\n  resourceLimit(\"resolved-fact\", resolved.scopes.length + resolved.declarations.length +\n    resolved.references.length + resolved.exports.length, request.maxHirNodes)?\n  resourceLimit(\"diagnostic\", resolved.diagnostics.length, request.maxDiagnostics)\n}\n\n// The host owns I/O and package facts. K owns this invocation's fact cache,\n// parsing, graph discovery, checking and requested backend work. No state is\n// retained by a subsequent call and no compilerStep replay occurs here.\nexport function compile(\n  request: Stage1Request,\n  provide: (PreviewHostQuery) -> Result<PreviewHostFact, string>,\n  observe: bool,\n  includeExports: bool,\n) -> Result<CompilerResult, string> {\n  let producerStage = validateStage1Request(request)?\n  let mut facts: Array<PreviewHostFact> = []\n  let counts: Array<int> = [0, 0]\n  for fact in request.facts {\n    accountSourceFact(request, counts, fact)?\n    facts.push(fact)\n  }\n  let catalog = resolverHostFacts(facts)\n  let hostFacts = ResolverHostFactCatalog {\n    ...catalog,\n    provider: Some((query: PreviewHostQuery) => {\n      let fact = provide(query)?\n      accountSourceFact(request, counts, fact)?\n      Ok(fact)\n    }),\n  }\n  let resolved = resolveWithFacts(request.entry, request.root, hostFacts,\n    request.package.externModules, request.package.generatedStdModules,\n    request.maxAstNodes, request.maxAstDepth, request.languageMode)?\n  resolverBudgets(request, resolved)?\n  let preview = stage1PreviewRequest(request)\n  let checked = checkResolvedRequest(preview, resolved)?\n  let frontEnd = applyCompilerProfile(request.profile, request.languageMode, resolvedResponse(preview, resolved, checked))?\n  resourceLimit(\"diagnostic\", frontEnd.resolverDiagnostics.length +\n    frontEnd.checkerDiagnostics.length, request.maxDiagnostics)?\n  let base = CompilerResult {\n    status: frontEnd.status,\n    kind: \"typed\",\n    diagnostics: frontEnd.resolverDiagnostics,\n    checkerDiagnostics: frontEnd.checkerDiagnostics,\n    exports: if includeExports { frontEnd.exports } else { [] },\n    provenance: compilerProvenance(request.compilerSourceSetId, request.producer, producerStage),\n    generatedRust: None,\n    lowered: None,\n    observation: if observe { Some(frontEnd) } else { None },\n  }\n  if frontEnd.status != \"completed\" || request.terminal == \"typed\" {\n    return Ok(base)\n  }\n  let lowerRequest = lowerBridgeValue(request, producerStage, frontEnd)\n  if request.terminal == \"lowered\" {\n    let lowered = lowerValue(lowerRequest)?\n    return Ok(CompilerResult {\n      ...base,\n      kind: \"lowered\",\n      status: if lowered.unsupported.length > 0 { \"unsupported\" } else { \"completed\" },\n      lowered: Some(lowered),\n    })\n  }\n  let lowered = lowerValue(lowerRequest)?\n  let rust = emitRust(lowered)?\n  if rust.byteLength() > request.maxGeneratedRustBytes {\n    return Err(\"Stage 1 generated Rust exceeds {request.maxGeneratedRustBytes} bytes\")\n  }\n  Ok(CompilerResult { ...base, kind: \"rust-source\", generatedRust: Some(rust) })\n}\n",
      "sourceSha256": "7ec1062435670c6fa75abc9135025cab17a4bdbccb9303c391261230b05c8b54"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/stage1_types.tpz",
      "language": "topaz",
      "bytes": 5140,
      "sha256": "1397cf1a1385a6b1a61591fe0320cd229da88c9eecbb3abf1c927e43e88b9bb0",
      "content": "import std.json as jsonBoundary\n\nimport types { PreviewTypeAtom }\nimport literal { normalizeLegacyIrDetail }\n\nexport const STAGE1_EXCHANGE_SCHEMA = \"topaz.compiler.stage1-exchange/v2\"\nexport const STAGE1_IR_SCHEMA = \"topaz.compiler.stage1-ir/v5\"\nconst STAGE1_PROVENANCE_SCHEMA = \"topaz.compiler.stage1-provenance/v1\"\n\nexport record Stage1Module derives JSON {\n  schema: string,\n  identity: string,\n  path: string,\n  sourceOrdinal: int,\n  initializationOrdinal: int,\n  entry: bool,\n  extern: bool,\n  operationIds: Array<string>,\n  generatedStd: bool,\n  // The package language mode the module was checked under.\n  languageMode: string,\n  // Target module identities of this module's import edges, in the\n  // resolver's edge order (one per import item).\n  importEdges: Array<string>,\n}\n\nexport record Stage1Operation derives JSON {\n  schema: string,\n  id: string,\n  module: string,\n  lo: int,\n  hi: int,\n  parentId: string,\n  role: string,\n  kind: string,\n  detail: string,\n  operands: Array<string>,\n  operandLabels: Array<string>,\n  semanticType: string,\n  representation: string,\n  referenceIdentity: string,\n  bindingName: string,\n  // On a `binding/capture` for a closure, nested function, or `defer`, whether\n  // this captured reference is an assignment target.\n  bindingMutable: bool,\n  bindingStorage: string,\n  declarationIdentity: string,\n  controlKind: string,\n  controlTarget: string,\n  cleanupIds: Array<string>,\n  callTarget: string,\n  callCalleeKind: string,\n  callMethod: string,\n  callMethodClass: string,\n  callOptional: bool,\n  callShadowFirst: bool,\n  callStageMethod: string,\n  callArguments: Array<string>,\n  callEvaluations: Array<string>,\n  runtimeLeaf: string,\n  generatedNameSeed: string,\n  // Full checked type of `semanticType` as the checker's preorder atom list.\n  // A value identifier or shorthand record pattern field the checker leaves\n  // untyped carries its declaration's type here with `semanticType` empty.\n  semanticTypeAtoms: Array<PreviewTypeAtom>,\n  // Source-declared type: parameter, function signature, annotated let/const.\n  // Nonempty lists have exactly one root.\n  declaredTypeAtoms: Array<PreviewTypeAtom>,\n  // Source-written call type arguments in source order, one rooted tree each.\n  callTypeArguments: Array<Array<PreviewTypeAtom>>,\n  // Type declaration signature: root identity, typeParameters, fields,\n  // variants with payload types, or newtype/alias base. Empty on other operations.\n  typeDefinition: Array<PreviewTypeAtom>,\n  importModule: string,\n  // `kind|sourceName|boundName|lo|hi` per bound import name.\n  importBindings: Array<string>,\n  // Runtime file of this operation's span: the source ordinal of its module.\n  sourceOrdinal: int,\n  // Parser-owned cooked-byte to original-source runs for a literal text segment.\n  literalSourceMap: string = \"\",\n  // Missing fields in historical v5 responses retain their source codec.\n  literalEncoding: string = \"legacy-source/v1\",\n  // The namespace/name reference above can name different local bindings in\n  // different scopes. Optimization uses the resolver's exact declaration span.\n  // Historical v5 inputs without this field remain conservatively unknown.\n  referenceDeclarationIdentity: string = \"\",\n}\n\nexport record Stage1Provenance derives JSON {\n  schema: string,\n  engine: string,\n  producerStage: int,\n  resultStage: int,\n  defaultEngine: string,\n  exchangeSchema: string,\n  irSchema: string,\n  sourceSetId: string,\n  fixedPoint: string,\n}\n\nexport record Stage1Response derives JSON {\n  schema: string,\n  status: string,\n  frontEnd: string,\n  loweredModules: Array<Stage1Module>,\n  loweredOperations: Array<Stage1Operation>,\n  generatedRust: string,\n  unsupported: Array<string>,\n  provenance: Stage1Provenance,\n}\n\nexport function decodeStage1Response(text: string) -> Result<Stage1Response, string> {\n  let response = jsonBoundary.parseAs<Stage1Response>(text)?\n  let mut operations: Array<Stage1Operation> = []\n  for op in response.loweredOperations {\n    if op.literalEncoding == \"checked-values/v1\" { operations.push(op) }\n    else if op.literalEncoding == \"legacy-source/v1\" {\n      let mut languageMode = \"topaz-5.20\"\n      for module in response.loweredModules { if module.identity == op.module { languageMode = module.languageMode } }\n      operations.push(Stage1Operation { ...op, detail: normalizeLegacyIrDetail(op.kind, op.detail, languageMode)?, literalEncoding: \"checked-values/v1\" })\n    } else { return Err(\"unknown Stage 1 literal encoding\") }\n  }\n  Ok(Stage1Response { ...response, loweredOperations: operations })\n}\n\nexport function compilerProvenance(\n  sourceSetId: string,\n  producer: string,\n  producerStage: int,\n) -> Stage1Provenance {\n  Stage1Provenance {\n    schema: STAGE1_PROVENANCE_SCHEMA,\n    engine: producer,\n    producerStage: producerStage,\n    resultStage: producerStage,\n    defaultEngine: \"rust-stage0\",\n    exchangeSchema: STAGE1_EXCHANGE_SCHEMA,\n    irSchema: STAGE1_IR_SCHEMA,\n    sourceSetId: sourceSetId,\n    fixedPoint: \"not-run\",\n  }\n}\n\nexport record LoweringOutput {\n  modules: Array<Stage1Module>,\n  operations: Array<Stage1Operation>,\n  unsupported: Array<string>,\n}\n",
      "sourceSha256": "90b36312360662d1c51e4a6a1bea5427d2247d85040f2937958820cc39b8bb5e"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/types.tpz",
      "language": "topaz",
      "bytes": 7849,
      "sha256": "689612b142727dbbfe6f14adb2c6cb4892d197d893d2fca5cfc7aeaf2370fdc7",
      "content": "import std.json as jsonBoundary\n\nexport record PreviewToken derives JSON {\n  kind: string,\n  lo: int,\n  hi: int,\n  stream: string,\n  synthetic: bool,\n}\n\nexport record PreviewDiagnostic derives JSON {\n  code: string,\n  message: string,\n  lo: int,\n  hi: int,\n  notes: Array<string>,\n}\n\nexport record PreviewAstAttribute derives JSON {\n  name: string,\n  kind: string,\n  value: string,\n}\n\nexport record PreviewAstNode derives JSON {\n  kind: string,\n  lo: int,\n  hi: int,\n  parent: int,\n  field: string,\n  index: int,\n  attributeNames: Array<string>,\n  attributeKinds: Array<string>,\n  attributeValues: Array<string>,\n}\n\nexport record SyntaxNode {\n  kind: string,\n  lo: int,\n  hi: int,\n  field: string,\n  index: int,\n  attributes: Array<PreviewAstAttribute>,\n  children: Array<SyntaxNode>,\n}\n\nexport record RawResult {\n  tokens: Array<PreviewToken>,\n  diagnostics: Array<PreviewDiagnostic>,\n}\n\nexport record LayoutResult {\n  tokens: Array<PreviewToken>,\n  diagnostics: Array<PreviewDiagnostic>,\n}\n\nexport record ParseResult {\n  root: SyntaxNode,\n  nodes: Array<PreviewAstNode>,\n  diagnostics: Array<PreviewDiagnostic>,\n}\n\nexport record PreviewDirectoryEntry derives JSON {\n  name: string,\n  kind: string,\n}\n\nexport record PreviewHostFact derives JSON {\n  kind: string,\n  mountId: string,\n  logicalPath: string,\n  status: string,\n  source: string,\n  entries: Array<PreviewDirectoryEntry>,\n  aliasClass: string,\n  reasonCode: string,\n}\n\nexport record PreviewHostQuery derives JSON {\n  kind: string,\n  mountId: string,\n  logicalPath: string,\n}\n\nexport record PreviewGeneratedStdModule derives JSON {\n  identity: string,\n  path: string,\n  source: string,\n}\n\nexport record PreviewModuleResult derives JSON {\n  sourceOrdinal: int,\n  identity: string,\n  path: string,\n  source: string,\n  entry: bool,\n  extern: bool,\n  generatedStd: bool,\n  raw: Array<PreviewToken>,\n  layout: Array<PreviewToken>,\n  ast: Array<PreviewAstNode>,\n}\n\nexport record PreviewImportEdge derives JSON {\n  from: string,\n  to: string,\n}\n\nexport record PreviewResolvedScope derives JSON {\n  moduleIndex: int,\n  ordinal: int,\n  parentOrdinal: int,\n  kind: string,\n  lo: int,\n  hi: int,\n}\n\nexport record PreviewResolvedDeclaration derives JSON {\n  moduleIndex: int,\n  scopeOrdinal: int,\n  name: string,\n  namespace: string,\n  declarationKind: string,\n  lo: int,\n  hi: int,\n  exported: bool,\n  targetModule: string,\n  targetName: string,\n}\n\nexport record PreviewResolvedReference derives JSON {\n  moduleIndex: int,\n  scopeOrdinal: int,\n  name: string,\n  namespace: string,\n  role: string,\n  lo: int,\n  hi: int,\n  targetModuleIndex: int,\n  targetLo: int,\n  targetHi: int,\n  targetNamespace: string,\n  targetModule: string,\n  targetName: string,\n}\n\nexport record PreviewResolvedExport derives JSON {\n  moduleIndex: int,\n  name: string,\n  namespace: string,\n  declarationLo: int,\n  declarationHi: int,\n}\n\nexport record PreviewResolvedDiagnostic derives JSON {\n  moduleIndex: int,\n  code: string,\n  message: string,\n  lo: int,\n  hi: int,\n  notes: Array<string>,\n}\n\nexport record ResolveResult {\n  queries: Array<PreviewHostQuery>,\n  modules: Array<PreviewModuleResult>,\n  edges: Array<PreviewImportEdge>,\n  scopes: Array<PreviewResolvedScope>,\n  declarations: Array<PreviewResolvedDeclaration>,\n  references: Array<PreviewResolvedReference>,\n  exports: Array<PreviewResolvedExport>,\n  diagnostics: Array<PreviewResolvedDiagnostic>,\n}\n\n// Private checker exchange. Types are a strict preorder tree so the public\n// record surface itself stays non-recursive and JSON-round-trippable.\nexport record PreviewTypeAtom derives JSON {\n  parent: int,\n  field: string,\n  index: int,\n  edgeName: string,\n  kind: string,\n  name: string,\n  value: string,\n  identity: string,\n  origin: string,\n}\n\nexport record PreviewTypedNode derives JSON {\n  moduleIndex: int,\n  nodeKind: string,\n  lo: int,\n  hi: int,\n  typeValue: Array<PreviewTypeAtom>,\n  ambient: bool,\n}\n\nexport record PreviewCallArgument derives JSON {\n  bindingKind: string,\n  bindingName: string,\n  sourceIndex: Option<int>,\n  lo: int,\n  hi: int,\n}\n\nexport record PreviewCallEvaluation derives JSON {\n  kind: string,\n  argumentIndex: int,\n}\n\nexport record PreviewTypedCall derives JSON {\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  calleeLo: int,\n  calleeHi: int,\n  calleeType: Array<PreviewTypeAtom>,\n  resultType: Array<PreviewTypeAtom>,\n  targetIdentity: string,\n  ambient: bool,\n  calleeKind: string,\n  method: string,\n  methodClass: string,\n  optional: bool,\n  shadowFirst: bool,\n  stageMethod: string,\n  arguments: Array<PreviewCallArgument>,\n  evaluations: Array<PreviewCallEvaluation>,\n}\n\nexport record PreviewTypedCapture derives JSON {\n  moduleIndex: int,\n  closureLo: int,\n  closureHi: int,\n  referenceLo: int,\n  referenceHi: int,\n  declarationLo: int,\n  declarationHi: int,\n  name: string,\n  typeValue: Array<PreviewTypeAtom>,\n  ambient: bool,\n}\n\nexport record PreviewCheckLabel derives JSON {\n  moduleIndex: int,\n  lo: int,\n  hi: int,\n  message: string,\n}\n\nexport record PreviewCheckDiagnostic derives JSON {\n  moduleIndex: int,\n  code: string,\n  message: string,\n  primaryMessage: string,\n  lo: int,\n  hi: int,\n  secondary: Array<PreviewCheckLabel>,\n  notes: Array<string>,\n  profileRule: string,\n}\n\nexport record CheckResult {\n  nodes: Array<PreviewTypedNode>,\n  calls: Array<PreviewTypedCall>,\n  captures: Array<PreviewTypedCapture>,\n  diagnostics: Array<PreviewCheckDiagnostic>,\n}\n\nexport record LowerBridgeRequest derives JSON {\n  producer: string,\n  producerStage: int,\n  frontEnd: string,\n  frontEndStatus: string,\n  modules: Array<PreviewModuleResult>,\n  references: Array<PreviewResolvedReference>,\n  typedNodes: Array<PreviewTypedNode>,\n  typedCalls: Array<PreviewTypedCall>,\n  typedCaptures: Array<PreviewTypedCapture>,\n  edges: Array<PreviewImportEdge>,\n  moduleDeclarations: Array<PreviewResolvedDeclaration>,\n  languageMode: string,\n  sourceSetId: string,\n  maxLoweredNodes: int,\n}\n\nexport function encodeLowerBridgeRequest(\n  request: LowerBridgeRequest,\n) -> Result<Bytes, string> {\n  Ok((jsonBoundary.stringify(request)?).encodeUtf8())\n}\n\nexport function decodeLowerBridgeRequest(\n  text: string,\n) -> Result<LowerBridgeRequest, string> {\n  jsonBoundary.parseAs<LowerBridgeRequest>(text)\n}\n\n// Known display facts retain aggregate boundaries so the standard interpolation\n// budget is applied once to the whole value, including nested containers.\nexport enum KnownLiteralRender {\n  Text(string),\n  Array(Array<KnownLiteralRender>),\n  Record(Array<KnownLiteralRenderField>),\n}\n\nexport record KnownLiteralRenderField {\n  name: string,\n  shape: KnownLiteralRender,\n}\n\nexport function renderKnownLiteral(value: KnownLiteralRender) -> string {\n  let mut out: Array<string> = []\n  let mut fuel = [100000]\n  let _ = renderKnownLiteralInto(value, out, fuel, 0)\n  out.join(\"\")\n}\n\nfunction renderKnownLiteralInto(\n  value: KnownLiteralRender, out: Array<string>, fuel: Array<int>, depth: int,\n) -> bool {\n  let remaining = match fuel.get(0) { case Some(value) => value; case None => 0 }\n  let mut budget = fuel\n  let mut parts = out\n  if remaining == 0 || depth > 128 { parts.push(\"...\"); return false }\n  budget[0] = remaining - 1\n  match value {\n    case Text(text) => { parts.push(text) }\n    case Array(items) => {\n      parts.push(\"[\")\n      let mut index = 0\n      for item in items {\n        if index != 0 { parts.push(\", \") }\n        if !renderKnownLiteralInto(item, out, fuel, depth + 1) { return false }\n        index += 1\n      }\n      parts.push(\"]\")\n    }\n    case Record(fields) => {\n      parts.push(\"\\{ \")\n      let mut index = 0\n      for field in fields {\n        if index != 0 { parts.push(\", \") }\n        parts.push(field.name)\n        parts.push(\": \")\n        if !renderKnownLiteralInto(field.shape, out, fuel, depth + 1) { return false }\n        index += 1\n      }\n      parts.push(\" \\}\")\n    }\n  }\n  true\n}\n",
      "sourceSha256": "689612b142727dbbfe6f14adb2c6cb4892d197d893d2fca5cfc7aeaf2370fdc7"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/unicode.tpz",
      "language": "topaz",
      "bytes": 9697,
      "sha256": "df85836258be748486d23e556bba2cfe91411e7f8fe7d819843fb5a933a37881",
      "content": "import unicode_tables {\n  CANONICAL_COMBINING_CLASS_KEYS,\n  CANONICAL_COMBINING_CLASS_VALUES,\n  CANONICAL_DECOMPOSITION_KEYS,\n  CANONICAL_DECOMPOSITION_OFFSETS,\n  CANONICAL_DECOMPOSITION_VALUES,\n  CASE_FOLD_KEYS,\n  CASE_FOLD_OFFSETS,\n  CASE_FOLD_VALUES,\n  CodePointRange,\n  EMOJI_RANGES,\n  LETTER_RANGES,\n  NUMBER_RANGES,\n}\n\n// Unicode Standard Annex #15 constants for algorithmic Hangul decomposition.\nconst HANGUL_SYLLABLE_BASE = 44032\nconst HANGUL_SYLLABLE_LIMIT = 55204\nconst HANGUL_LEADING_BASE = 4352\nconst HANGUL_VOWEL_BASE = 4449\nconst HANGUL_TRAILING_BASE = 4519\nconst HANGUL_SYLLABLES_PER_LEADING = 588\nconst HANGUL_TRAILING_COUNT = 28\n// Suggestions skip short names and admit edits up to one third of the longer spelling.\nconst MIN_SUGGESTION_SCALARS = 4\nconst MAX_SUGGESTION_SCALARS = 64\nconst SUGGESTION_DISTANCE_DIVISOR = 3\nconst MAX_SUGGESTION_BYTES = 256\n// This sentinel exceeds every admitted suggestion length.\nconst NO_SUGGESTION_DISTANCE = 1000000\n\nfunction contains(ranges: Array<CodePointRange>, codePoint: int) -> bool {\n  let mut lo = 0\n  let mut hi = ranges.length\n  while lo < hi {\n    let middle = lo + (hi - lo) / 2\n    let range = ranges[middle]\n    if codePoint < range.first {\n      hi = middle\n    } else if codePoint > range.last {\n      lo = middle + 1\n    } else {\n      return true\n    }\n  }\n  false\n}\n\nfunction sequenceIndex(keys: Array<int>, codePoint: int) -> int {\n  let mut lo = 0\n  let mut hi = keys.length\n  while lo < hi {\n    let middle = lo + (hi - lo) / 2\n    let candidate = keys[middle]\n    if codePoint < candidate {\n      hi = middle\n    } else if codePoint > candidate {\n      lo = middle + 1\n    } else {\n      return middle\n    }\n  }\n  -1\n}\n\nfunction combiningClass(codePoint: int) -> int {\n  let index = sequenceIndex(CANONICAL_COMBINING_CLASS_KEYS, codePoint)\n  if index >= 0 {\n    return CANONICAL_COMBINING_CLASS_VALUES[index]\n  }\n  0\n}\n\nfunction decompose(codePoint: int, output: Array<int>) -> () {\n  let mut target = output\n  if codePoint >= HANGUL_SYLLABLE_BASE && codePoint < HANGUL_SYLLABLE_LIMIT {\n    let syllable = codePoint - HANGUL_SYLLABLE_BASE\n    target.push(HANGUL_LEADING_BASE + syllable / HANGUL_SYLLABLES_PER_LEADING)\n    target.push(HANGUL_VOWEL_BASE +\n      (syllable % HANGUL_SYLLABLES_PER_LEADING) / HANGUL_TRAILING_COUNT)\n    let trailing = syllable % HANGUL_TRAILING_COUNT\n    if trailing != 0 {\n      target.push(HANGUL_TRAILING_BASE + trailing)\n    }\n    return ()\n  }\n  let index = sequenceIndex(CANONICAL_DECOMPOSITION_KEYS, codePoint)\n  if index < 0 {\n    target.push(codePoint)\n    return ()\n  }\n  let mut offset = CANONICAL_DECOMPOSITION_OFFSETS[index]\n  let limit = CANONICAL_DECOMPOSITION_OFFSETS[index + 1]\n  while offset < limit {\n    target.push(CANONICAL_DECOMPOSITION_VALUES[offset])\n    offset += 1\n  }\n  ()\n}\n\nfunction codePointText(codePoint: int) -> string {\n  match codePoint.toCodePoint() {\n    case Some(value) => value\n    case None => \"\"\n  }\n}\n\nexport function nfd(value: string) -> string {\n  let mut codePoints: Array<int> = []\n  for scalar in value.scalars() {\n    match scalar.codePointAt(0) {\n      case Some(codePoint) => decompose(codePoint, codePoints)\n      case None => ()\n    }\n  }\n  let mut index = 1\n  while index < codePoints.length {\n    let left = codePoints[index - 1]\n    let right = codePoints[index]\n    let leftClass = combiningClass(left)\n    let rightClass = combiningClass(right)\n    if rightClass != 0 && leftClass > rightClass {\n      codePoints[index - 1] = right\n      codePoints[index] = left\n      if index > 1 {\n        index -= 1\n      } else {\n        index += 1\n      }\n    } else {\n      index += 1\n    }\n  }\n  let mut output: Array<string> = []\n  for codePoint in codePoints {\n    output.push(codePointText(codePoint))\n  }\n  output.join(\"\")\n}\n\nexport function caseFold(value: string) -> string {\n  let mut output: Array<string> = []\n  for scalar in value.scalars() {\n    match scalar.codePointAt(0) {\n      case Some(codePoint) => {\n        let index = sequenceIndex(CASE_FOLD_KEYS, codePoint)\n        if index < 0 {\n          output.push(scalar)\n        } else {\n          let mut offset = CASE_FOLD_OFFSETS[index]\n          let limit = CASE_FOLD_OFFSETS[index + 1]\n          while offset < limit {\n            output.push(codePointText(CASE_FOLD_VALUES[offset]))\n            offset += 1\n          }\n        }\n      }\n      case None => ()\n    }\n  }\n  output.join(\"\")\n}\n\nfunction isIdentifierStartCodePoint(codePoint: int) -> bool {\n  codePoint == 95 ||\n    contains(LETTER_RANGES, codePoint) ||\n    contains(EMOJI_RANGES, codePoint)\n}\n\nfunction isIdentifierContinueCodePoint(codePoint: int) -> bool {\n  isIdentifierStartCodePoint(codePoint) || contains(NUMBER_RANGES, codePoint)\n}\n\nfunction byteAt(bytes: Bytes, index: int) -> int {\n  match bytes.get(index) {\n    case Some(value) => value\n    case None => -1\n  }\n}\n\nexport function utf8Width(first: int) -> int {\n  if first >= 0 && first < 128 { return 1 }\n  if first >= 194 && first <= 223 { return 2 }\n  if first >= 224 && first <= 239 { return 3 }\n  if first >= 240 && first <= 244 { return 4 }\n  0\n}\n\nfunction codePointAt(bytes: Bytes, index: int, width: int) -> Option<int> {\n  match bytes.slice(index, index + width).decodeUtf8() {\n    case Ok(text) => text.codePointAt(0)\n    case Err(_) => None\n  }\n}\n\nfunction identifierWidth(bytes: Bytes, index: int, allowNumber: bool) -> int {\n  let first = byteAt(bytes, index)\n  if first >= 0 && first < 128 {\n    let isStart = first == 95 ||\n      (first >= 65 && first <= 90) ||\n      (first >= 97 && first <= 122)\n    return if isStart || allowNumber && first >= 48 && first <= 57 { 1 } else { 0 }\n  }\n  let width = utf8Width(first)\n  if width == 0 { return 0 }\n  match codePointAt(bytes, index, width) {\n    case Some(codePoint) => {\n      let accepted = if allowNumber {\n        isIdentifierContinueCodePoint(codePoint)\n      } else {\n        isIdentifierStartCodePoint(codePoint)\n      }\n      if accepted { width } else { 0 }\n    }\n    case None => 0\n  }\n}\n\nexport function identifierStartWidth(bytes: Bytes, index: int) -> int {\n  identifierWidth(bytes, index, false)\n}\n\nfunction identifierContinueWidth(bytes: Bytes, index: int) -> int {\n  identifierWidth(bytes, index, true)\n}\n\nexport function identifierContinueEnd(bytes: Bytes, start: int) -> int {\n  let mut index = start\n  let mut width = identifierContinueWidth(bytes, index)\n  while width > 0 {\n    index += width\n    width = identifierContinueWidth(bytes, index)\n  }\n  index\n}\n\nexport function identifierEnd(bytes: Bytes, start: int) -> int {\n  let width = identifierStartWidth(bytes, start)\n  if width == 0 { return start }\n  identifierContinueEnd(bytes, start + width)\n}\n\nfunction minimum3(left: int, middle: int, right: int) -> int {\n  let mut best = left\n  if middle < best {\n    best = middle\n  }\n  if right < best {\n    best = right\n  }\n  best\n}\n\nfunction osaDistance(leftScalars: Array<string>, rightScalars: Array<string>) -> int {\n  let mut previousPrevious: Array<int> = []\n  let mut previous: Array<int> = []\n  let mut current: Array<int> = []\n  let mut column = 0\n  while column <= rightScalars.length {\n    previousPrevious.push(0)\n    previous.push(column)\n    current.push(0)\n    column += 1\n  }\n  let mut row = 1\n  while row <= leftScalars.length {\n    current[0] = row\n    column = 1\n    while column <= rightScalars.length {\n      let substitution = previous[column - 1] +\n        if leftScalars[row - 1] == rightScalars[column - 1] {\n          0\n        } else {\n          1\n        }\n      let deletion = previous[column] + 1\n      let insertion = current[column - 1] + 1\n      let mut best = minimum3(substitution, deletion, insertion)\n      if row > 1 && column > 1 &&\n        leftScalars[row - 1] == rightScalars[column - 2] &&\n        leftScalars[row - 2] == rightScalars[column - 1] {\n        let transposition = previousPrevious[column - 2] + 1\n        if transposition < best {\n          best = transposition\n        }\n      }\n      current[column] = best\n      column += 1\n    }\n    let recycled = previousPrevious\n    previousPrevious = previous\n    previous = current\n    current = recycled\n    row += 1\n  }\n  previous[rightScalars.length]\n}\n\nexport function didYouMean(target: string, candidates: Array<string>) -> string {\n  if target.byteLength() > MAX_SUGGESTION_BYTES {\n    return \"\"\n  }\n  let targetScalars = target.scalars()\n  let targetLength = targetScalars.length\n  if targetLength > MAX_SUGGESTION_SCALARS {\n    return \"\"\n  }\n  let mut best = \"\"\n  let mut bestDistance = NO_SUGGESTION_DISTANCE\n  for candidate in candidates {\n    if candidate != target && candidate.byteLength() <= MAX_SUGGESTION_BYTES {\n      let candidateScalars = candidate.scalars()\n      let candidateLength = candidateScalars.length\n      if candidateLength >= MIN_SUGGESTION_SCALARS &&\n        candidateLength <= MAX_SUGGESTION_SCALARS {\n        let longest = if targetLength > candidateLength { targetLength } else { candidateLength }\n        let mut threshold = longest / SUGGESTION_DISTANCE_DIVISOR\n        if threshold < 1 {\n          threshold = 1\n        }\n        let lengthDifference = if targetLength > candidateLength {\n          targetLength - candidateLength\n        } else {\n          candidateLength - targetLength\n        }\n        if lengthDifference <= threshold {\n          let distance = osaDistance(targetScalars, candidateScalars)\n          if distance <= threshold &&\n            (best == \"\" || distance < bestDistance ||\n              distance == bestDistance && candidate < best) {\n            best = candidate\n            bestDistance = distance\n          }\n        }\n      }\n    }\n  }\n  if best == \"\" { \"\" } else { \"; did you mean `{best}`?\" }\n}\n",
      "sourceSha256": "df85836258be748486d23e556bba2cfe91411e7f8fe7d819843fb5a933a37881"
    },
    {
      "path": "compiler/crates/topaz_self_frontend/topaz/unicode_tables.tpz",
      "language": "topaz",
      "bytes": 133510,
      "sha256": "16293a12c70d71705abbf76523c0667497c52a4f30360a794e2e80995aceae3c",
      "content": "// GENERATED by `cargo run -p unicode-gen` — do not edit.\n// Pinned UCD 16.0.0 data is vendored under tools/unicode-gen/data/.\n\nexport record CodePointRange {\n  first: int,\n  last: int,\n}\n\nexport let LETTER_RANGES: Array<CodePointRange> = [\n  CodePointRange { first: 65, last: 90 },\n  CodePointRange { first: 97, last: 122 },\n  CodePointRange { first: 170, last: 170 },\n  CodePointRange { first: 181, last: 181 },\n  CodePointRange { first: 186, last: 186 },\n  CodePointRange { first: 192, last: 214 },\n  CodePointRange { first: 216, last: 246 },\n  CodePointRange { first: 248, last: 705 },\n  CodePointRange { first: 710, last: 721 },\n  CodePointRange { first: 736, last: 740 },\n  CodePointRange { first: 748, last: 748 },\n  CodePointRange { first: 750, last: 750 },\n  CodePointRange { first: 880, last: 884 },\n  CodePointRange { first: 886, last: 887 },\n  CodePointRange { first: 890, last: 893 },\n  CodePointRange { first: 895, last: 895 },\n  CodePointRange { first: 902, last: 902 },\n  CodePointRange { first: 904, last: 906 },\n  CodePointRange { first: 908, last: 908 },\n  CodePointRange { first: 910, last: 929 },\n  CodePointRange { first: 931, last: 1013 },\n  CodePointRange { first: 1015, last: 1153 },\n  CodePointRange { first: 1162, last: 1327 },\n  CodePointRange { first: 1329, last: 1366 },\n  CodePointRange { first: 1369, last: 1369 },\n  CodePointRange { first: 1376, last: 1416 },\n  CodePointRange { first: 1488, last: 1514 },\n  CodePointRange { first: 1519, last: 1522 },\n  CodePointRange { first: 1568, last: 1610 },\n  CodePointRange { first: 1646, last: 1647 },\n  CodePointRange { first: 1649, last: 1747 },\n  CodePointRange { first: 1749, last: 1749 },\n  CodePointRange { first: 1765, last: 1766 },\n  CodePointRange { first: 1774, last: 1775 },\n  CodePointRange { first: 1786, last: 1788 },\n  CodePointRange { first: 1791, last: 1791 },\n  CodePointRange { first: 1808, last: 1808 },\n  CodePointRange { first: 1810, last: 1839 },\n  CodePointRange { first: 1869, last: 1957 },\n  CodePointRange { first: 1969, last: 1969 },\n  CodePointRange { first: 1994, last: 2026 },\n  CodePointRange { first: 2036, last: 2037 },\n  CodePointRange { first: 2042, last: 2042 },\n  CodePointRange { first: 2048, last: 2069 },\n  CodePointRange { first: 2074, last: 2074 },\n  CodePointRange { first: 2084, last: 2084 },\n  CodePointRange { first: 2088, last: 2088 },\n  CodePointRange { first: 2112, last: 2136 },\n  CodePointRange { first: 2144, last: 2154 },\n  CodePointRange { first: 2160, last: 2183 },\n  CodePointRange { first: 2185, last: 2190 },\n  CodePointRange { first: 2208, last: 2249 },\n  CodePointRange { first: 2308, last: 2361 },\n  CodePointRange { first: 2365, last: 2365 },\n  CodePointRange { first: 2384, last: 2384 },\n  CodePointRange { first: 2392, last: 2401 },\n  CodePointRange { first: 2417, last: 2432 },\n  CodePointRange { first: 2437, last: 2444 },\n  CodePointRange { first: 2447, last: 2448 },\n  CodePointRange { first: 2451, last: 2472 },\n  CodePointRange { first: 2474, last: 2480 },\n  CodePointRange { first: 2482, last: 2482 },\n  CodePointRange { first: 2486, last: 2489 },\n  CodePointRange { first: 2493, last: 2493 },\n  CodePointRange { first: 2510, last: 2510 },\n  CodePointRange { first: 2524, last: 2525 },\n  CodePointRange { first: 2527, last: 2529 },\n  CodePointRange { first: 2544, last: 2545 },\n  CodePointRange { first: 2556, last: 2556 },\n  CodePointRange { first: 2565, last: 2570 },\n  CodePointRange { first: 2575, last: 2576 },\n  CodePointRange { first: 2579, last: 2600 },\n  CodePointRange { first: 2602, last: 2608 },\n  CodePointRange { first: 2610, last: 2611 },\n  CodePointRange { first: 2613, last: 2614 },\n  CodePointRange { first: 2616, last: 2617 },\n  CodePointRange { first: 2649, last: 2652 },\n  CodePointRange { first: 2654, last: 2654 },\n  CodePointRange { first: 2674, last: 2676 },\n  CodePointRange { first: 2693, last: 2701 },\n  CodePointRange { first: 2703, last: 2705 },\n  CodePointRange { first: 2707, last: 2728 },\n  CodePointRange { first: 2730, last: 2736 },\n  CodePointRange { first: 2738, last: 2739 },\n  CodePointRange { first: 2741, last: 2745 },\n  CodePointRange { first: 2749, last: 2749 },\n  CodePointRange { first: 2768, last: 2768 },\n  CodePointRange { first: 2784, last: 2785 },\n  CodePointRange { first: 2809, last: 2809 },\n  CodePointRange { first: 2821, last: 2828 },\n  CodePointRange { first: 2831, last: 2832 },\n  CodePointRange { first: 2835, last: 2856 },\n  CodePointRange { first: 2858, last: 2864 },\n  CodePointRange { first: 2866, last: 2867 },\n  CodePointRange { first: 2869, last: 2873 },\n  CodePointRange { first: 2877, last: 2877 },\n  CodePointRange { first: 2908, last: 2909 },\n  CodePointRange { first: 2911, last: 2913 },\n  CodePointRange { first: 2929, last: 2929 },\n  CodePointRange { first: 2947, last: 2947 },\n  CodePointRange { first: 2949, last: 2954 },\n  CodePointRange { first: 2958, last: 2960 },\n  CodePointRange { first: 2962, last: 2965 },\n  CodePointRange { first: 2969, last: 2970 },\n  CodePointRange { first: 2972, last: 2972 },\n  CodePointRange { first: 2974, last: 2975 },\n  CodePointRange { first: 2979, last: 2980 },\n  CodePointRange { first: 2984, last: 2986 },\n  CodePointRange { first: 2990, last: 3001 },\n  CodePointRange { first: 3024, last: 3024 },\n  CodePointRange { first: 3077, last: 3084 },\n  CodePointRange { first: 3086, last: 3088 },\n  CodePointRange { first: 3090, last: 3112 },\n  CodePointRange { first: 3114, last: 3129 },\n  CodePointRange { first: 3133, last: 3133 },\n  CodePointRange { first: 3160, last: 3162 },\n  CodePointRange { first: 3165, last: 3165 },\n  CodePointRange { first: 3168, last: 3169 },\n  CodePointRange { first: 3200, last: 3200 },\n  CodePointRange { first: 3205, last: 3212 },\n  CodePointRange { first: 3214, last: 3216 },\n  CodePointRange { first: 3218, last: 3240 },\n  CodePointRange { first: 3242, last: 3251 },\n  CodePointRange { first: 3253, last: 3257 },\n  CodePointRange { first: 3261, last: 3261 },\n  CodePointRange { first: 3293, last: 3294 },\n  CodePointRange { first: 3296, last: 3297 },\n  CodePointRange { first: 3313, last: 3314 },\n  CodePointRange { first: 3332, last: 3340 },\n  CodePointRange { first: 3342, last: 3344 },\n  CodePointRange { first: 3346, last: 3386 },\n  CodePointRange { first: 3389, last: 3389 },\n  CodePointRange { first: 3406, last: 3406 },\n  CodePointRange { first: 3412, last: 3414 },\n  CodePointRange { first: 3423, last: 3425 },\n  CodePointRange { first: 3450, last: 3455 },\n  CodePointRange { first: 3461, last: 3478 },\n  CodePointRange { first: 3482, last: 3505 },\n  CodePointRange { first: 3507, last: 3515 },\n  CodePointRange { first: 3517, last: 3517 },\n  CodePointRange { first: 3520, last: 3526 },\n  CodePointRange { first: 3585, last: 3632 },\n  CodePointRange { first: 3634, last: 3635 },\n  CodePointRange { first: 3648, last: 3654 },\n  CodePointRange { first: 3713, last: 3714 },\n  CodePointRange { first: 3716, last: 3716 },\n  CodePointRange { first: 3718, last: 3722 },\n  CodePointRange { first: 3724, last: 3747 },\n  CodePointRange { first: 3749, last: 3749 },\n  CodePointRange { first: 3751, last: 3760 },\n  CodePointRange { first: 3762, last: 3763 },\n  CodePointRange { first: 3773, last: 3773 },\n  CodePointRange { first: 3776, last: 3780 },\n  CodePointRange { first: 3782, last: 3782 },\n  CodePointRange { first: 3804, last: 3807 },\n  CodePointRange { first: 3840, last: 3840 },\n  CodePointRange { first: 3904, last: 3911 },\n  CodePointRange { first: 3913, last: 3948 },\n  CodePointRange { first: 3976, last: 3980 },\n  CodePointRange { first: 4096, last: 4138 },\n  CodePointRange { first: 4159, last: 4159 },\n  CodePointRange { first: 4176, last: 4181 },\n  CodePointRange { first: 4186, last: 4189 },\n  CodePointRange { first: 4193, last: 4193 },\n  CodePointRange { first: 4197, last: 4198 },\n  CodePointRange { first: 4206, last: 4208 },\n  CodePointRange { first: 4213, last: 4225 },\n  CodePointRange { first: 4238, last: 4238 },\n  CodePointRange { first: 4256, last: 4293 },\n  CodePointRange { first: 4295, last: 4295 },\n  CodePointRange { first: 4301, last: 4301 },\n  CodePointRange { first: 4304, last: 4346 },\n  CodePointRange { first: 4348, last: 4680 },\n  CodePointRange { first: 4682, last: 4685 },\n  CodePointRange { first: 4688, last: 4694 },\n  CodePointRange { first: 4696, last: 4696 },\n  CodePointRange { first: 4698, last: 4701 },\n  CodePointRange { first: 4704, last: 4744 },\n  CodePointRange { first: 4746, last: 4749 },\n  CodePointRange { first: 4752, last: 4784 },\n  CodePointRange { first: 4786, last: 4789 },\n  CodePointRange { first: 4792, last: 4798 },\n  CodePointRange { first: 4800, last: 4800 },\n  CodePointRange { first: 4802, last: 4805 },\n  CodePointRange { first: 4808, last: 4822 },\n  CodePointRange { first: 4824, last: 4880 },\n  CodePointRange { first: 4882, last: 4885 },\n  CodePointRange { first: 4888, last: 4954 },\n  CodePointRange { first: 4992, last: 5007 },\n  CodePointRange { first: 5024, last: 5109 },\n  CodePointRange { first: 5112, last: 5117 },\n  CodePointRange { first: 5121, last: 5740 },\n  CodePointRange { first: 5743, last: 5759 },\n  CodePointRange { first: 5761, last: 5786 },\n  CodePointRange { first: 5792, last: 5866 },\n  CodePointRange { first: 5873, last: 5880 },\n  CodePointRange { first: 5888, last: 5905 },\n  CodePointRange { first: 5919, last: 5937 },\n  CodePointRange { first: 5952, last: 5969 },\n  CodePointRange { first: 5984, last: 5996 },\n  CodePointRange { first: 5998, last: 6000 },\n  CodePointRange { first: 6016, last: 6067 },\n  CodePointRange { first: 6103, last: 6103 },\n  CodePointRange { first: 6108, last: 6108 },\n  CodePointRange { first: 6176, last: 6264 },\n  CodePointRange { first: 6272, last: 6276 },\n  CodePointRange { first: 6279, last: 6312 },\n  CodePointRange { first: 6314, last: 6314 },\n  CodePointRange { first: 6320, last: 6389 },\n  CodePointRange { first: 6400, last: 6430 },\n  CodePointRange { first: 6480, last: 6509 },\n  CodePointRange { first: 6512, last: 6516 },\n  CodePointRange { first: 6528, last: 6571 },\n  CodePointRange { first: 6576, last: 6601 },\n  CodePointRange { first: 6656, last: 6678 },\n  CodePointRange { first: 6688, last: 6740 },\n  CodePointRange { first: 6823, last: 6823 },\n  CodePointRange { first: 6917, last: 6963 },\n  CodePointRange { first: 6981, last: 6988 },\n  CodePointRange { first: 7043, last: 7072 },\n  CodePointRange { first: 7086, last: 7087 },\n  CodePointRange { first: 7098, last: 7141 },\n  CodePointRange { first: 7168, last: 7203 },\n  CodePointRange { first: 7245, last: 7247 },\n  CodePointRange { first: 7258, last: 7293 },\n  CodePointRange { first: 7296, last: 7306 },\n  CodePointRange { first: 7312, last: 7354 },\n  CodePointRange { first: 7357, last: 7359 },\n  CodePointRange { first: 7401, last: 7404 },\n  CodePointRange { first: 7406, last: 7411 },\n  CodePointRange { first: 7413, last: 7414 },\n  CodePointRange { first: 7418, last: 7418 },\n  CodePointRange { first: 7424, last: 7615 },\n  CodePointRange { first: 7680, last: 7957 },\n  CodePointRange { first: 7960, last: 7965 },\n  CodePointRange { first: 7968, last: 8005 },\n  CodePointRange { first: 8008, last: 8013 },\n  CodePointRange { first: 8016, last: 8023 },\n  CodePointRange { first: 8025, last: 8025 },\n  CodePointRange { first: 8027, last: 8027 },\n  CodePointRange { first: 8029, last: 8029 },\n  CodePointRange { first: 8031, last: 8061 },\n  CodePointRange { first: 8064, last: 8116 },\n  CodePointRange { first: 8118, last: 8124 },\n  CodePointRange { first: 8126, last: 8126 },\n  CodePointRange { first: 8130, last: 8132 },\n  CodePointRange { first: 8134, last: 8140 },\n  CodePointRange { first: 8144, last: 8147 },\n  CodePointRange { first: 8150, last: 8155 },\n  CodePointRange { first: 8160, last: 8172 },\n  CodePointRange { first: 8178, last: 8180 },\n  CodePointRange { first: 8182, last: 8188 },\n  CodePointRange { first: 8305, last: 8305 },\n  CodePointRange { first: 8319, last: 8319 },\n  CodePointRange { first: 8336, last: 8348 },\n  CodePointRange { first: 8450, last: 8450 },\n  CodePointRange { first: 8455, last: 8455 },\n  CodePointRange { first: 8458, last: 8467 },\n  CodePointRange { first: 8469, last: 8469 },\n  CodePointRange { first: 8473, last: 8477 },\n  CodePointRange { first: 8484, last: 8484 },\n  CodePointRange { first: 8486, last: 8486 },\n  CodePointRange { first: 8488, last: 8488 },\n  CodePointRange { first: 8490, last: 8493 },\n  CodePointRange { first: 8495, last: 8505 },\n  CodePointRange { first: 8508, last: 8511 },\n  CodePointRange { first: 8517, last: 8521 },\n  CodePointRange { first: 8526, last: 8526 },\n  CodePointRange { first: 8579, last: 8580 },\n  CodePointRange { first: 11264, last: 11492 },\n  CodePointRange { first: 11499, last: 11502 },\n  CodePointRange { first: 11506, last: 11507 },\n  CodePointRange { first: 11520, last: 11557 },\n  CodePointRange { first: 11559, last: 11559 },\n  CodePointRange { first: 11565, last: 11565 },\n  CodePointRange { first: 11568, last: 11623 },\n  CodePointRange { first: 11631, last: 11631 },\n  CodePointRange { first: 11648, last: 11670 },\n  CodePointRange { first: 11680, last: 11686 },\n  CodePointRange { first: 11688, last: 11694 },\n  CodePointRange { first: 11696, last: 11702 },\n  CodePointRange { first: 11704, last: 11710 },\n  CodePointRange { first: 11712, last: 11718 },\n  CodePointRange { first: 11720, last: 11726 },\n  CodePointRange { first: 11728, last: 11734 },\n  CodePointRange { first: 11736, last: 11742 },\n  CodePointRange { first: 11823, last: 11823 },\n  CodePointRange { first: 12293, last: 12294 },\n  CodePointRange { first: 12337, last: 12341 },\n  CodePointRange { first: 12347, last: 12348 },\n  CodePointRange { first: 12353, last: 12438 },\n  CodePointRange { first: 12445, last: 12447 },\n  CodePointRange { first: 12449, last: 12538 },\n  CodePointRange { first: 12540, last: 12543 },\n  CodePointRange { first: 12549, last: 12591 },\n  CodePointRange { first: 12593, last: 12686 },\n  CodePointRange { first: 12704, last: 12735 },\n  CodePointRange { first: 12784, last: 12799 },\n  CodePointRange { first: 13312, last: 19903 },\n  CodePointRange { first: 19968, last: 42124 },\n  CodePointRange { first: 42192, last: 42237 },\n  CodePointRange { first: 42240, last: 42508 },\n  CodePointRange { first: 42512, last: 42527 },\n  CodePointRange { first: 42538, last: 42539 },\n  CodePointRange { first: 42560, last: 42606 },\n  CodePointRange { first: 42623, last: 42653 },\n  CodePointRange { first: 42656, last: 42725 },\n  CodePointRange { first: 42775, last: 42783 },\n  CodePointRange { first: 42786, last: 42888 },\n  CodePointRange { first: 42891, last: 42957 },\n  CodePointRange { first: 42960, last: 42961 },\n  CodePointRange { first: 42963, last: 42963 },\n  CodePointRange { first: 42965, last: 42972 },\n  CodePointRange { first: 42994, last: 43009 },\n  CodePointRange { first: 43011, last: 43013 },\n  CodePointRange { first: 43015, last: 43018 },\n  CodePointRange { first: 43020, last: 43042 },\n  CodePointRange { first: 43072, last: 43123 },\n  CodePointRange { first: 43138, last: 43187 },\n  CodePointRange { first: 43250, last: 43255 },\n  CodePointRange { first: 43259, last: 43259 },\n  CodePointRange { first: 43261, last: 43262 },\n  CodePointRange { first: 43274, last: 43301 },\n  CodePointRange { first: 43312, last: 43334 },\n  CodePointRange { first: 43360, last: 43388 },\n  CodePointRange { first: 43396, last: 43442 },\n  CodePointRange { first: 43471, last: 43471 },\n  CodePointRange { first: 43488, last: 43492 },\n  CodePointRange { first: 43494, last: 43503 },\n  CodePointRange { first: 43514, last: 43518 },\n  CodePointRange { first: 43520, last: 43560 },\n  CodePointRange { first: 43584, last: 43586 },\n  CodePointRange { first: 43588, last: 43595 },\n  CodePointRange { first: 43616, last: 43638 },\n  CodePointRange { first: 43642, last: 43642 },\n  CodePointRange { first: 43646, last: 43695 },\n  CodePointRange { first: 43697, last: 43697 },\n  CodePointRange { first: 43701, last: 43702 },\n  CodePointRange { first: 43705, last: 43709 },\n  CodePointRange { first: 43712, last: 43712 },\n  CodePointRange { first: 43714, last: 43714 },\n  CodePointRange { first: 43739, last: 43741 },\n  CodePointRange { first: 43744, last: 43754 },\n  CodePointRange { first: 43762, last: 43764 },\n  CodePointRange { first: 43777, last: 43782 },\n  CodePointRange { first: 43785, last: 43790 },\n  CodePointRange { first: 43793, last: 43798 },\n  CodePointRange { first: 43808, last: 43814 },\n  CodePointRange { first: 43816, last: 43822 },\n  CodePointRange { first: 43824, last: 43866 },\n  CodePointRange { first: 43868, last: 43881 },\n  CodePointRange { first: 43888, last: 44002 },\n  CodePointRange { first: 44032, last: 55203 },\n  CodePointRange { first: 55216, last: 55238 },\n  CodePointRange { first: 55243, last: 55291 },\n  CodePointRange { first: 63744, last: 64109 },\n  CodePointRange { first: 64112, last: 64217 },\n  CodePointRange { first: 64256, last: 64262 },\n  CodePointRange { first: 64275, last: 64279 },\n  CodePointRange { first: 64285, last: 64285 },\n  CodePointRange { first: 64287, last: 64296 },\n  CodePointRange { first: 64298, last: 64310 },\n  CodePointRange { first: 64312, last: 64316 },\n  CodePointRange { first: 64318, last: 64318 },\n  CodePointRange { first: 64320, last: 64321 },\n  CodePointRange { first: 64323, last: 64324 },\n  CodePointRange { first: 64326, last: 64433 },\n  CodePointRange { first: 64467, last: 64829 },\n  CodePointRange { first: 64848, last: 64911 },\n  CodePointRange { first: 64914, last: 64967 },\n  CodePointRange { first: 65008, last: 65019 },\n  CodePointRange { first: 65136, last: 65140 },\n  CodePointRange { first: 65142, last: 65276 },\n  CodePointRange { first: 65313, last: 65338 },\n  CodePointRange { first: 65345, last: 65370 },\n  CodePointRange { first: 65382, last: 65470 },\n  CodePointRange { first: 65474, last: 65479 },\n  CodePointRange { first: 65482, last: 65487 },\n  CodePointRange { first: 65490, last: 65495 },\n  CodePointRange { first: 65498, last: 65500 },\n  CodePointRange { first: 65536, last: 65547 },\n  CodePointRange { first: 65549, last: 65574 },\n  CodePointRange { first: 65576, last: 65594 },\n  CodePointRange { first: 65596, last: 65597 },\n  CodePointRange { first: 65599, last: 65613 },\n  CodePointRange { first: 65616, last: 65629 },\n  CodePointRange { first: 65664, last: 65786 },\n  CodePointRange { first: 66176, last: 66204 },\n  CodePointRange { first: 66208, last: 66256 },\n  CodePointRange { first: 66304, last: 66335 },\n  CodePointRange { first: 66349, last: 66368 },\n  CodePointRange { first: 66370, last: 66377 },\n  CodePointRange { first: 66384, last: 66421 },\n  CodePointRange { first: 66432, last: 66461 },\n  CodePointRange { first: 66464, last: 66499 },\n  CodePointRange { first: 66504, last: 66511 },\n  CodePointRange { first: 66560, last: 66717 },\n  CodePointRange { first: 66736, last: 66771 },\n  CodePointRange { first: 66776, last: 66811 },\n  CodePointRange { first: 66816, last: 66855 },\n  CodePointRange { first: 66864, last: 66915 },\n  CodePointRange { first: 66928, last: 66938 },\n  CodePointRange { first: 66940, last: 66954 },\n  CodePointRange { first: 66956, last: 66962 },\n  CodePointRange { first: 66964, last: 66965 },\n  CodePointRange { first: 66967, last: 66977 },\n  CodePointRange { first: 66979, last: 66993 },\n  CodePointRange { first: 66995, last: 67001 },\n  CodePointRange { first: 67003, last: 67004 },\n  CodePointRange { first: 67008, last: 67059 },\n  CodePointRange { first: 67072, last: 67382 },\n  CodePointRange { first: 67392, last: 67413 },\n  CodePointRange { first: 67424, last: 67431 },\n  CodePointRange { first: 67456, last: 67461 },\n  CodePointRange { first: 67463, last: 67504 },\n  CodePointRange { first: 67506, last: 67514 },\n  CodePointRange { first: 67584, last: 67589 },\n  CodePointRange { first: 67592, last: 67592 },\n  CodePointRange { first: 67594, last: 67637 },\n  CodePointRange { first: 67639, last: 67640 },\n  CodePointRange { first: 67644, last: 67644 },\n  CodePointRange { first: 67647, last: 67669 },\n  CodePointRange { first: 67680, last: 67702 },\n  CodePointRange { first: 67712, last: 67742 },\n  CodePointRange { first: 67808, last: 67826 },\n  CodePointRange { first: 67828, last: 67829 },\n  CodePointRange { first: 67840, last: 67861 },\n  CodePointRange { first: 67872, last: 67897 },\n  CodePointRange { first: 67968, last: 68023 },\n  CodePointRange { first: 68030, last: 68031 },\n  CodePointRange { first: 68096, last: 68096 },\n  CodePointRange { first: 68112, last: 68115 },\n  CodePointRange { first: 68117, last: 68119 },\n  CodePointRange { first: 68121, last: 68149 },\n  CodePointRange { first: 68192, last: 68220 },\n  CodePointRange { first: 68224, last: 68252 },\n  CodePointRange { first: 68288, last: 68295 },\n  CodePointRange { first: 68297, last: 68324 },\n  CodePointRange { first: 68352, last: 68405 },\n  CodePointRange { first: 68416, last: 68437 },\n  CodePointRange { first: 68448, last: 68466 },\n  CodePointRange { first: 68480, last: 68497 },\n  CodePointRange { first: 68608, last: 68680 },\n  CodePointRange { first: 68736, last: 68786 },\n  CodePointRange { first: 68800, last: 68850 },\n  CodePointRange { first: 68864, last: 68899 },\n  CodePointRange { first: 68938, last: 68965 },\n  CodePointRange { first: 68975, last: 68997 },\n  CodePointRange { first: 69248, last: 69289 },\n  CodePointRange { first: 69296, last: 69297 },\n  CodePointRange { first: 69314, last: 69316 },\n  CodePointRange { first: 69376, last: 69404 },\n  CodePointRange { first: 69415, last: 69415 },\n  CodePointRange { first: 69424, last: 69445 },\n  CodePointRange { first: 69488, last: 69505 },\n  CodePointRange { first: 69552, last: 69572 },\n  CodePointRange { first: 69600, last: 69622 },\n  CodePointRange { first: 69635, last: 69687 },\n  CodePointRange { first: 69745, last: 69746 },\n  CodePointRange { first: 69749, last: 69749 },\n  CodePointRange { first: 69763, last: 69807 },\n  CodePointRange { first: 69840, last: 69864 },\n  CodePointRange { first: 69891, last: 69926 },\n  CodePointRange { first: 69956, last: 69956 },\n  CodePointRange { first: 69959, last: 69959 },\n  CodePointRange { first: 69968, last: 70002 },\n  CodePointRange { first: 70006, last: 70006 },\n  CodePointRange { first: 70019, last: 70066 },\n  CodePointRange { first: 70081, last: 70084 },\n  CodePointRange { first: 70106, last: 70106 },\n  CodePointRange { first: 70108, last: 70108 },\n  CodePointRange { first: 70144, last: 70161 },\n  CodePointRange { first: 70163, last: 70187 },\n  CodePointRange { first: 70207, last: 70208 },\n  CodePointRange { first: 70272, last: 70278 },\n  CodePointRange { first: 70280, last: 70280 },\n  CodePointRange { first: 70282, last: 70285 },\n  CodePointRange { first: 70287, last: 70301 },\n  CodePointRange { first: 70303, last: 70312 },\n  CodePointRange { first: 70320, last: 70366 },\n  CodePointRange { first: 70405, last: 70412 },\n  CodePointRange { first: 70415, last: 70416 },\n  CodePointRange { first: 70419, last: 70440 },\n  CodePointRange { first: 70442, last: 70448 },\n  CodePointRange { first: 70450, last: 70451 },\n  CodePointRange { first: 70453, last: 70457 },\n  CodePointRange { first: 70461, last: 70461 },\n  CodePointRange { first: 70480, last: 70480 },\n  CodePointRange { first: 70493, last: 70497 },\n  CodePointRange { first: 70528, last: 70537 },\n  CodePointRange { first: 70539, last: 70539 },\n  CodePointRange { first: 70542, last: 70542 },\n  CodePointRange { first: 70544, last: 70581 },\n  CodePointRange { first: 70583, last: 70583 },\n  CodePointRange { first: 70609, last: 70609 },\n  CodePointRange { first: 70611, last: 70611 },\n  CodePointRange { first: 70656, last: 70708 },\n  CodePointRange { first: 70727, last: 70730 },\n  CodePointRange { first: 70751, last: 70753 },\n  CodePointRange { first: 70784, last: 70831 },\n  CodePointRange { first: 70852, last: 70853 },\n  CodePointRange { first: 70855, last: 70855 },\n  CodePointRange { first: 71040, last: 71086 },\n  CodePointRange { first: 71128, last: 71131 },\n  CodePointRange { first: 71168, last: 71215 },\n  CodePointRange { first: 71236, last: 71236 },\n  CodePointRange { first: 71296, last: 71338 },\n  CodePointRange { first: 71352, last: 71352 },\n  CodePointRange { first: 71424, last: 71450 },\n  CodePointRange { first: 71488, last: 71494 },\n  CodePointRange { first: 71680, last: 71723 },\n  CodePointRange { first: 71840, last: 71903 },\n  CodePointRange { first: 71935, last: 71942 },\n  CodePointRange { first: 71945, last: 71945 },\n  CodePointRange { first: 71948, last: 71955 },\n  CodePointRange { first: 71957, last: 71958 },\n  CodePointRange { first: 71960, last: 71983 },\n  CodePointRange { first: 71999, last: 71999 },\n  CodePointRange { first: 72001, last: 72001 },\n  CodePointRange { first: 72096, last: 72103 },\n  CodePointRange { first: 72106, last: 72144 },\n  CodePointRange { first: 72161, last: 72161 },\n  CodePointRange { first: 72163, last: 72163 },\n  CodePointRange { first: 72192, last: 72192 },\n  CodePointRange { first: 72203, last: 72242 },\n  CodePointRange { first: 72250, last: 72250 },\n  CodePointRange { first: 72272, last: 72272 },\n  CodePointRange { first: 72284, last: 72329 },\n  CodePointRange { first: 72349, last: 72349 },\n  CodePointRange { first: 72368, last: 72440 },\n  CodePointRange { first: 72640, last: 72672 },\n  CodePointRange { first: 72704, last: 72712 },\n  CodePointRange { first: 72714, last: 72750 },\n  CodePointRange { first: 72768, last: 72768 },\n  CodePointRange { first: 72818, last: 72847 },\n  CodePointRange { first: 72960, last: 72966 },\n  CodePointRange { first: 72968, last: 72969 },\n  CodePointRange { first: 72971, last: 73008 },\n  CodePointRange { first: 73030, last: 73030 },\n  CodePointRange { first: 73056, last: 73061 },\n  CodePointRange { first: 73063, last: 73064 },\n  CodePointRange { first: 73066, last: 73097 },\n  CodePointRange { first: 73112, last: 73112 },\n  CodePointRange { first: 73440, last: 73458 },\n  CodePointRange { first: 73474, last: 73474 },\n  CodePointRange { first: 73476, last: 73488 },\n  CodePointRange { first: 73490, last: 73523 },\n  CodePointRange { first: 73648, last: 73648 },\n  CodePointRange { first: 73728, last: 74649 },\n  CodePointRange { first: 74880, last: 75075 },\n  CodePointRange { first: 77712, last: 77808 },\n  CodePointRange { first: 77824, last: 78895 },\n  CodePointRange { first: 78913, last: 78918 },\n  CodePointRange { first: 78944, last: 82938 },\n  CodePointRange { first: 82944, last: 83526 },\n  CodePointRange { first: 90368, last: 90397 },\n  CodePointRange { first: 92160, last: 92728 },\n  CodePointRange { first: 92736, last: 92766 },\n  CodePointRange { first: 92784, last: 92862 },\n  CodePointRange { first: 92880, last: 92909 },\n  CodePointRange { first: 92928, last: 92975 },\n  CodePointRange { first: 92992, last: 92995 },\n  CodePointRange { first: 93027, last: 93047 },\n  CodePointRange { first: 93053, last: 93071 },\n  CodePointRange { first: 93504, last: 93548 },\n  CodePointRange { first: 93760, last: 93823 },\n  CodePointRange { first: 93952, last: 94026 },\n  CodePointRange { first: 94032, last: 94032 },\n  CodePointRange { first: 94099, last: 94111 },\n  CodePointRange { first: 94176, last: 94177 },\n  CodePointRange { first: 94179, last: 94179 },\n  CodePointRange { first: 94208, last: 100343 },\n  CodePointRange { first: 100352, last: 101589 },\n  CodePointRange { first: 101631, last: 101640 },\n  CodePointRange { first: 110576, last: 110579 },\n  CodePointRange { first: 110581, last: 110587 },\n  CodePointRange { first: 110589, last: 110590 },\n  CodePointRange { first: 110592, last: 110882 },\n  CodePointRange { first: 110898, last: 110898 },\n  CodePointRange { first: 110928, last: 110930 },\n  CodePointRange { first: 110933, last: 110933 },\n  CodePointRange { first: 110948, last: 110951 },\n  CodePointRange { first: 110960, last: 111355 },\n  CodePointRange { first: 113664, last: 113770 },\n  CodePointRange { first: 113776, last: 113788 },\n  CodePointRange { first: 113792, last: 113800 },\n  CodePointRange { first: 113808, last: 113817 },\n  CodePointRange { first: 119808, last: 119892 },\n  CodePointRange { first: 119894, last: 119964 },\n  CodePointRange { first: 119966, last: 119967 },\n  CodePointRange { first: 119970, last: 119970 },\n  CodePointRange { first: 119973, last: 119974 },\n  CodePointRange { first: 119977, last: 119980 },\n  CodePointRange { first: 119982, last: 119993 },\n  CodePointRange { first: 119995, last: 119995 },\n  CodePointRange { first: 119997, last: 120003 },\n  CodePointRange { first: 120005, last: 120069 },\n  CodePointRange { first: 120071, last: 120074 },\n  CodePointRange { first: 120077, last: 120084 },\n  CodePointRange { first: 120086, last: 120092 },\n  CodePointRange { first: 120094, last: 120121 },\n  CodePointRange { first: 120123, last: 120126 },\n  CodePointRange { first: 120128, last: 120132 },\n  CodePointRange { first: 120134, last: 120134 },\n  CodePointRange { first: 120138, last: 120144 },\n  CodePointRange { first: 120146, last: 120485 },\n  CodePointRange { first: 120488, last: 120512 },\n  CodePointRange { first: 120514, last: 120538 },\n  CodePointRange { first: 120540, last: 120570 },\n  CodePointRange { first: 120572, last: 120596 },\n  CodePointRange { first: 120598, last: 120628 },\n  CodePointRange { first: 120630, last: 120654 },\n  CodePointRange { first: 120656, last: 120686 },\n  CodePointRange { first: 120688, last: 120712 },\n  CodePointRange { first: 120714, last: 120744 },\n  CodePointRange { first: 120746, last: 120770 },\n  CodePointRange { first: 120772, last: 120779 },\n  CodePointRange { first: 122624, last: 122654 },\n  CodePointRange { first: 122661, last: 122666 },\n  CodePointRange { first: 122928, last: 122989 },\n  CodePointRange { first: 123136, last: 123180 },\n  CodePointRange { first: 123191, last: 123197 },\n  CodePointRange { first: 123214, last: 123214 },\n  CodePointRange { first: 123536, last: 123565 },\n  CodePointRange { first: 123584, last: 123627 },\n  CodePointRange { first: 124112, last: 124139 },\n  CodePointRange { first: 124368, last: 124397 },\n  CodePointRange { first: 124400, last: 124400 },\n  CodePointRange { first: 124896, last: 124902 },\n  CodePointRange { first: 124904, last: 124907 },\n  CodePointRange { first: 124909, last: 124910 },\n  CodePointRange { first: 124912, last: 124926 },\n  CodePointRange { first: 124928, last: 125124 },\n  CodePointRange { first: 125184, last: 125251 },\n  CodePointRange { first: 125259, last: 125259 },\n  CodePointRange { first: 126464, last: 126467 },\n  CodePointRange { first: 126469, last: 126495 },\n  CodePointRange { first: 126497, last: 126498 },\n  CodePointRange { first: 126500, last: 126500 },\n  CodePointRange { first: 126503, last: 126503 },\n  CodePointRange { first: 126505, last: 126514 },\n  CodePointRange { first: 126516, last: 126519 },\n  CodePointRange { first: 126521, last: 126521 },\n  CodePointRange { first: 126523, last: 126523 },\n  CodePointRange { first: 126530, last: 126530 },\n  CodePointRange { first: 126535, last: 126535 },\n  CodePointRange { first: 126537, last: 126537 },\n  CodePointRange { first: 126539, last: 126539 },\n  CodePointRange { first: 126541, last: 126543 },\n  CodePointRange { first: 126545, last: 126546 },\n  CodePointRange { first: 126548, last: 126548 },\n  CodePointRange { first: 126551, last: 126551 },\n  CodePointRange { first: 126553, last: 126553 },\n  CodePointRange { first: 126555, last: 126555 },\n  CodePointRange { first: 126557, last: 126557 },\n  CodePointRange { first: 126559, last: 126559 },\n  CodePointRange { first: 126561, last: 126562 },\n  CodePointRange { first: 126564, last: 126564 },\n  CodePointRange { first: 126567, last: 126570 },\n  CodePointRange { first: 126572, last: 126578 },\n  CodePointRange { first: 126580, last: 126583 },\n  CodePointRange { first: 126585, last: 126588 },\n  CodePointRange { first: 126590, last: 126590 },\n  CodePointRange { first: 126592, last: 126601 },\n  CodePointRange { first: 126603, last: 126619 },\n  CodePointRange { first: 126625, last: 126627 },\n  CodePointRange { first: 126629, last: 126633 },\n  CodePointRange { first: 126635, last: 126651 },\n  CodePointRange { first: 131072, last: 173791 },\n  CodePointRange { first: 173824, last: 177977 },\n  CodePointRange { first: 177984, last: 178205 },\n  CodePointRange { first: 178208, last: 183969 },\n  CodePointRange { first: 183984, last: 191456 },\n  CodePointRange { first: 191472, last: 192093 },\n  CodePointRange { first: 194560, last: 195101 },\n  CodePointRange { first: 196608, last: 201546 },\n  CodePointRange { first: 201552, last: 205743 },\n]\n\nexport let NUMBER_RANGES: Array<CodePointRange> = [\n  CodePointRange { first: 48, last: 57 },\n  CodePointRange { first: 178, last: 179 },\n  CodePointRange { first: 185, last: 185 },\n  CodePointRange { first: 188, last: 190 },\n  CodePointRange { first: 1632, last: 1641 },\n  CodePointRange { first: 1776, last: 1785 },\n  CodePointRange { first: 1984, last: 1993 },\n  CodePointRange { first: 2406, last: 2415 },\n  CodePointRange { first: 2534, last: 2543 },\n  CodePointRange { first: 2548, last: 2553 },\n  CodePointRange { first: 2662, last: 2671 },\n  CodePointRange { first: 2790, last: 2799 },\n  CodePointRange { first: 2918, last: 2927 },\n  CodePointRange { first: 2930, last: 2935 },\n  CodePointRange { first: 3046, last: 3058 },\n  CodePointRange { first: 3174, last: 3183 },\n  CodePointRange { first: 3192, last: 3198 },\n  CodePointRange { first: 3302, last: 3311 },\n  CodePointRange { first: 3416, last: 3422 },\n  CodePointRange { first: 3430, last: 3448 },\n  CodePointRange { first: 3558, last: 3567 },\n  CodePointRange { first: 3664, last: 3673 },\n  CodePointRange { first: 3792, last: 3801 },\n  CodePointRange { first: 3872, last: 3891 },\n  CodePointRange { first: 4160, last: 4169 },\n  CodePointRange { first: 4240, last: 4249 },\n  CodePointRange { first: 4969, last: 4988 },\n  CodePointRange { first: 5870, last: 5872 },\n  CodePointRange { first: 6112, last: 6121 },\n  CodePointRange { first: 6128, last: 6137 },\n  CodePointRange { first: 6160, last: 6169 },\n  CodePointRange { first: 6470, last: 6479 },\n  CodePointRange { first: 6608, last: 6618 },\n  CodePointRange { first: 6784, last: 6793 },\n  CodePointRange { first: 6800, last: 6809 },\n  CodePointRange { first: 6992, last: 7001 },\n  CodePointRange { first: 7088, last: 7097 },\n  CodePointRange { first: 7232, last: 7241 },\n  CodePointRange { first: 7248, last: 7257 },\n  CodePointRange { first: 8304, last: 8304 },\n  CodePointRange { first: 8308, last: 8313 },\n  CodePointRange { first: 8320, last: 8329 },\n  CodePointRange { first: 8528, last: 8578 },\n  CodePointRange { first: 8581, last: 8585 },\n  CodePointRange { first: 9312, last: 9371 },\n  CodePointRange { first: 9450, last: 9471 },\n  CodePointRange { first: 10102, last: 10131 },\n  CodePointRange { first: 11517, last: 11517 },\n  CodePointRange { first: 12295, last: 12295 },\n  CodePointRange { first: 12321, last: 12329 },\n  CodePointRange { first: 12344, last: 12346 },\n  CodePointRange { first: 12690, last: 12693 },\n  CodePointRange { first: 12832, last: 12841 },\n  CodePointRange { first: 12872, last: 12879 },\n  CodePointRange { first: 12881, last: 12895 },\n  CodePointRange { first: 12928, last: 12937 },\n  CodePointRange { first: 12977, last: 12991 },\n  CodePointRange { first: 42528, last: 42537 },\n  CodePointRange { first: 42726, last: 42735 },\n  CodePointRange { first: 43056, last: 43061 },\n  CodePointRange { first: 43216, last: 43225 },\n  CodePointRange { first: 43264, last: 43273 },\n  CodePointRange { first: 43472, last: 43481 },\n  CodePointRange { first: 43504, last: 43513 },\n  CodePointRange { first: 43600, last: 43609 },\n  CodePointRange { first: 44016, last: 44025 },\n  CodePointRange { first: 65296, last: 65305 },\n  CodePointRange { first: 65799, last: 65843 },\n  CodePointRange { first: 65856, last: 65912 },\n  CodePointRange { first: 65930, last: 65931 },\n  CodePointRange { first: 66273, last: 66299 },\n  CodePointRange { first: 66336, last: 66339 },\n  CodePointRange { first: 66369, last: 66369 },\n  CodePointRange { first: 66378, last: 66378 },\n  CodePointRange { first: 66513, last: 66517 },\n  CodePointRange { first: 66720, last: 66729 },\n  CodePointRange { first: 67672, last: 67679 },\n  CodePointRange { first: 67705, last: 67711 },\n  CodePointRange { first: 67751, last: 67759 },\n  CodePointRange { first: 67835, last: 67839 },\n  CodePointRange { first: 67862, last: 67867 },\n  CodePointRange { first: 68028, last: 68029 },\n  CodePointRange { first: 68032, last: 68047 },\n  CodePointRange { first: 68050, last: 68095 },\n  CodePointRange { first: 68160, last: 68168 },\n  CodePointRange { first: 68221, last: 68222 },\n  CodePointRange { first: 68253, last: 68255 },\n  CodePointRange { first: 68331, last: 68335 },\n  CodePointRange { first: 68440, last: 68447 },\n  CodePointRange { first: 68472, last: 68479 },\n  CodePointRange { first: 68521, last: 68527 },\n  CodePointRange { first: 68858, last: 68863 },\n  CodePointRange { first: 68912, last: 68921 },\n  CodePointRange { first: 68928, last: 68937 },\n  CodePointRange { first: 69216, last: 69246 },\n  CodePointRange { first: 69405, last: 69414 },\n  CodePointRange { first: 69457, last: 69460 },\n  CodePointRange { first: 69573, last: 69579 },\n  CodePointRange { first: 69714, last: 69743 },\n  CodePointRange { first: 69872, last: 69881 },\n  CodePointRange { first: 69942, last: 69951 },\n  CodePointRange { first: 70096, last: 70105 },\n  CodePointRange { first: 70113, last: 70132 },\n  CodePointRange { first: 70384, last: 70393 },\n  CodePointRange { first: 70736, last: 70745 },\n  CodePointRange { first: 70864, last: 70873 },\n  CodePointRange { first: 71248, last: 71257 },\n  CodePointRange { first: 71360, last: 71369 },\n  CodePointRange { first: 71376, last: 71395 },\n  CodePointRange { first: 71472, last: 71483 },\n  CodePointRange { first: 71904, last: 71922 },\n  CodePointRange { first: 72016, last: 72025 },\n  CodePointRange { first: 72688, last: 72697 },\n  CodePointRange { first: 72784, last: 72812 },\n  CodePointRange { first: 73040, last: 73049 },\n  CodePointRange { first: 73120, last: 73129 },\n  CodePointRange { first: 73552, last: 73561 },\n  CodePointRange { first: 73664, last: 73684 },\n  CodePointRange { first: 74752, last: 74862 },\n  CodePointRange { first: 90416, last: 90425 },\n  CodePointRange { first: 92768, last: 92777 },\n  CodePointRange { first: 92864, last: 92873 },\n  CodePointRange { first: 93008, last: 93017 },\n  CodePointRange { first: 93019, last: 93025 },\n  CodePointRange { first: 93552, last: 93561 },\n  CodePointRange { first: 93824, last: 93846 },\n  CodePointRange { first: 118000, last: 118009 },\n  CodePointRange { first: 119488, last: 119507 },\n  CodePointRange { first: 119520, last: 119539 },\n  CodePointRange { first: 119648, last: 119672 },\n  CodePointRange { first: 120782, last: 120831 },\n  CodePointRange { first: 123200, last: 123209 },\n  CodePointRange { first: 123632, last: 123641 },\n  CodePointRange { first: 124144, last: 124153 },\n  CodePointRange { first: 124401, last: 124410 },\n  CodePointRange { first: 125127, last: 125135 },\n  CodePointRange { first: 125264, last: 125273 },\n  CodePointRange { first: 126065, last: 126123 },\n  CodePointRange { first: 126125, last: 126127 },\n  CodePointRange { first: 126129, last: 126132 },\n  CodePointRange { first: 126209, last: 126253 },\n  CodePointRange { first: 126255, last: 126269 },\n  CodePointRange { first: 127232, last: 127244 },\n  CodePointRange { first: 130032, last: 130041 },\n]\n\nexport let EMOJI_RANGES: Array<CodePointRange> = [\n  CodePointRange { first: 169, last: 169 },\n  CodePointRange { first: 174, last: 174 },\n  CodePointRange { first: 8252, last: 8252 },\n  CodePointRange { first: 8265, last: 8265 },\n  CodePointRange { first: 8482, last: 8482 },\n  CodePointRange { first: 8505, last: 8505 },\n  CodePointRange { first: 8596, last: 8601 },\n  CodePointRange { first: 8617, last: 8618 },\n  CodePointRange { first: 8986, last: 8987 },\n  CodePointRange { first: 9000, last: 9000 },\n  CodePointRange { first: 9167, last: 9167 },\n  CodePointRange { first: 9193, last: 9203 },\n  CodePointRange { first: 9208, last: 9210 },\n  CodePointRange { first: 9410, last: 9410 },\n  CodePointRange { first: 9642, last: 9643 },\n  CodePointRange { first: 9654, last: 9654 },\n  CodePointRange { first: 9664, last: 9664 },\n  CodePointRange { first: 9723, last: 9726 },\n  CodePointRange { first: 9728, last: 9732 },\n  CodePointRange { first: 9742, last: 9742 },\n  CodePointRange { first: 9745, last: 9745 },\n  CodePointRange { first: 9748, last: 9749 },\n  CodePointRange { first: 9752, last: 9752 },\n  CodePointRange { first: 9757, last: 9757 },\n  CodePointRange { first: 9760, last: 9760 },\n  CodePointRange { first: 9762, last: 9763 },\n  CodePointRange { first: 9766, last: 9766 },\n  CodePointRange { first: 9770, last: 9770 },\n  CodePointRange { first: 9774, last: 9775 },\n  CodePointRange { first: 9784, last: 9786 },\n  CodePointRange { first: 9792, last: 9792 },\n  CodePointRange { first: 9794, last: 9794 },\n  CodePointRange { first: 9800, last: 9811 },\n  CodePointRange { first: 9823, last: 9824 },\n  CodePointRange { first: 9827, last: 9827 },\n  CodePointRange { first: 9829, last: 9830 },\n  CodePointRange { first: 9832, last: 9832 },\n  CodePointRange { first: 9851, last: 9851 },\n  CodePointRange { first: 9854, last: 9855 },\n  CodePointRange { first: 9874, last: 9879 },\n  CodePointRange { first: 9881, last: 9881 },\n  CodePointRange { first: 9883, last: 9884 },\n  CodePointRange { first: 9888, last: 9889 },\n  CodePointRange { first: 9895, last: 9895 },\n  CodePointRange { first: 9898, last: 9899 },\n  CodePointRange { first: 9904, last: 9905 },\n  CodePointRange { first: 9917, last: 9918 },\n  CodePointRange { first: 9924, last: 9925 },\n  CodePointRange { first: 9928, last: 9928 },\n  CodePointRange { first: 9934, last: 9935 },\n  CodePointRange { first: 9937, last: 9937 },\n  CodePointRange { first: 9939, last: 9940 },\n  CodePointRange { first: 9961, last: 9962 },\n  CodePointRange { first: 9968, last: 9973 },\n  CodePointRange { first: 9975, last: 9978 },\n  CodePointRange { first: 9981, last: 9981 },\n  CodePointRange { first: 9986, last: 9986 },\n  CodePointRange { first: 9989, last: 9989 },\n  CodePointRange { first: 9992, last: 9997 },\n  CodePointRange { first: 9999, last: 9999 },\n  CodePointRange { first: 10002, last: 10002 },\n  CodePointRange { first: 10004, last: 10004 },\n  CodePointRange { first: 10006, last: 10006 },\n  CodePointRange { first: 10013, last: 10013 },\n  CodePointRange { first: 10017, last: 10017 },\n  CodePointRange { first: 10024, last: 10024 },\n  CodePointRange { first: 10035, last: 10036 },\n  CodePointRange { first: 10052, last: 10052 },\n  CodePointRange { first: 10055, last: 10055 },\n  CodePointRange { first: 10060, last: 10060 },\n  CodePointRange { first: 10062, last: 10062 },\n  CodePointRange { first: 10067, last: 10069 },\n  CodePointRange { first: 10071, last: 10071 },\n  CodePointRange { first: 10083, last: 10084 },\n  CodePointRange { first: 10133, last: 10135 },\n  CodePointRange { first: 10145, last: 10145 },\n  CodePointRange { first: 10160, last: 10160 },\n  CodePointRange { first: 10175, last: 10175 },\n  CodePointRange { first: 10548, last: 10549 },\n  CodePointRange { first: 11013, last: 11015 },\n  CodePointRange { first: 11035, last: 11036 },\n  CodePointRange { first: 11088, last: 11088 },\n  CodePointRange { first: 11093, last: 11093 },\n  CodePointRange { first: 12336, last: 12336 },\n  CodePointRange { first: 12349, last: 12349 },\n  CodePointRange { first: 12951, last: 12951 },\n  CodePointRange { first: 12953, last: 12953 },\n  CodePointRange { first: 126980, last: 126980 },\n  CodePointRange { first: 127183, last: 127183 },\n  CodePointRange { first: 127344, last: 127345 },\n  CodePointRange { first: 127358, last: 127359 },\n  CodePointRange { first: 127374, last: 127374 },\n  CodePointRange { first: 127377, last: 127386 },\n  CodePointRange { first: 127462, last: 127487 },\n  CodePointRange { first: 127489, last: 127490 },\n  CodePointRange { first: 127514, last: 127514 },\n  CodePointRange { first: 127535, last: 127535 },\n  CodePointRange { first: 127538, last: 127546 },\n  CodePointRange { first: 127568, last: 127569 },\n  CodePointRange { first: 127744, last: 127777 },\n  CodePointRange { first: 127780, last: 127891 },\n  CodePointRange { first: 127894, last: 127895 },\n  CodePointRange { first: 127897, last: 127899 },\n  CodePointRange { first: 127902, last: 127984 },\n  CodePointRange { first: 127987, last: 127989 },\n  CodePointRange { first: 127991, last: 128253 },\n  CodePointRange { first: 128255, last: 128317 },\n  CodePointRange { first: 128329, last: 128334 },\n  CodePointRange { first: 128336, last: 128359 },\n  CodePointRange { first: 128367, last: 128368 },\n  CodePointRange { first: 128371, last: 128378 },\n  CodePointRange { first: 128391, last: 128391 },\n  CodePointRange { first: 128394, last: 128397 },\n  CodePointRange { first: 128400, last: 128400 },\n  CodePointRange { first: 128405, last: 128406 },\n  CodePointRange { first: 128420, last: 128421 },\n  CodePointRange { first: 128424, last: 128424 },\n  CodePointRange { first: 128433, last: 128434 },\n  CodePointRange { first: 128444, last: 128444 },\n  CodePointRange { first: 128450, last: 128452 },\n  CodePointRange { first: 128465, last: 128467 },\n  CodePointRange { first: 128476, last: 128478 },\n  CodePointRange { first: 128481, last: 128481 },\n  CodePointRange { first: 128483, last: 128483 },\n  CodePointRange { first: 128488, last: 128488 },\n  CodePointRange { first: 128495, last: 128495 },\n  CodePointRange { first: 128499, last: 128499 },\n  CodePointRange { first: 128506, last: 128591 },\n  CodePointRange { first: 128640, last: 128709 },\n  CodePointRange { first: 128715, last: 128722 },\n  CodePointRange { first: 128725, last: 128727 },\n  CodePointRange { first: 128732, last: 128741 },\n  CodePointRange { first: 128745, last: 128745 },\n  CodePointRange { first: 128747, last: 128748 },\n  CodePointRange { first: 128752, last: 128752 },\n  CodePointRange { first: 128755, last: 128764 },\n  CodePointRange { first: 128992, last: 129003 },\n  CodePointRange { first: 129008, last: 129008 },\n  CodePointRange { first: 129292, last: 129338 },\n  CodePointRange { first: 129340, last: 129349 },\n  CodePointRange { first: 129351, last: 129535 },\n  CodePointRange { first: 129648, last: 129660 },\n  CodePointRange { first: 129664, last: 129673 },\n  CodePointRange { first: 129679, last: 129734 },\n  CodePointRange { first: 129742, last: 129756 },\n  CodePointRange { first: 129759, last: 129769 },\n  CodePointRange { first: 129776, last: 129784 },\n]\n\nexport let CASE_FOLD_KEYS: Array<int> = [\n  65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,\n  77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,\n  89, 90, 181, 192, 193, 194, 195, 196, 197, 198, 199, 200,\n  201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,\n  213, 214, 216, 217, 218, 219, 220, 221, 222, 223, 256, 258,\n  260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282,\n  284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306,\n  308, 310, 313, 315, 317, 319, 321, 323, 325, 327, 329, 330,\n  332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354,\n  356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 377,\n  379, 381, 383, 385, 386, 388, 390, 391, 393, 394, 395, 398,\n  399, 400, 401, 403, 404, 406, 407, 408, 412, 413, 415, 416,\n  418, 420, 422, 423, 425, 428, 430, 431, 433, 434, 435, 437,\n  439, 440, 444, 452, 453, 455, 456, 458, 459, 461, 463, 465,\n  467, 469, 471, 473, 475, 478, 480, 482, 484, 486, 488, 490,\n  492, 494, 496, 497, 498, 500, 502, 503, 504, 506, 508, 510,\n  512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534,\n  536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558,\n  560, 562, 570, 571, 573, 574, 577, 579, 580, 581, 582, 584,\n  586, 588, 590, 837, 880, 882, 886, 895, 902, 904, 905, 906,\n  908, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920,\n  921, 922, 923, 924, 925, 926, 927, 928, 929, 931, 932, 933,\n  934, 935, 936, 937, 938, 939, 944, 962, 975, 976, 977, 981,\n  982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004,\n  1006, 1008, 1009, 1012, 1013, 1015, 1017, 1018, 1021, 1022, 1023, 1024,\n  1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036,\n  1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048,\n  1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060,\n  1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1120,\n  1122, 1124, 1126, 1128, 1130, 1132, 1134, 1136, 1138, 1140, 1142, 1144,\n  1146, 1148, 1150, 1152, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176,\n  1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200,\n  1202, 1204, 1206, 1208, 1210, 1212, 1214, 1216, 1217, 1219, 1221, 1223,\n  1225, 1227, 1229, 1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, 1248,\n  1250, 1252, 1254, 1256, 1258, 1260, 1262, 1264, 1266, 1268, 1270, 1272,\n  1274, 1276, 1278, 1280, 1282, 1284, 1286, 1288, 1290, 1292, 1294, 1296,\n  1298, 1300, 1302, 1304, 1306, 1308, 1310, 1312, 1314, 1316, 1318, 1320,\n  1322, 1324, 1326, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,\n  1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349,\n  1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361,\n  1362, 1363, 1364, 1365, 1366, 1415, 4256, 4257, 4258, 4259, 4260, 4261,\n  4262, 4263, 4264, 4265, 4266, 4267, 4268, 4269, 4270, 4271, 4272, 4273,\n  4274, 4275, 4276, 4277, 4278, 4279, 4280, 4281, 4282, 4283, 4284, 4285,\n  4286, 4287, 4288, 4289, 4290, 4291, 4292, 4293, 4295, 4301, 5112, 5113,\n  5114, 5115, 5116, 5117, 7296, 7297, 7298, 7299, 7300, 7301, 7302, 7303,\n  7304, 7305, 7312, 7313, 7314, 7315, 7316, 7317, 7318, 7319, 7320, 7321,\n  7322, 7323, 7324, 7325, 7326, 7327, 7328, 7329, 7330, 7331, 7332, 7333,\n  7334, 7335, 7336, 7337, 7338, 7339, 7340, 7341, 7342, 7343, 7344, 7345,\n  7346, 7347, 7348, 7349, 7350, 7351, 7352, 7353, 7354, 7357, 7358, 7359,\n  7680, 7682, 7684, 7686, 7688, 7690, 7692, 7694, 7696, 7698, 7700, 7702,\n  7704, 7706, 7708, 7710, 7712, 7714, 7716, 7718, 7720, 7722, 7724, 7726,\n  7728, 7730, 7732, 7734, 7736, 7738, 7740, 7742, 7744, 7746, 7748, 7750,\n  7752, 7754, 7756, 7758, 7760, 7762, 7764, 7766, 7768, 7770, 7772, 7774,\n  7776, 7778, 7780, 7782, 7784, 7786, 7788, 7790, 7792, 7794, 7796, 7798,\n  7800, 7802, 7804, 7806, 7808, 7810, 7812, 7814, 7816, 7818, 7820, 7822,\n  7824, 7826, 7828, 7830, 7831, 7832, 7833, 7834, 7835, 7838, 7840, 7842,\n  7844, 7846, 7848, 7850, 7852, 7854, 7856, 7858, 7860, 7862, 7864, 7866,\n  7868, 7870, 7872, 7874, 7876, 7878, 7880, 7882, 7884, 7886, 7888, 7890,\n  7892, 7894, 7896, 7898, 7900, 7902, 7904, 7906, 7908, 7910, 7912, 7914,\n  7916, 7918, 7920, 7922, 7924, 7926, 7928, 7930, 7932, 7934, 7944, 7945,\n  7946, 7947, 7948, 7949, 7950, 7951, 7960, 7961, 7962, 7963, 7964, 7965,\n  7976, 7977, 7978, 7979, 7980, 7981, 7982, 7983, 7992, 7993, 7994, 7995,\n  7996, 7997, 7998, 7999, 8008, 8009, 8010, 8011, 8012, 8013, 8016, 8018,\n  8020, 8022, 8025, 8027, 8029, 8031, 8040, 8041, 8042, 8043, 8044, 8045,\n  8046, 8047, 8064, 8065, 8066, 8067, 8068, 8069, 8070, 8071, 8072, 8073,\n  8074, 8075, 8076, 8077, 8078, 8079, 8080, 8081, 8082, 8083, 8084, 8085,\n  8086, 8087, 8088, 8089, 8090, 8091, 8092, 8093, 8094, 8095, 8096, 8097,\n  8098, 8099, 8100, 8101, 8102, 8103, 8104, 8105, 8106, 8107, 8108, 8109,\n  8110, 8111, 8114, 8115, 8116, 8118, 8119, 8120, 8121, 8122, 8123, 8124,\n  8126, 8130, 8131, 8132, 8134, 8135, 8136, 8137, 8138, 8139, 8140, 8146,\n  8147, 8150, 8151, 8152, 8153, 8154, 8155, 8162, 8163, 8164, 8166, 8167,\n  8168, 8169, 8170, 8171, 8172, 8178, 8179, 8180, 8182, 8183, 8184, 8185,\n  8186, 8187, 8188, 8486, 8490, 8491, 8498, 8544, 8545, 8546, 8547, 8548,\n  8549, 8550, 8551, 8552, 8553, 8554, 8555, 8556, 8557, 8558, 8559, 8579,\n  9398, 9399, 9400, 9401, 9402, 9403, 9404, 9405, 9406, 9407, 9408, 9409,\n  9410, 9411, 9412, 9413, 9414, 9415, 9416, 9417, 9418, 9419, 9420, 9421,\n  9422, 9423, 11264, 11265, 11266, 11267, 11268, 11269, 11270, 11271, 11272, 11273,\n  11274, 11275, 11276, 11277, 11278, 11279, 11280, 11281, 11282, 11283, 11284, 11285,\n  11286, 11287, 11288, 11289, 11290, 11291, 11292, 11293, 11294, 11295, 11296, 11297,\n  11298, 11299, 11300, 11301, 11302, 11303, 11304, 11305, 11306, 11307, 11308, 11309,\n  11310, 11311, 11360, 11362, 11363, 11364, 11367, 11369, 11371, 11373, 11374, 11375,\n  11376, 11378, 11381, 11390, 11391, 11392, 11394, 11396, 11398, 11400, 11402, 11404,\n  11406, 11408, 11410, 11412, 11414, 11416, 11418, 11420, 11422, 11424, 11426, 11428,\n  11430, 11432, 11434, 11436, 11438, 11440, 11442, 11444, 11446, 11448, 11450, 11452,\n  11454, 11456, 11458, 11460, 11462, 11464, 11466, 11468, 11470, 11472, 11474, 11476,\n  11478, 11480, 11482, 11484, 11486, 11488, 11490, 11499, 11501, 11506, 42560, 42562,\n  42564, 42566, 42568, 42570, 42572, 42574, 42576, 42578, 42580, 42582, 42584, 42586,\n  42588, 42590, 42592, 42594, 42596, 42598, 42600, 42602, 42604, 42624, 42626, 42628,\n  42630, 42632, 42634, 42636, 42638, 42640, 42642, 42644, 42646, 42648, 42650, 42786,\n  42788, 42790, 42792, 42794, 42796, 42798, 42802, 42804, 42806, 42808, 42810, 42812,\n  42814, 42816, 42818, 42820, 42822, 42824, 42826, 42828, 42830, 42832, 42834, 42836,\n  42838, 42840, 42842, 42844, 42846, 42848, 42850, 42852, 42854, 42856, 42858, 42860,\n  42862, 42873, 42875, 42877, 42878, 42880, 42882, 42884, 42886, 42891, 42893, 42896,\n  42898, 42902, 42904, 42906, 42908, 42910, 42912, 42914, 42916, 42918, 42920, 42922,\n  42923, 42924, 42925, 42926, 42928, 42929, 42930, 42931, 42932, 42934, 42936, 42938,\n  42940, 42942, 42944, 42946, 42948, 42949, 42950, 42951, 42953, 42955, 42956, 42960,\n  42966, 42968, 42970, 42972, 42997, 43888, 43889, 43890, 43891, 43892, 43893, 43894,\n  43895, 43896, 43897, 43898, 43899, 43900, 43901, 43902, 43903, 43904, 43905, 43906,\n  43907, 43908, 43909, 43910, 43911, 43912, 43913, 43914, 43915, 43916, 43917, 43918,\n  43919, 43920, 43921, 43922, 43923, 43924, 43925, 43926, 43927, 43928, 43929, 43930,\n  43931, 43932, 43933, 43934, 43935, 43936, 43937, 43938, 43939, 43940, 43941, 43942,\n  43943, 43944, 43945, 43946, 43947, 43948, 43949, 43950, 43951, 43952, 43953, 43954,\n  43955, 43956, 43957, 43958, 43959, 43960, 43961, 43962, 43963, 43964, 43965, 43966,\n  43967, 64256, 64257, 64258, 64259, 64260, 64261, 64262, 64275, 64276, 64277, 64278,\n  64279, 65313, 65314, 65315, 65316, 65317, 65318, 65319, 65320, 65321, 65322, 65323,\n  65324, 65325, 65326, 65327, 65328, 65329, 65330, 65331, 65332, 65333, 65334, 65335,\n  65336, 65337, 65338, 66560, 66561, 66562, 66563, 66564, 66565, 66566, 66567, 66568,\n  66569, 66570, 66571, 66572, 66573, 66574, 66575, 66576, 66577, 66578, 66579, 66580,\n  66581, 66582, 66583, 66584, 66585, 66586, 66587, 66588, 66589, 66590, 66591, 66592,\n  66593, 66594, 66595, 66596, 66597, 66598, 66599, 66736, 66737, 66738, 66739, 66740,\n  66741, 66742, 66743, 66744, 66745, 66746, 66747, 66748, 66749, 66750, 66751, 66752,\n  66753, 66754, 66755, 66756, 66757, 66758, 66759, 66760, 66761, 66762, 66763, 66764,\n  66765, 66766, 66767, 66768, 66769, 66770, 66771, 66928, 66929, 66930, 66931, 66932,\n  66933, 66934, 66935, 66936, 66937, 66938, 66940, 66941, 66942, 66943, 66944, 66945,\n  66946, 66947, 66948, 66949, 66950, 66951, 66952, 66953, 66954, 66956, 66957, 66958,\n  66959, 66960, 66961, 66962, 66964, 66965, 68736, 68737, 68738, 68739, 68740, 68741,\n  68742, 68743, 68744, 68745, 68746, 68747, 68748, 68749, 68750, 68751, 68752, 68753,\n  68754, 68755, 68756, 68757, 68758, 68759, 68760, 68761, 68762, 68763, 68764, 68765,\n  68766, 68767, 68768, 68769, 68770, 68771, 68772, 68773, 68774, 68775, 68776, 68777,\n  68778, 68779, 68780, 68781, 68782, 68783, 68784, 68785, 68786, 68944, 68945, 68946,\n  68947, 68948, 68949, 68950, 68951, 68952, 68953, 68954, 68955, 68956, 68957, 68958,\n  68959, 68960, 68961, 68962, 68963, 68964, 68965, 71840, 71841, 71842, 71843, 71844,\n  71845, 71846, 71847, 71848, 71849, 71850, 71851, 71852, 71853, 71854, 71855, 71856,\n  71857, 71858, 71859, 71860, 71861, 71862, 71863, 71864, 71865, 71866, 71867, 71868,\n  71869, 71870, 71871, 93760, 93761, 93762, 93763, 93764, 93765, 93766, 93767, 93768,\n  93769, 93770, 93771, 93772, 93773, 93774, 93775, 93776, 93777, 93778, 93779, 93780,\n  93781, 93782, 93783, 93784, 93785, 93786, 93787, 93788, 93789, 93790, 93791, 125184,\n  125185, 125186, 125187, 125188, 125189, 125190, 125191, 125192, 125193, 125194, 125195, 125196,\n  125197, 125198, 125199, 125200, 125201, 125202, 125203, 125204, 125205, 125206, 125207, 125208,\n  125209, 125210, 125211, 125212, 125213, 125214, 125215, 125216, 125217,\n]\n\nexport let CASE_FOLD_OFFSETS: Array<int> = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,\n  12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,\n  24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n  36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60,\n  61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,\n  73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 85,\n  86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 98,\n  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,\n  111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,\n  123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,\n  135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,\n  147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,\n  159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,\n  171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,\n  183, 184, 185, 187, 188, 189, 190, 191, 192, 193, 194, 195,\n  196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,\n  208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,\n  220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,\n  232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,\n  244, 245, 246, 247, 250, 251, 252, 253, 254, 255, 256, 257,\n  258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269,\n  270, 271, 272, 273, 274, 275, 276, 279, 280, 281, 282, 283,\n  284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,\n  296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,\n  308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319,\n  320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331,\n  332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343,\n  344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355,\n  356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367,\n  368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379,\n  380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391,\n  392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403,\n  404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415,\n  416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427,\n  428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439,\n  440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451,\n  452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463,\n  464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475,\n  476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487,\n  488, 489, 490, 491, 492, 493, 495, 496, 497, 498, 499, 500,\n  501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,\n  513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524,\n  525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536,\n  537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548,\n  549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,\n  561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572,\n  573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584,\n  585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596,\n  597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,\n  609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620,\n  621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632,\n  633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644,\n  645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,\n  657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668,\n  669, 670, 671, 672, 674, 676, 678, 680, 682, 683, 685, 686,\n  687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698,\n  699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710,\n  711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722,\n  723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734,\n  735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746,\n  747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758,\n  759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 771,\n  774, 777, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789,\n  790, 791, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810,\n  812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834,\n  836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858,\n  860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882,\n  884, 886, 888, 890, 892, 894, 896, 899, 900, 901, 902, 903,\n  905, 906, 908, 910, 912, 914, 917, 918, 919, 920, 921, 923,\n  926, 929, 931, 934, 935, 936, 937, 938, 941, 944, 946, 948,\n  951, 952, 953, 954, 955, 956, 958, 960, 962, 964, 967, 968,\n  969, 970, 971, 973, 974, 975, 976, 977, 978, 979, 980, 981,\n  982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993,\n  994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005,\n  1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,\n  1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029,\n  1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041,\n  1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053,\n  1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,\n  1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077,\n  1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089,\n  1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101,\n  1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,\n  1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125,\n  1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137,\n  1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149,\n  1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,\n  1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173,\n  1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185,\n  1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197,\n  1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,\n  1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221,\n  1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233,\n  1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245,\n  1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,\n  1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269,\n  1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,\n  1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293,\n  1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,\n  1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317,\n  1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329,\n  1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341,\n  1342, 1343, 1345, 1347, 1349, 1352, 1355, 1357, 1359, 1361, 1363, 1365,\n  1367, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379,\n  1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391,\n  1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403,\n  1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415,\n  1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427,\n  1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439,\n  1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451,\n  1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463,\n  1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475,\n  1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487,\n  1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499,\n  1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511,\n  1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523,\n  1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535,\n  1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547,\n  1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559,\n  1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571,\n  1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583,\n  1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595,\n  1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607,\n  1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619,\n  1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631,\n  1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643,\n  1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655,\n  1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667,\n  1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677,\n]\n\nexport let CASE_FOLD_VALUES: Array<int> = [\n  97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,\n  109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,\n  121, 122, 956, 224, 225, 226, 227, 228, 229, 230, 231, 232,\n  233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244,\n  245, 246, 248, 249, 250, 251, 252, 253, 254, 115, 115, 257,\n  259, 261, 263, 265, 267, 269, 271, 273, 275, 277, 279, 281,\n  283, 285, 287, 289, 291, 293, 295, 297, 299, 301, 303, 105,\n  775, 307, 309, 311, 314, 316, 318, 320, 322, 324, 326, 328,\n  700, 110, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349,\n  351, 353, 355, 357, 359, 361, 363, 365, 367, 369, 371, 373,\n  375, 255, 378, 380, 382, 115, 595, 387, 389, 596, 392, 598,\n  599, 396, 477, 601, 603, 402, 608, 611, 617, 616, 409, 623,\n  626, 629, 417, 419, 421, 640, 424, 643, 429, 648, 432, 650,\n  651, 436, 438, 658, 441, 445, 454, 454, 457, 457, 460, 460,\n  462, 464, 466, 468, 470, 472, 474, 476, 479, 481, 483, 485,\n  487, 489, 491, 493, 495, 106, 780, 499, 499, 501, 405, 447,\n  505, 507, 509, 511, 513, 515, 517, 519, 521, 523, 525, 527,\n  529, 531, 533, 535, 537, 539, 541, 543, 414, 547, 549, 551,\n  553, 555, 557, 559, 561, 563, 11365, 572, 410, 11366, 578, 384,\n  649, 652, 583, 585, 587, 589, 591, 953, 881, 883, 887, 1011,\n  940, 941, 942, 943, 972, 973, 974, 953, 776, 769, 945, 946,\n  947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958,\n  959, 960, 961, 963, 964, 965, 966, 967, 968, 969, 970, 971,\n  965, 776, 769, 963, 983, 946, 952, 966, 960, 985, 987, 989,\n  991, 993, 995, 997, 999, 1001, 1003, 1005, 1007, 954, 961, 952,\n  949, 1016, 1010, 1019, 891, 892, 893, 1104, 1105, 1106, 1107, 1108,\n  1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1072,\n  1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084,\n  1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096,\n  1097, 1098, 1099, 1100, 1101, 1102, 1103, 1121, 1123, 1125, 1127, 1129,\n  1131, 1133, 1135, 1137, 1139, 1141, 1143, 1145, 1147, 1149, 1151, 1153,\n  1163, 1165, 1167, 1169, 1171, 1173, 1175, 1177, 1179, 1181, 1183, 1185,\n  1187, 1189, 1191, 1193, 1195, 1197, 1199, 1201, 1203, 1205, 1207, 1209,\n  1211, 1213, 1215, 1231, 1218, 1220, 1222, 1224, 1226, 1228, 1230, 1233,\n  1235, 1237, 1239, 1241, 1243, 1245, 1247, 1249, 1251, 1253, 1255, 1257,\n  1259, 1261, 1263, 1265, 1267, 1269, 1271, 1273, 1275, 1277, 1279, 1281,\n  1283, 1285, 1287, 1289, 1291, 1293, 1295, 1297, 1299, 1301, 1303, 1305,\n  1307, 1309, 1311, 1313, 1315, 1317, 1319, 1321, 1323, 1325, 1327, 1377,\n  1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389,\n  1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401,\n  1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413,\n  1414, 1381, 1410, 11520, 11521, 11522, 11523, 11524, 11525, 11526, 11527, 11528,\n  11529, 11530, 11531, 11532, 11533, 11534, 11535, 11536, 11537, 11538, 11539, 11540,\n  11541, 11542, 11543, 11544, 11545, 11546, 11547, 11548, 11549, 11550, 11551, 11552,\n  11553, 11554, 11555, 11556, 11557, 11559, 11565, 5104, 5105, 5106, 5107, 5108,\n  5109, 1074, 1076, 1086, 1089, 1090, 1090, 1098, 1123, 42571, 7306, 4304,\n  4305, 4306, 4307, 4308, 4309, 4310, 4311, 4312, 4313, 4314, 4315, 4316,\n  4317, 4318, 4319, 4320, 4321, 4322, 4323, 4324, 4325, 4326, 4327, 4328,\n  4329, 4330, 4331, 4332, 4333, 4334, 4335, 4336, 4337, 4338, 4339, 4340,\n  4341, 4342, 4343, 4344, 4345, 4346, 4349, 4350, 4351, 7681, 7683, 7685,\n  7687, 7689, 7691, 7693, 7695, 7697, 7699, 7701, 7703, 7705, 7707, 7709,\n  7711, 7713, 7715, 7717, 7719, 7721, 7723, 7725, 7727, 7729, 7731, 7733,\n  7735, 7737, 7739, 7741, 7743, 7745, 7747, 7749, 7751, 7753, 7755, 7757,\n  7759, 7761, 7763, 7765, 7767, 7769, 7771, 7773, 7775, 7777, 7779, 7781,\n  7783, 7785, 7787, 7789, 7791, 7793, 7795, 7797, 7799, 7801, 7803, 7805,\n  7807, 7809, 7811, 7813, 7815, 7817, 7819, 7821, 7823, 7825, 7827, 7829,\n  104, 817, 116, 776, 119, 778, 121, 778, 97, 702, 7777, 115,\n  115, 7841, 7843, 7845, 7847, 7849, 7851, 7853, 7855, 7857, 7859, 7861,\n  7863, 7865, 7867, 7869, 7871, 7873, 7875, 7877, 7879, 7881, 7883, 7885,\n  7887, 7889, 7891, 7893, 7895, 7897, 7899, 7901, 7903, 7905, 7907, 7909,\n  7911, 7913, 7915, 7917, 7919, 7921, 7923, 7925, 7927, 7929, 7931, 7933,\n  7935, 7936, 7937, 7938, 7939, 7940, 7941, 7942, 7943, 7952, 7953, 7954,\n  7955, 7956, 7957, 7968, 7969, 7970, 7971, 7972, 7973, 7974, 7975, 7984,\n  7985, 7986, 7987, 7988, 7989, 7990, 7991, 8000, 8001, 8002, 8003, 8004,\n  8005, 965, 787, 965, 787, 768, 965, 787, 769, 965, 787, 834,\n  8017, 8019, 8021, 8023, 8032, 8033, 8034, 8035, 8036, 8037, 8038, 8039,\n  7936, 953, 7937, 953, 7938, 953, 7939, 953, 7940, 953, 7941, 953,\n  7942, 953, 7943, 953, 7936, 953, 7937, 953, 7938, 953, 7939, 953,\n  7940, 953, 7941, 953, 7942, 953, 7943, 953, 7968, 953, 7969, 953,\n  7970, 953, 7971, 953, 7972, 953, 7973, 953, 7974, 953, 7975, 953,\n  7968, 953, 7969, 953, 7970, 953, 7971, 953, 7972, 953, 7973, 953,\n  7974, 953, 7975, 953, 8032, 953, 8033, 953, 8034, 953, 8035, 953,\n  8036, 953, 8037, 953, 8038, 953, 8039, 953, 8032, 953, 8033, 953,\n  8034, 953, 8035, 953, 8036, 953, 8037, 953, 8038, 953, 8039, 953,\n  8048, 953, 945, 953, 940, 953, 945, 834, 945, 834, 953, 8112,\n  8113, 8048, 8049, 945, 953, 953, 8052, 953, 951, 953, 942, 953,\n  951, 834, 951, 834, 953, 8050, 8051, 8052, 8053, 951, 953, 953,\n  776, 768, 953, 776, 769, 953, 834, 953, 776, 834, 8144, 8145,\n  8054, 8055, 965, 776, 768, 965, 776, 769, 961, 787, 965, 834,\n  965, 776, 834, 8160, 8161, 8058, 8059, 8165, 8060, 953, 969, 953,\n  974, 953, 969, 834, 969, 834, 953, 8056, 8057, 8060, 8061, 969,\n  953, 969, 107, 229, 8526, 8560, 8561, 8562, 8563, 8564, 8565, 8566,\n  8567, 8568, 8569, 8570, 8571, 8572, 8573, 8574, 8575, 8580, 9424, 9425,\n  9426, 9427, 9428, 9429, 9430, 9431, 9432, 9433, 9434, 9435, 9436, 9437,\n  9438, 9439, 9440, 9441, 9442, 9443, 9444, 9445, 9446, 9447, 9448, 9449,\n  11312, 11313, 11314, 11315, 11316, 11317, 11318, 11319, 11320, 11321, 11322, 11323,\n  11324, 11325, 11326, 11327, 11328, 11329, 11330, 11331, 11332, 11333, 11334, 11335,\n  11336, 11337, 11338, 11339, 11340, 11341, 11342, 11343, 11344, 11345, 11346, 11347,\n  11348, 11349, 11350, 11351, 11352, 11353, 11354, 11355, 11356, 11357, 11358, 11359,\n  11361, 619, 7549, 637, 11368, 11370, 11372, 593, 625, 592, 594, 11379,\n  11382, 575, 576, 11393, 11395, 11397, 11399, 11401, 11403, 11405, 11407, 11409,\n  11411, 11413, 11415, 11417, 11419, 11421, 11423, 11425, 11427, 11429, 11431, 11433,\n  11435, 11437, 11439, 11441, 11443, 11445, 11447, 11449, 11451, 11453, 11455, 11457,\n  11459, 11461, 11463, 11465, 11467, 11469, 11471, 11473, 11475, 11477, 11479, 11481,\n  11483, 11485, 11487, 11489, 11491, 11500, 11502, 11507, 42561, 42563, 42565, 42567,\n  42569, 42571, 42573, 42575, 42577, 42579, 42581, 42583, 42585, 42587, 42589, 42591,\n  42593, 42595, 42597, 42599, 42601, 42603, 42605, 42625, 42627, 42629, 42631, 42633,\n  42635, 42637, 42639, 42641, 42643, 42645, 42647, 42649, 42651, 42787, 42789, 42791,\n  42793, 42795, 42797, 42799, 42803, 42805, 42807, 42809, 42811, 42813, 42815, 42817,\n  42819, 42821, 42823, 42825, 42827, 42829, 42831, 42833, 42835, 42837, 42839, 42841,\n  42843, 42845, 42847, 42849, 42851, 42853, 42855, 42857, 42859, 42861, 42863, 42874,\n  42876, 7545, 42879, 42881, 42883, 42885, 42887, 42892, 613, 42897, 42899, 42903,\n  42905, 42907, 42909, 42911, 42913, 42915, 42917, 42919, 42921, 614, 604, 609,\n  620, 618, 670, 647, 669, 43859, 42933, 42935, 42937, 42939, 42941, 42943,\n  42945, 42947, 42900, 642, 7566, 42952, 42954, 612, 42957, 42961, 42967, 42969,\n  42971, 411, 42998, 5024, 5025, 5026, 5027, 5028, 5029, 5030, 5031, 5032,\n  5033, 5034, 5035, 5036, 5037, 5038, 5039, 5040, 5041, 5042, 5043, 5044,\n  5045, 5046, 5047, 5048, 5049, 5050, 5051, 5052, 5053, 5054, 5055, 5056,\n  5057, 5058, 5059, 5060, 5061, 5062, 5063, 5064, 5065, 5066, 5067, 5068,\n  5069, 5070, 5071, 5072, 5073, 5074, 5075, 5076, 5077, 5078, 5079, 5080,\n  5081, 5082, 5083, 5084, 5085, 5086, 5087, 5088, 5089, 5090, 5091, 5092,\n  5093, 5094, 5095, 5096, 5097, 5098, 5099, 5100, 5101, 5102, 5103, 102,\n  102, 102, 105, 102, 108, 102, 102, 105, 102, 102, 108, 115,\n  116, 115, 116, 1396, 1398, 1396, 1381, 1396, 1387, 1406, 1398, 1396,\n  1389, 65345, 65346, 65347, 65348, 65349, 65350, 65351, 65352, 65353, 65354, 65355,\n  65356, 65357, 65358, 65359, 65360, 65361, 65362, 65363, 65364, 65365, 65366, 65367,\n  65368, 65369, 65370, 66600, 66601, 66602, 66603, 66604, 66605, 66606, 66607, 66608,\n  66609, 66610, 66611, 66612, 66613, 66614, 66615, 66616, 66617, 66618, 66619, 66620,\n  66621, 66622, 66623, 66624, 66625, 66626, 66627, 66628, 66629, 66630, 66631, 66632,\n  66633, 66634, 66635, 66636, 66637, 66638, 66639, 66776, 66777, 66778, 66779, 66780,\n  66781, 66782, 66783, 66784, 66785, 66786, 66787, 66788, 66789, 66790, 66791, 66792,\n  66793, 66794, 66795, 66796, 66797, 66798, 66799, 66800, 66801, 66802, 66803, 66804,\n  66805, 66806, 66807, 66808, 66809, 66810, 66811, 66967, 66968, 66969, 66970, 66971,\n  66972, 66973, 66974, 66975, 66976, 66977, 66979, 66980, 66981, 66982, 66983, 66984,\n  66985, 66986, 66987, 66988, 66989, 66990, 66991, 66992, 66993, 66995, 66996, 66997,\n  66998, 66999, 67000, 67001, 67003, 67004, 68800, 68801, 68802, 68803, 68804, 68805,\n  68806, 68807, 68808, 68809, 68810, 68811, 68812, 68813, 68814, 68815, 68816, 68817,\n  68818, 68819, 68820, 68821, 68822, 68823, 68824, 68825, 68826, 68827, 68828, 68829,\n  68830, 68831, 68832, 68833, 68834, 68835, 68836, 68837, 68838, 68839, 68840, 68841,\n  68842, 68843, 68844, 68845, 68846, 68847, 68848, 68849, 68850, 68976, 68977, 68978,\n  68979, 68980, 68981, 68982, 68983, 68984, 68985, 68986, 68987, 68988, 68989, 68990,\n  68991, 68992, 68993, 68994, 68995, 68996, 68997, 71872, 71873, 71874, 71875, 71876,\n  71877, 71878, 71879, 71880, 71881, 71882, 71883, 71884, 71885, 71886, 71887, 71888,\n  71889, 71890, 71891, 71892, 71893, 71894, 71895, 71896, 71897, 71898, 71899, 71900,\n  71901, 71902, 71903, 93792, 93793, 93794, 93795, 93796, 93797, 93798, 93799, 93800,\n  93801, 93802, 93803, 93804, 93805, 93806, 93807, 93808, 93809, 93810, 93811, 93812,\n  93813, 93814, 93815, 93816, 93817, 93818, 93819, 93820, 93821, 93822, 93823, 125218,\n  125219, 125220, 125221, 125222, 125223, 125224, 125225, 125226, 125227, 125228, 125229, 125230,\n  125231, 125232, 125233, 125234, 125235, 125236, 125237, 125238, 125239, 125240, 125241, 125242,\n  125243, 125244, 125245, 125246, 125247, 125248, 125249, 125250, 125251,\n]\n\nexport let CANONICAL_DECOMPOSITION_KEYS: Array<int> = [\n  192, 193, 194, 195, 196, 197, 199, 200, 201, 202, 203, 204,\n  205, 206, 207, 209, 210, 211, 212, 213, 214, 217, 218, 219,\n  220, 221, 224, 225, 226, 227, 228, 229, 231, 232, 233, 234,\n  235, 236, 237, 238, 239, 241, 242, 243, 244, 245, 246, 249,\n  250, 251, 252, 253, 255, 256, 257, 258, 259, 260, 261, 262,\n  263, 264, 265, 266, 267, 268, 269, 270, 271, 274, 275, 276,\n  277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,\n  289, 290, 291, 292, 293, 296, 297, 298, 299, 300, 301, 302,\n  303, 304, 308, 309, 310, 311, 313, 314, 315, 316, 317, 318,\n  323, 324, 325, 326, 327, 328, 332, 333, 334, 335, 336, 337,\n  340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351,\n  352, 353, 354, 355, 356, 357, 360, 361, 362, 363, 364, 365,\n  366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377,\n  378, 379, 380, 381, 382, 416, 417, 431, 432, 461, 462, 463,\n  464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475,\n  476, 478, 479, 480, 481, 482, 483, 486, 487, 488, 489, 490,\n  491, 492, 493, 494, 495, 496, 500, 501, 504, 505, 506, 507,\n  508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519,\n  520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531,\n  532, 533, 534, 535, 536, 537, 538, 539, 542, 543, 550, 551,\n  552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563,\n  832, 833, 835, 836, 884, 894, 901, 902, 903, 904, 905, 906,\n  908, 910, 911, 912, 938, 939, 940, 941, 942, 943, 944, 970,\n  971, 972, 973, 974, 979, 980, 1024, 1025, 1027, 1031, 1036, 1037,\n  1038, 1049, 1081, 1104, 1105, 1107, 1111, 1116, 1117, 1118, 1142, 1143,\n  1217, 1218, 1232, 1233, 1234, 1235, 1238, 1239, 1242, 1243, 1244, 1245,\n  1246, 1247, 1250, 1251, 1252, 1253, 1254, 1255, 1258, 1259, 1260, 1261,\n  1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1272, 1273, 1570, 1571,\n  1572, 1573, 1574, 1728, 1730, 1747, 2345, 2353, 2356, 2392, 2393, 2394,\n  2395, 2396, 2397, 2398, 2399, 2507, 2508, 2524, 2525, 2527, 2611, 2614,\n  2649, 2650, 2651, 2654, 2888, 2891, 2892, 2908, 2909, 2964, 3018, 3019,\n  3020, 3144, 3264, 3271, 3272, 3274, 3275, 3402, 3403, 3404, 3546, 3548,\n  3549, 3550, 3907, 3917, 3922, 3927, 3932, 3945, 3955, 3957, 3958, 3960,\n  3969, 3987, 3997, 4002, 4007, 4012, 4025, 4134, 6918, 6920, 6922, 6924,\n  6926, 6930, 6971, 6973, 6976, 6977, 6979, 7680, 7681, 7682, 7683, 7684,\n  7685, 7686, 7687, 7688, 7689, 7690, 7691, 7692, 7693, 7694, 7695, 7696,\n  7697, 7698, 7699, 7700, 7701, 7702, 7703, 7704, 7705, 7706, 7707, 7708,\n  7709, 7710, 7711, 7712, 7713, 7714, 7715, 7716, 7717, 7718, 7719, 7720,\n  7721, 7722, 7723, 7724, 7725, 7726, 7727, 7728, 7729, 7730, 7731, 7732,\n  7733, 7734, 7735, 7736, 7737, 7738, 7739, 7740, 7741, 7742, 7743, 7744,\n  7745, 7746, 7747, 7748, 7749, 7750, 7751, 7752, 7753, 7754, 7755, 7756,\n  7757, 7758, 7759, 7760, 7761, 7762, 7763, 7764, 7765, 7766, 7767, 7768,\n  7769, 7770, 7771, 7772, 7773, 7774, 7775, 7776, 7777, 7778, 7779, 7780,\n  7781, 7782, 7783, 7784, 7785, 7786, 7787, 7788, 7789, 7790, 7791, 7792,\n  7793, 7794, 7795, 7796, 7797, 7798, 7799, 7800, 7801, 7802, 7803, 7804,\n  7805, 7806, 7807, 7808, 7809, 7810, 7811, 7812, 7813, 7814, 7815, 7816,\n  7817, 7818, 7819, 7820, 7821, 7822, 7823, 7824, 7825, 7826, 7827, 7828,\n  7829, 7830, 7831, 7832, 7833, 7835, 7840, 7841, 7842, 7843, 7844, 7845,\n  7846, 7847, 7848, 7849, 7850, 7851, 7852, 7853, 7854, 7855, 7856, 7857,\n  7858, 7859, 7860, 7861, 7862, 7863, 7864, 7865, 7866, 7867, 7868, 7869,\n  7870, 7871, 7872, 7873, 7874, 7875, 7876, 7877, 7878, 7879, 7880, 7881,\n  7882, 7883, 7884, 7885, 7886, 7887, 7888, 7889, 7890, 7891, 7892, 7893,\n  7894, 7895, 7896, 7897, 7898, 7899, 7900, 7901, 7902, 7903, 7904, 7905,\n  7906, 7907, 7908, 7909, 7910, 7911, 7912, 7913, 7914, 7915, 7916, 7917,\n  7918, 7919, 7920, 7921, 7922, 7923, 7924, 7925, 7926, 7927, 7928, 7929,\n  7936, 7937, 7938, 7939, 7940, 7941, 7942, 7943, 7944, 7945, 7946, 7947,\n  7948, 7949, 7950, 7951, 7952, 7953, 7954, 7955, 7956, 7957, 7960, 7961,\n  7962, 7963, 7964, 7965, 7968, 7969, 7970, 7971, 7972, 7973, 7974, 7975,\n  7976, 7977, 7978, 7979, 7980, 7981, 7982, 7983, 7984, 7985, 7986, 7987,\n  7988, 7989, 7990, 7991, 7992, 7993, 7994, 7995, 7996, 7997, 7998, 7999,\n  8000, 8001, 8002, 8003, 8004, 8005, 8008, 8009, 8010, 8011, 8012, 8013,\n  8016, 8017, 8018, 8019, 8020, 8021, 8022, 8023, 8025, 8027, 8029, 8031,\n  8032, 8033, 8034, 8035, 8036, 8037, 8038, 8039, 8040, 8041, 8042, 8043,\n  8044, 8045, 8046, 8047, 8048, 8049, 8050, 8051, 8052, 8053, 8054, 8055,\n  8056, 8057, 8058, 8059, 8060, 8061, 8064, 8065, 8066, 8067, 8068, 8069,\n  8070, 8071, 8072, 8073, 8074, 8075, 8076, 8077, 8078, 8079, 8080, 8081,\n  8082, 8083, 8084, 8085, 8086, 8087, 8088, 8089, 8090, 8091, 8092, 8093,\n  8094, 8095, 8096, 8097, 8098, 8099, 8100, 8101, 8102, 8103, 8104, 8105,\n  8106, 8107, 8108, 8109, 8110, 8111, 8112, 8113, 8114, 8115, 8116, 8118,\n  8119, 8120, 8121, 8122, 8123, 8124, 8126, 8129, 8130, 8131, 8132, 8134,\n  8135, 8136, 8137, 8138, 8139, 8140, 8141, 8142, 8143, 8144, 8145, 8146,\n  8147, 8150, 8151, 8152, 8153, 8154, 8155, 8157, 8158, 8159, 8160, 8161,\n  8162, 8163, 8164, 8165, 8166, 8167, 8168, 8169, 8170, 8171, 8172, 8173,\n  8174, 8175, 8178, 8179, 8180, 8182, 8183, 8184, 8185, 8186, 8187, 8188,\n  8189, 8192, 8193, 8486, 8490, 8491, 8602, 8603, 8622, 8653, 8654, 8655,\n  8708, 8713, 8716, 8740, 8742, 8769, 8772, 8775, 8777, 8800, 8802, 8813,\n  8814, 8815, 8816, 8817, 8820, 8821, 8824, 8825, 8832, 8833, 8836, 8837,\n  8840, 8841, 8876, 8877, 8878, 8879, 8928, 8929, 8930, 8931, 8938, 8939,\n  8940, 8941, 9001, 9002, 10972, 12364, 12366, 12368, 12370, 12372, 12374, 12376,\n  12378, 12380, 12382, 12384, 12386, 12389, 12391, 12393, 12400, 12401, 12403, 12404,\n  12406, 12407, 12409, 12410, 12412, 12413, 12436, 12446, 12460, 12462, 12464, 12466,\n  12468, 12470, 12472, 12474, 12476, 12478, 12480, 12482, 12485, 12487, 12489, 12496,\n  12497, 12499, 12500, 12502, 12503, 12505, 12506, 12508, 12509, 12532, 12535, 12536,\n  12537, 12538, 12542, 63744, 63745, 63746, 63747, 63748, 63749, 63750, 63751, 63752,\n  63753, 63754, 63755, 63756, 63757, 63758, 63759, 63760, 63761, 63762, 63763, 63764,\n  63765, 63766, 63767, 63768, 63769, 63770, 63771, 63772, 63773, 63774, 63775, 63776,\n  63777, 63778, 63779, 63780, 63781, 63782, 63783, 63784, 63785, 63786, 63787, 63788,\n  63789, 63790, 63791, 63792, 63793, 63794, 63795, 63796, 63797, 63798, 63799, 63800,\n  63801, 63802, 63803, 63804, 63805, 63806, 63807, 63808, 63809, 63810, 63811, 63812,\n  63813, 63814, 63815, 63816, 63817, 63818, 63819, 63820, 63821, 63822, 63823, 63824,\n  63825, 63826, 63827, 63828, 63829, 63830, 63831, 63832, 63833, 63834, 63835, 63836,\n  63837, 63838, 63839, 63840, 63841, 63842, 63843, 63844, 63845, 63846, 63847, 63848,\n  63849, 63850, 63851, 63852, 63853, 63854, 63855, 63856, 63857, 63858, 63859, 63860,\n  63861, 63862, 63863, 63864, 63865, 63866, 63867, 63868, 63869, 63870, 63871, 63872,\n  63873, 63874, 63875, 63876, 63877, 63878, 63879, 63880, 63881, 63882, 63883, 63884,\n  63885, 63886, 63887, 63888, 63889, 63890, 63891, 63892, 63893, 63894, 63895, 63896,\n  63897, 63898, 63899, 63900, 63901, 63902, 63903, 63904, 63905, 63906, 63907, 63908,\n  63909, 63910, 63911, 63912, 63913, 63914, 63915, 63916, 63917, 63918, 63919, 63920,\n  63921, 63922, 63923, 63924, 63925, 63926, 63927, 63928, 63929, 63930, 63931, 63932,\n  63933, 63934, 63935, 63936, 63937, 63938, 63939, 63940, 63941, 63942, 63943, 63944,\n  63945, 63946, 63947, 63948, 63949, 63950, 63951, 63952, 63953, 63954, 63955, 63956,\n  63957, 63958, 63959, 63960, 63961, 63962, 63963, 63964, 63965, 63966, 63967, 63968,\n  63969, 63970, 63971, 63972, 63973, 63974, 63975, 63976, 63977, 63978, 63979, 63980,\n  63981, 63982, 63983, 63984, 63985, 63986, 63987, 63988, 63989, 63990, 63991, 63992,\n  63993, 63994, 63995, 63996, 63997, 63998, 63999, 64000, 64001, 64002, 64003, 64004,\n  64005, 64006, 64007, 64008, 64009, 64010, 64011, 64012, 64013, 64016, 64018, 64021,\n  64022, 64023, 64024, 64025, 64026, 64027, 64028, 64029, 64030, 64032, 64034, 64037,\n  64038, 64042, 64043, 64044, 64045, 64046, 64047, 64048, 64049, 64050, 64051, 64052,\n  64053, 64054, 64055, 64056, 64057, 64058, 64059, 64060, 64061, 64062, 64063, 64064,\n  64065, 64066, 64067, 64068, 64069, 64070, 64071, 64072, 64073, 64074, 64075, 64076,\n  64077, 64078, 64079, 64080, 64081, 64082, 64083, 64084, 64085, 64086, 64087, 64088,\n  64089, 64090, 64091, 64092, 64093, 64094, 64095, 64096, 64097, 64098, 64099, 64100,\n  64101, 64102, 64103, 64104, 64105, 64106, 64107, 64108, 64109, 64112, 64113, 64114,\n  64115, 64116, 64117, 64118, 64119, 64120, 64121, 64122, 64123, 64124, 64125, 64126,\n  64127, 64128, 64129, 64130, 64131, 64132, 64133, 64134, 64135, 64136, 64137, 64138,\n  64139, 64140, 64141, 64142, 64143, 64144, 64145, 64146, 64147, 64148, 64149, 64150,\n  64151, 64152, 64153, 64154, 64155, 64156, 64157, 64158, 64159, 64160, 64161, 64162,\n  64163, 64164, 64165, 64166, 64167, 64168, 64169, 64170, 64171, 64172, 64173, 64174,\n  64175, 64176, 64177, 64178, 64179, 64180, 64181, 64182, 64183, 64184, 64185, 64186,\n  64187, 64188, 64189, 64190, 64191, 64192, 64193, 64194, 64195, 64196, 64197, 64198,\n  64199, 64200, 64201, 64202, 64203, 64204, 64205, 64206, 64207, 64208, 64209, 64210,\n  64211, 64212, 64213, 64214, 64215, 64216, 64217, 64285, 64287, 64298, 64299, 64300,\n  64301, 64302, 64303, 64304, 64305, 64306, 64307, 64308, 64309, 64310, 64312, 64313,\n  64314, 64315, 64316, 64318, 64320, 64321, 64323, 64324, 64326, 64327, 64328, 64329,\n  64330, 64331, 64332, 64333, 64334, 67017, 67044, 69786, 69788, 69803, 69934, 69935,\n  70475, 70476, 70531, 70533, 70542, 70545, 70597, 70599, 70600, 70843, 70844, 70846,\n  71098, 71099, 71992, 90401, 90402, 90403, 90404, 90405, 90406, 90407, 90408, 93544,\n  93545, 93546, 119134, 119135, 119136, 119137, 119138, 119139, 119140, 119227, 119228, 119229,\n  119230, 119231, 119232, 194560, 194561, 194562, 194563, 194564, 194565, 194566, 194567, 194568,\n  194569, 194570, 194571, 194572, 194573, 194574, 194575, 194576, 194577, 194578, 194579, 194580,\n  194581, 194582, 194583, 194584, 194585, 194586, 194587, 194588, 194589, 194590, 194591, 194592,\n  194593, 194594, 194595, 194596, 194597, 194598, 194599, 194600, 194601, 194602, 194603, 194604,\n  194605, 194606, 194607, 194608, 194609, 194610, 194611, 194612, 194613, 194614, 194615, 194616,\n  194617, 194618, 194619, 194620, 194621, 194622, 194623, 194624, 194625, 194626, 194627, 194628,\n  194629, 194630, 194631, 194632, 194633, 194634, 194635, 194636, 194637, 194638, 194639, 194640,\n  194641, 194642, 194643, 194644, 194645, 194646, 194647, 194648, 194649, 194650, 194651, 194652,\n  194653, 194654, 194655, 194656, 194657, 194658, 194659, 194660, 194661, 194662, 194663, 194664,\n  194665, 194666, 194667, 194668, 194669, 194670, 194671, 194672, 194673, 194674, 194675, 194676,\n  194677, 194678, 194679, 194680, 194681, 194682, 194683, 194684, 194685, 194686, 194687, 194688,\n  194689, 194690, 194691, 194692, 194693, 194694, 194695, 194696, 194697, 194698, 194699, 194700,\n  194701, 194702, 194703, 194704, 194705, 194706, 194707, 194708, 194709, 194710, 194711, 194712,\n  194713, 194714, 194715, 194716, 194717, 194718, 194719, 194720, 194721, 194722, 194723, 194724,\n  194725, 194726, 194727, 194728, 194729, 194730, 194731, 194732, 194733, 194734, 194735, 194736,\n  194737, 194738, 194739, 194740, 194741, 194742, 194743, 194744, 194745, 194746, 194747, 194748,\n  194749, 194750, 194751, 194752, 194753, 194754, 194755, 194756, 194757, 194758, 194759, 194760,\n  194761, 194762, 194763, 194764, 194765, 194766, 194767, 194768, 194769, 194770, 194771, 194772,\n  194773, 194774, 194775, 194776, 194777, 194778, 194779, 194780, 194781, 194782, 194783, 194784,\n  194785, 194786, 194787, 194788, 194789, 194790, 194791, 194792, 194793, 194794, 194795, 194796,\n  194797, 194798, 194799, 194800, 194801, 194802, 194803, 194804, 194805, 194806, 194807, 194808,\n  194809, 194810, 194811, 194812, 194813, 194814, 194815, 194816, 194817, 194818, 194819, 194820,\n  194821, 194822, 194823, 194824, 194825, 194826, 194827, 194828, 194829, 194830, 194831, 194832,\n  194833, 194834, 194835, 194836, 194837, 194838, 194839, 194840, 194841, 194842, 194843, 194844,\n  194845, 194846, 194847, 194848, 194849, 194850, 194851, 194852, 194853, 194854, 194855, 194856,\n  194857, 194858, 194859, 194860, 194861, 194862, 194863, 194864, 194865, 194866, 194867, 194868,\n  194869, 194870, 194871, 194872, 194873, 194874, 194875, 194876, 194877, 194878, 194879, 194880,\n  194881, 194882, 194883, 194884, 194885, 194886, 194887, 194888, 194889, 194890, 194891, 194892,\n  194893, 194894, 194895, 194896, 194897, 194898, 194899, 194900, 194901, 194902, 194903, 194904,\n  194905, 194906, 194907, 194908, 194909, 194910, 194911, 194912, 194913, 194914, 194915, 194916,\n  194917, 194918, 194919, 194920, 194921, 194922, 194923, 194924, 194925, 194926, 194927, 194928,\n  194929, 194930, 194931, 194932, 194933, 194934, 194935, 194936, 194937, 194938, 194939, 194940,\n  194941, 194942, 194943, 194944, 194945, 194946, 194947, 194948, 194949, 194950, 194951, 194952,\n  194953, 194954, 194955, 194956, 194957, 194958, 194959, 194960, 194961, 194962, 194963, 194964,\n  194965, 194966, 194967, 194968, 194969, 194970, 194971, 194972, 194973, 194974, 194975, 194976,\n  194977, 194978, 194979, 194980, 194981, 194982, 194983, 194984, 194985, 194986, 194987, 194988,\n  194989, 194990, 194991, 194992, 194993, 194994, 194995, 194996, 194997, 194998, 194999, 195000,\n  195001, 195002, 195003, 195004, 195005, 195006, 195007, 195008, 195009, 195010, 195011, 195012,\n  195013, 195014, 195015, 195016, 195017, 195018, 195019, 195020, 195021, 195022, 195023, 195024,\n  195025, 195026, 195027, 195028, 195029, 195030, 195031, 195032, 195033, 195034, 195035, 195036,\n  195037, 195038, 195039, 195040, 195041, 195042, 195043, 195044, 195045, 195046, 195047, 195048,\n  195049, 195050, 195051, 195052, 195053, 195054, 195055, 195056, 195057, 195058, 195059, 195060,\n  195061, 195062, 195063, 195064, 195065, 195066, 195067, 195068, 195069, 195070, 195071, 195072,\n  195073, 195074, 195075, 195076, 195077, 195078, 195079, 195080, 195081, 195082, 195083, 195084,\n  195085, 195086, 195087, 195088, 195089, 195090, 195091, 195092, 195093, 195094, 195095, 195096,\n  195097, 195098, 195099, 195100, 195101,\n]\n\nexport let CANONICAL_DECOMPOSITION_OFFSETS: Array<int> = [\n  0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,\n  24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46,\n  48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70,\n  72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94,\n  96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118,\n  120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142,\n  144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166,\n  168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190,\n  192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214,\n  216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238,\n  240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262,\n  264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286,\n  288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310,\n  312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334,\n  336, 338, 340, 342, 344, 346, 349, 352, 355, 358, 361, 364,\n  367, 370, 373, 376, 379, 382, 384, 386, 388, 390, 392, 394,\n  396, 398, 401, 404, 406, 408, 410, 412, 414, 416, 418, 421,\n  424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446,\n  448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470,\n  472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494,\n  496, 498, 500, 503, 506, 509, 512, 514, 516, 519, 522, 524,\n  526, 527, 528, 529, 531, 532, 533, 535, 537, 538, 540, 542,\n  544, 546, 548, 550, 553, 555, 557, 559, 561, 563, 565, 568,\n  570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592,\n  594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616,\n  618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640,\n  642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664,\n  666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688,\n  690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712,\n  714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736,\n  738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760,\n  762, 764, 766, 768, 770, 772, 774, 777, 779, 781, 783, 785,\n  787, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810,\n  812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834,\n  836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858,\n  860, 862, 864, 866, 869, 872, 874, 876, 878, 880, 882, 884,\n  886, 888, 890, 892, 895, 898, 901, 904, 906, 908, 910, 912,\n  915, 918, 920, 922, 924, 926, 928, 930, 932, 934, 936, 938,\n  940, 942, 944, 946, 948, 950, 953, 956, 958, 960, 962, 964,\n  966, 968, 970, 972, 975, 978, 980, 982, 984, 986, 988, 990,\n  992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014,\n  1017, 1020, 1023, 1026, 1029, 1032, 1035, 1038, 1040, 1042, 1044, 1046,\n  1048, 1050, 1052, 1054, 1057, 1060, 1062, 1064, 1066, 1068, 1070, 1072,\n  1075, 1078, 1081, 1084, 1087, 1090, 1092, 1094, 1096, 1098, 1100, 1102,\n  1104, 1106, 1108, 1110, 1112, 1114, 1116, 1118, 1121, 1124, 1127, 1130,\n  1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154,\n  1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178,\n  1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1203,\n  1206, 1209, 1212, 1215, 1218, 1221, 1224, 1227, 1230, 1233, 1236, 1239,\n  1242, 1245, 1248, 1251, 1254, 1257, 1260, 1262, 1264, 1266, 1268, 1270,\n  1272, 1275, 1278, 1281, 1284, 1287, 1290, 1293, 1296, 1299, 1302, 1304,\n  1306, 1308, 1310, 1312, 1314, 1316, 1318, 1321, 1324, 1327, 1330, 1333,\n  1336, 1339, 1342, 1345, 1348, 1351, 1354, 1357, 1360, 1363, 1366, 1369,\n  1372, 1375, 1378, 1380, 1382, 1384, 1386, 1389, 1392, 1395, 1398, 1401,\n  1404, 1407, 1410, 1413, 1416, 1418, 1420, 1422, 1424, 1426, 1428, 1430,\n  1432, 1434, 1436, 1439, 1442, 1445, 1448, 1451, 1454, 1456, 1458, 1461,\n  1464, 1467, 1470, 1473, 1476, 1478, 1480, 1483, 1486, 1489, 1492, 1494,\n  1496, 1499, 1502, 1505, 1508, 1510, 1512, 1515, 1518, 1521, 1524, 1527,\n  1530, 1532, 1534, 1537, 1540, 1543, 1546, 1549, 1552, 1554, 1556, 1559,\n  1562, 1565, 1568, 1571, 1574, 1576, 1578, 1581, 1584, 1587, 1590, 1593,\n  1596, 1598, 1600, 1603, 1606, 1609, 1612, 1614, 1616, 1619, 1622, 1625,\n  1628, 1630, 1632, 1635, 1638, 1641, 1644, 1647, 1650, 1652, 1655, 1658,\n  1661, 1663, 1665, 1668, 1671, 1674, 1677, 1680, 1683, 1685, 1687, 1690,\n  1693, 1696, 1699, 1702, 1705, 1707, 1709, 1711, 1713, 1715, 1717, 1719,\n  1721, 1723, 1725, 1727, 1729, 1731, 1733, 1736, 1739, 1743, 1747, 1751,\n  1755, 1759, 1763, 1766, 1769, 1773, 1777, 1781, 1785, 1789, 1793, 1796,\n  1799, 1803, 1807, 1811, 1815, 1819, 1823, 1826, 1829, 1833, 1837, 1841,\n  1845, 1849, 1853, 1856, 1859, 1863, 1867, 1871, 1875, 1879, 1883, 1886,\n  1889, 1893, 1897, 1901, 1905, 1909, 1913, 1915, 1917, 1920, 1922, 1925,\n  1927, 1930, 1932, 1934, 1936, 1938, 1940, 1941, 1943, 1946, 1948, 1951,\n  1953, 1956, 1958, 1960, 1962, 1964, 1966, 1968, 1970, 1972, 1974, 1976,\n  1979, 1982, 1984, 1987, 1989, 1991, 1993, 1995, 1997, 1999, 2001, 2003,\n  2005, 2008, 2011, 2013, 2015, 2017, 2020, 2022, 2024, 2026, 2028, 2030,\n  2032, 2034, 2035, 2038, 2040, 2043, 2045, 2048, 2050, 2052, 2054, 2056,\n  2058, 2059, 2060, 2061, 2062, 2063, 2065, 2067, 2069, 2071, 2073, 2075,\n  2077, 2079, 2081, 2083, 2085, 2087, 2089, 2091, 2093, 2095, 2097, 2099,\n  2101, 2103, 2105, 2107, 2109, 2111, 2113, 2115, 2117, 2119, 2121, 2123,\n  2125, 2127, 2129, 2131, 2133, 2135, 2137, 2139, 2141, 2143, 2145, 2147,\n  2149, 2151, 2153, 2154, 2155, 2157, 2159, 2161, 2163, 2165, 2167, 2169,\n  2171, 2173, 2175, 2177, 2179, 2181, 2183, 2185, 2187, 2189, 2191, 2193,\n  2195, 2197, 2199, 2201, 2203, 2205, 2207, 2209, 2211, 2213, 2215, 2217,\n  2219, 2221, 2223, 2225, 2227, 2229, 2231, 2233, 2235, 2237, 2239, 2241,\n  2243, 2245, 2247, 2249, 2251, 2253, 2255, 2257, 2259, 2261, 2263, 2265,\n  2267, 2269, 2271, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281,\n  2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293,\n  2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305,\n  2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317,\n  2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329,\n  2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341,\n  2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353,\n  2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365,\n  2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377,\n  2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389,\n  2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401,\n  2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413,\n  2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425,\n  2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437,\n  2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449,\n  2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 2461,\n  2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473,\n  2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485,\n  2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497,\n  2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, 2506, 2507, 2508, 2509,\n  2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521,\n  2522, 2523, 2524, 2525, 2526, 2527, 2528, 2529, 2530, 2531, 2532, 2533,\n  2534, 2535, 2536, 2537, 2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545,\n  2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553, 2554, 2555, 2556, 2557,\n  2558, 2559, 2560, 2561, 2562, 2563, 2564, 2565, 2566, 2567, 2568, 2569,\n  2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581,\n  2582, 2583, 2584, 2585, 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593,\n  2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2604, 2605,\n  2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617,\n  2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629,\n  2630, 2631, 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2639, 2640, 2641,\n  2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 2650, 2651, 2652, 2653,\n  2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, 2664, 2665,\n  2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677,\n  2678, 2679, 2680, 2681, 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689,\n  2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697, 2698, 2699, 2700, 2701,\n  2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713,\n  2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725,\n  2726, 2727, 2728, 2729, 2730, 2731, 2732, 2733, 2735, 2737, 2739, 2741,\n  2744, 2747, 2749, 2751, 2753, 2755, 2757, 2759, 2761, 2763, 2765, 2767,\n  2769, 2771, 2773, 2775, 2777, 2779, 2781, 2783, 2785, 2787, 2789, 2791,\n  2793, 2795, 2797, 2799, 2801, 2803, 2805, 2807, 2809, 2811, 2813, 2815,\n  2817, 2819, 2821, 2823, 2825, 2827, 2829, 2831, 2833, 2835, 2837, 2839,\n  2841, 2843, 2845, 2847, 2849, 2851, 2853, 2855, 2857, 2860, 2863, 2866,\n  2868, 2870, 2873, 2875, 2877, 2880, 2883, 2886, 2889, 2892, 2894, 2896,\n  2899, 2902, 2905, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916,\n  2917, 2918, 2919, 2920, 2921, 2922, 2923, 2924, 2925, 2926, 2927, 2928,\n  2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, 2940,\n  2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952,\n  2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964,\n  2965, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976,\n  2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985, 2986, 2987, 2988,\n  2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000,\n  3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012,\n  3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024,\n  3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036,\n  3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048,\n  3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060,\n  3061, 3062, 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072,\n  3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, 3082, 3083, 3084,\n  3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096,\n  3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108,\n  3109, 3110, 3111, 3112, 3113, 3114, 3115, 3116, 3117, 3118, 3119, 3120,\n  3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129, 3130, 3131, 3132,\n  3133, 3134, 3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144,\n  3145, 3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153, 3154, 3155, 3156,\n  3157, 3158, 3159, 3160, 3161, 3162, 3163, 3164, 3165, 3166, 3167, 3168,\n  3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177, 3178, 3179, 3180,\n  3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192,\n  3193, 3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204,\n  3205, 3206, 3207, 3208, 3209, 3210, 3211, 3212, 3213, 3214, 3215, 3216,\n  3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225, 3226, 3227, 3228,\n  3229, 3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240,\n  3241, 3242, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 3250, 3251, 3252,\n  3253, 3254, 3255, 3256, 3257, 3258, 3259, 3260, 3261, 3262, 3263, 3264,\n  3265, 3266, 3267, 3268, 3269, 3270, 3271, 3272, 3273, 3274, 3275, 3276,\n  3277, 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286, 3287, 3288,\n  3289, 3290, 3291, 3292, 3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300,\n  3301, 3302, 3303, 3304, 3305, 3306, 3307, 3308, 3309, 3310, 3311, 3312,\n  3313, 3314, 3315, 3316, 3317, 3318, 3319, 3320, 3321, 3322, 3323, 3324,\n  3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334, 3335, 3336,\n  3337, 3338, 3339, 3340, 3341, 3342, 3343, 3344, 3345, 3346, 3347, 3348,\n  3349, 3350, 3351, 3352, 3353, 3354, 3355, 3356, 3357, 3358, 3359, 3360,\n  3361, 3362, 3363, 3364, 3365, 3366, 3367, 3368, 3369, 3370, 3371, 3372,\n  3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382, 3383, 3384,\n  3385, 3386, 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396,\n  3397, 3398, 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406, 3407, 3408,\n  3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3417, 3418, 3419, 3420,\n  3421, 3422, 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432,\n  3433, 3434, 3435, 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3444,\n  3445, 3446, 3447, 3448, 3449, 3450,\n]\n\nexport let CANONICAL_DECOMPOSITION_VALUES: Array<int> = [\n  65, 768, 65, 769, 65, 770, 65, 771, 65, 776, 65, 778,\n  67, 807, 69, 768, 69, 769, 69, 770, 69, 776, 73, 768,\n  73, 769, 73, 770, 73, 776, 78, 771, 79, 768, 79, 769,\n  79, 770, 79, 771, 79, 776, 85, 768, 85, 769, 85, 770,\n  85, 776, 89, 769, 97, 768, 97, 769, 97, 770, 97, 771,\n  97, 776, 97, 778, 99, 807, 101, 768, 101, 769, 101, 770,\n  101, 776, 105, 768, 105, 769, 105, 770, 105, 776, 110, 771,\n  111, 768, 111, 769, 111, 770, 111, 771, 111, 776, 117, 768,\n  117, 769, 117, 770, 117, 776, 121, 769, 121, 776, 65, 772,\n  97, 772, 65, 774, 97, 774, 65, 808, 97, 808, 67, 769,\n  99, 769, 67, 770, 99, 770, 67, 775, 99, 775, 67, 780,\n  99, 780, 68, 780, 100, 780, 69, 772, 101, 772, 69, 774,\n  101, 774, 69, 775, 101, 775, 69, 808, 101, 808, 69, 780,\n  101, 780, 71, 770, 103, 770, 71, 774, 103, 774, 71, 775,\n  103, 775, 71, 807, 103, 807, 72, 770, 104, 770, 73, 771,\n  105, 771, 73, 772, 105, 772, 73, 774, 105, 774, 73, 808,\n  105, 808, 73, 775, 74, 770, 106, 770, 75, 807, 107, 807,\n  76, 769, 108, 769, 76, 807, 108, 807, 76, 780, 108, 780,\n  78, 769, 110, 769, 78, 807, 110, 807, 78, 780, 110, 780,\n  79, 772, 111, 772, 79, 774, 111, 774, 79, 779, 111, 779,\n  82, 769, 114, 769, 82, 807, 114, 807, 82, 780, 114, 780,\n  83, 769, 115, 769, 83, 770, 115, 770, 83, 807, 115, 807,\n  83, 780, 115, 780, 84, 807, 116, 807, 84, 780, 116, 780,\n  85, 771, 117, 771, 85, 772, 117, 772, 85, 774, 117, 774,\n  85, 778, 117, 778, 85, 779, 117, 779, 85, 808, 117, 808,\n  87, 770, 119, 770, 89, 770, 121, 770, 89, 776, 90, 769,\n  122, 769, 90, 775, 122, 775, 90, 780, 122, 780, 79, 795,\n  111, 795, 85, 795, 117, 795, 65, 780, 97, 780, 73, 780,\n  105, 780, 79, 780, 111, 780, 85, 780, 117, 780, 85, 776,\n  772, 117, 776, 772, 85, 776, 769, 117, 776, 769, 85, 776,\n  780, 117, 776, 780, 85, 776, 768, 117, 776, 768, 65, 776,\n  772, 97, 776, 772, 65, 775, 772, 97, 775, 772, 198, 772,\n  230, 772, 71, 780, 103, 780, 75, 780, 107, 780, 79, 808,\n  111, 808, 79, 808, 772, 111, 808, 772, 439, 780, 658, 780,\n  106, 780, 71, 769, 103, 769, 78, 768, 110, 768, 65, 778,\n  769, 97, 778, 769, 198, 769, 230, 769, 216, 769, 248, 769,\n  65, 783, 97, 783, 65, 785, 97, 785, 69, 783, 101, 783,\n  69, 785, 101, 785, 73, 783, 105, 783, 73, 785, 105, 785,\n  79, 783, 111, 783, 79, 785, 111, 785, 82, 783, 114, 783,\n  82, 785, 114, 785, 85, 783, 117, 783, 85, 785, 117, 785,\n  83, 806, 115, 806, 84, 806, 116, 806, 72, 780, 104, 780,\n  65, 775, 97, 775, 69, 807, 101, 807, 79, 776, 772, 111,\n  776, 772, 79, 771, 772, 111, 771, 772, 79, 775, 111, 775,\n  79, 775, 772, 111, 775, 772, 89, 772, 121, 772, 768, 769,\n  787, 776, 769, 697, 59, 168, 769, 913, 769, 183, 917, 769,\n  919, 769, 921, 769, 927, 769, 933, 769, 937, 769, 953, 776,\n  769, 921, 776, 933, 776, 945, 769, 949, 769, 951, 769, 953,\n  769, 965, 776, 769, 953, 776, 965, 776, 959, 769, 965, 769,\n  969, 769, 978, 769, 978, 776, 1045, 768, 1045, 776, 1043, 769,\n  1030, 776, 1050, 769, 1048, 768, 1059, 774, 1048, 774, 1080, 774,\n  1077, 768, 1077, 776, 1075, 769, 1110, 776, 1082, 769, 1080, 768,\n  1091, 774, 1140, 783, 1141, 783, 1046, 774, 1078, 774, 1040, 774,\n  1072, 774, 1040, 776, 1072, 776, 1045, 774, 1077, 774, 1240, 776,\n  1241, 776, 1046, 776, 1078, 776, 1047, 776, 1079, 776, 1048, 772,\n  1080, 772, 1048, 776, 1080, 776, 1054, 776, 1086, 776, 1256, 776,\n  1257, 776, 1069, 776, 1101, 776, 1059, 772, 1091, 772, 1059, 776,\n  1091, 776, 1059, 779, 1091, 779, 1063, 776, 1095, 776, 1067, 776,\n  1099, 776, 1575, 1619, 1575, 1620, 1608, 1620, 1575, 1621, 1610, 1620,\n  1749, 1620, 1729, 1620, 1746, 1620, 2344, 2364, 2352, 2364, 2355, 2364,\n  2325, 2364, 2326, 2364, 2327, 2364, 2332, 2364, 2337, 2364, 2338, 2364,\n  2347, 2364, 2351, 2364, 2503, 2494, 2503, 2519, 2465, 2492, 2466, 2492,\n  2479, 2492, 2610, 2620, 2616, 2620, 2582, 2620, 2583, 2620, 2588, 2620,\n  2603, 2620, 2887, 2902, 2887, 2878, 2887, 2903, 2849, 2876, 2850, 2876,\n  2962, 3031, 3014, 3006, 3015, 3006, 3014, 3031, 3142, 3158, 3263, 3285,\n  3270, 3285, 3270, 3286, 3270, 3266, 3270, 3266, 3285, 3398, 3390, 3399,\n  3390, 3398, 3415, 3545, 3530, 3545, 3535, 3545, 3535, 3530, 3545, 3551,\n  3906, 4023, 3916, 4023, 3921, 4023, 3926, 4023, 3931, 4023, 3904, 4021,\n  3953, 3954, 3953, 3956, 4018, 3968, 4019, 3968, 3953, 3968, 3986, 4023,\n  3996, 4023, 4001, 4023, 4006, 4023, 4011, 4023, 3984, 4021, 4133, 4142,\n  6917, 6965, 6919, 6965, 6921, 6965, 6923, 6965, 6925, 6965, 6929, 6965,\n  6970, 6965, 6972, 6965, 6974, 6965, 6975, 6965, 6978, 6965, 65, 805,\n  97, 805, 66, 775, 98, 775, 66, 803, 98, 803, 66, 817,\n  98, 817, 67, 807, 769, 99, 807, 769, 68, 775, 100, 775,\n  68, 803, 100, 803, 68, 817, 100, 817, 68, 807, 100, 807,\n  68, 813, 100, 813, 69, 772, 768, 101, 772, 768, 69, 772,\n  769, 101, 772, 769, 69, 813, 101, 813, 69, 816, 101, 816,\n  69, 807, 774, 101, 807, 774, 70, 775, 102, 775, 71, 772,\n  103, 772, 72, 775, 104, 775, 72, 803, 104, 803, 72, 776,\n  104, 776, 72, 807, 104, 807, 72, 814, 104, 814, 73, 816,\n  105, 816, 73, 776, 769, 105, 776, 769, 75, 769, 107, 769,\n  75, 803, 107, 803, 75, 817, 107, 817, 76, 803, 108, 803,\n  76, 803, 772, 108, 803, 772, 76, 817, 108, 817, 76, 813,\n  108, 813, 77, 769, 109, 769, 77, 775, 109, 775, 77, 803,\n  109, 803, 78, 775, 110, 775, 78, 803, 110, 803, 78, 817,\n  110, 817, 78, 813, 110, 813, 79, 771, 769, 111, 771, 769,\n  79, 771, 776, 111, 771, 776, 79, 772, 768, 111, 772, 768,\n  79, 772, 769, 111, 772, 769, 80, 769, 112, 769, 80, 775,\n  112, 775, 82, 775, 114, 775, 82, 803, 114, 803, 82, 803,\n  772, 114, 803, 772, 82, 817, 114, 817, 83, 775, 115, 775,\n  83, 803, 115, 803, 83, 769, 775, 115, 769, 775, 83, 780,\n  775, 115, 780, 775, 83, 803, 775, 115, 803, 775, 84, 775,\n  116, 775, 84, 803, 116, 803, 84, 817, 116, 817, 84, 813,\n  116, 813, 85, 804, 117, 804, 85, 816, 117, 816, 85, 813,\n  117, 813, 85, 771, 769, 117, 771, 769, 85, 772, 776, 117,\n  772, 776, 86, 771, 118, 771, 86, 803, 118, 803, 87, 768,\n  119, 768, 87, 769, 119, 769, 87, 776, 119, 776, 87, 775,\n  119, 775, 87, 803, 119, 803, 88, 775, 120, 775, 88, 776,\n  120, 776, 89, 775, 121, 775, 90, 770, 122, 770, 90, 803,\n  122, 803, 90, 817, 122, 817, 104, 817, 116, 776, 119, 778,\n  121, 778, 383, 775, 65, 803, 97, 803, 65, 777, 97, 777,\n  65, 770, 769, 97, 770, 769, 65, 770, 768, 97, 770, 768,\n  65, 770, 777, 97, 770, 777, 65, 770, 771, 97, 770, 771,\n  65, 803, 770, 97, 803, 770, 65, 774, 769, 97, 774, 769,\n  65, 774, 768, 97, 774, 768, 65, 774, 777, 97, 774, 777,\n  65, 774, 771, 97, 774, 771, 65, 803, 774, 97, 803, 774,\n  69, 803, 101, 803, 69, 777, 101, 777, 69, 771, 101, 771,\n  69, 770, 769, 101, 770, 769, 69, 770, 768, 101, 770, 768,\n  69, 770, 777, 101, 770, 777, 69, 770, 771, 101, 770, 771,\n  69, 803, 770, 101, 803, 770, 73, 777, 105, 777, 73, 803,\n  105, 803, 79, 803, 111, 803, 79, 777, 111, 777, 79, 770,\n  769, 111, 770, 769, 79, 770, 768, 111, 770, 768, 79, 770,\n  777, 111, 770, 777, 79, 770, 771, 111, 770, 771, 79, 803,\n  770, 111, 803, 770, 79, 795, 769, 111, 795, 769, 79, 795,\n  768, 111, 795, 768, 79, 795, 777, 111, 795, 777, 79, 795,\n  771, 111, 795, 771, 79, 795, 803, 111, 795, 803, 85, 803,\n  117, 803, 85, 777, 117, 777, 85, 795, 769, 117, 795, 769,\n  85, 795, 768, 117, 795, 768, 85, 795, 777, 117, 795, 777,\n  85, 795, 771, 117, 795, 771, 85, 795, 803, 117, 795, 803,\n  89, 768, 121, 768, 89, 803, 121, 803, 89, 777, 121, 777,\n  89, 771, 121, 771, 945, 787, 945, 788, 945, 787, 768, 945,\n  788, 768, 945, 787, 769, 945, 788, 769, 945, 787, 834, 945,\n  788, 834, 913, 787, 913, 788, 913, 787, 768, 913, 788, 768,\n  913, 787, 769, 913, 788, 769, 913, 787, 834, 913, 788, 834,\n  949, 787, 949, 788, 949, 787, 768, 949, 788, 768, 949, 787,\n  769, 949, 788, 769, 917, 787, 917, 788, 917, 787, 768, 917,\n  788, 768, 917, 787, 769, 917, 788, 769, 951, 787, 951, 788,\n  951, 787, 768, 951, 788, 768, 951, 787, 769, 951, 788, 769,\n  951, 787, 834, 951, 788, 834, 919, 787, 919, 788, 919, 787,\n  768, 919, 788, 768, 919, 787, 769, 919, 788, 769, 919, 787,\n  834, 919, 788, 834, 953, 787, 953, 788, 953, 787, 768, 953,\n  788, 768, 953, 787, 769, 953, 788, 769, 953, 787, 834, 953,\n  788, 834, 921, 787, 921, 788, 921, 787, 768, 921, 788, 768,\n  921, 787, 769, 921, 788, 769, 921, 787, 834, 921, 788, 834,\n  959, 787, 959, 788, 959, 787, 768, 959, 788, 768, 959, 787,\n  769, 959, 788, 769, 927, 787, 927, 788, 927, 787, 768, 927,\n  788, 768, 927, 787, 769, 927, 788, 769, 965, 787, 965, 788,\n  965, 787, 768, 965, 788, 768, 965, 787, 769, 965, 788, 769,\n  965, 787, 834, 965, 788, 834, 933, 788, 933, 788, 768, 933,\n  788, 769, 933, 788, 834, 969, 787, 969, 788, 969, 787, 768,\n  969, 788, 768, 969, 787, 769, 969, 788, 769, 969, 787, 834,\n  969, 788, 834, 937, 787, 937, 788, 937, 787, 768, 937, 788,\n  768, 937, 787, 769, 937, 788, 769, 937, 787, 834, 937, 788,\n  834, 945, 768, 945, 769, 949, 768, 949, 769, 951, 768, 951,\n  769, 953, 768, 953, 769, 959, 768, 959, 769, 965, 768, 965,\n  769, 969, 768, 969, 769, 945, 787, 837, 945, 788, 837, 945,\n  787, 768, 837, 945, 788, 768, 837, 945, 787, 769, 837, 945,\n  788, 769, 837, 945, 787, 834, 837, 945, 788, 834, 837, 913,\n  787, 837, 913, 788, 837, 913, 787, 768, 837, 913, 788, 768,\n  837, 913, 787, 769, 837, 913, 788, 769, 837, 913, 787, 834,\n  837, 913, 788, 834, 837, 951, 787, 837, 951, 788, 837, 951,\n  787, 768, 837, 951, 788, 768, 837, 951, 787, 769, 837, 951,\n  788, 769, 837, 951, 787, 834, 837, 951, 788, 834, 837, 919,\n  787, 837, 919, 788, 837, 919, 787, 768, 837, 919, 788, 768,\n  837, 919, 787, 769, 837, 919, 788, 769, 837, 919, 787, 834,\n  837, 919, 788, 834, 837, 969, 787, 837, 969, 788, 837, 969,\n  787, 768, 837, 969, 788, 768, 837, 969, 787, 769, 837, 969,\n  788, 769, 837, 969, 787, 834, 837, 969, 788, 834, 837, 937,\n  787, 837, 937, 788, 837, 937, 787, 768, 837, 937, 788, 768,\n  837, 937, 787, 769, 837, 937, 788, 769, 837, 937, 787, 834,\n  837, 937, 788, 834, 837, 945, 774, 945, 772, 945, 768, 837,\n  945, 837, 945, 769, 837, 945, 834, 945, 834, 837, 913, 774,\n  913, 772, 913, 768, 913, 769, 913, 837, 953, 168, 834, 951,\n  768, 837, 951, 837, 951, 769, 837, 951, 834, 951, 834, 837,\n  917, 768, 917, 769, 919, 768, 919, 769, 919, 837, 8127, 768,\n  8127, 769, 8127, 834, 953, 774, 953, 772, 953, 776, 768, 953,\n  776, 769, 953, 834, 953, 776, 834, 921, 774, 921, 772, 921,\n  768, 921, 769, 8190, 768, 8190, 769, 8190, 834, 965, 774, 965,\n  772, 965, 776, 768, 965, 776, 769, 961, 787, 961, 788, 965,\n  834, 965, 776, 834, 933, 774, 933, 772, 933, 768, 933, 769,\n  929, 788, 168, 768, 168, 769, 96, 969, 768, 837, 969, 837,\n  969, 769, 837, 969, 834, 969, 834, 837, 927, 768, 927, 769,\n  937, 768, 937, 769, 937, 837, 180, 8194, 8195, 937, 75, 65,\n  778, 8592, 824, 8594, 824, 8596, 824, 8656, 824, 8660, 824, 8658,\n  824, 8707, 824, 8712, 824, 8715, 824, 8739, 824, 8741, 824, 8764,\n  824, 8771, 824, 8773, 824, 8776, 824, 61, 824, 8801, 824, 8781,\n  824, 60, 824, 62, 824, 8804, 824, 8805, 824, 8818, 824, 8819,\n  824, 8822, 824, 8823, 824, 8826, 824, 8827, 824, 8834, 824, 8835,\n  824, 8838, 824, 8839, 824, 8866, 824, 8872, 824, 8873, 824, 8875,\n  824, 8828, 824, 8829, 824, 8849, 824, 8850, 824, 8882, 824, 8883,\n  824, 8884, 824, 8885, 824, 12296, 12297, 10973, 824, 12363, 12441, 12365,\n  12441, 12367, 12441, 12369, 12441, 12371, 12441, 12373, 12441, 12375, 12441, 12377,\n  12441, 12379, 12441, 12381, 12441, 12383, 12441, 12385, 12441, 12388, 12441, 12390,\n  12441, 12392, 12441, 12399, 12441, 12399, 12442, 12402, 12441, 12402, 12442, 12405,\n  12441, 12405, 12442, 12408, 12441, 12408, 12442, 12411, 12441, 12411, 12442, 12358,\n  12441, 12445, 12441, 12459, 12441, 12461, 12441, 12463, 12441, 12465, 12441, 12467,\n  12441, 12469, 12441, 12471, 12441, 12473, 12441, 12475, 12441, 12477, 12441, 12479,\n  12441, 12481, 12441, 12484, 12441, 12486, 12441, 12488, 12441, 12495, 12441, 12495,\n  12442, 12498, 12441, 12498, 12442, 12501, 12441, 12501, 12442, 12504, 12441, 12504,\n  12442, 12507, 12441, 12507, 12442, 12454, 12441, 12527, 12441, 12528, 12441, 12529,\n  12441, 12530, 12441, 12541, 12441, 35912, 26356, 36554, 36040, 28369, 20018, 21477,\n  40860, 40860, 22865, 37329, 21895, 22856, 25078, 30313, 32645, 34367, 34746, 35064,\n  37007, 27138, 27931, 28889, 29662, 33853, 37226, 39409, 20098, 21365, 27396, 29211,\n  34349, 40478, 23888, 28651, 34253, 35172, 25289, 33240, 34847, 24266, 26391, 28010,\n  29436, 37070, 20358, 20919, 21214, 25796, 27347, 29200, 30439, 32769, 34310, 34396,\n  36335, 38706, 39791, 40442, 30860, 31103, 32160, 33737, 37636, 40575, 35542, 22751,\n  24324, 31840, 32894, 29282, 30922, 36034, 38647, 22744, 23650, 27155, 28122, 28431,\n  32047, 32311, 38475, 21202, 32907, 20956, 20940, 31260, 32190, 33777, 38517, 35712,\n  25295, 27138, 35582, 20025, 23527, 24594, 29575, 30064, 21271, 30971, 20415, 24489,\n  19981, 27852, 25976, 32034, 21443, 22622, 30465, 33865, 35498, 27578, 36784, 27784,\n  25342, 33509, 25504, 30053, 20142, 20841, 20937, 26753, 31975, 33391, 35538, 37327,\n  21237, 21570, 22899, 24300, 26053, 28670, 31018, 38317, 39530, 40599, 40654, 21147,\n  26310, 27511, 36706, 24180, 24976, 25088, 25754, 28451, 29001, 29833, 31178, 32244,\n  32879, 36646, 34030, 36899, 37706, 21015, 21155, 21693, 28872, 35010, 35498, 24265,\n  24565, 25467, 27566, 31806, 29557, 20196, 22265, 23527, 23994, 24604, 29618, 29801,\n  32666, 32838, 37428, 38646, 38728, 38936, 20363, 31150, 37300, 38584, 24801, 20102,\n  20698, 23534, 23615, 26009, 27138, 29134, 30274, 34044, 36988, 40845, 26248, 38446,\n  21129, 26491, 26611, 27969, 28316, 29705, 30041, 30827, 32016, 39006, 20845, 25134,\n  38520, 20523, 23833, 28138, 36650, 24459, 24900, 26647, 29575, 38534, 21033, 21519,\n  23653, 26131, 26446, 26792, 27877, 29702, 30178, 32633, 35023, 35041, 37324, 38626,\n  21311, 28346, 21533, 29136, 29848, 34298, 38563, 40023, 40607, 26519, 28107, 33256,\n  31435, 31520, 31890, 29376, 28825, 35672, 20160, 33590, 21050, 20999, 24230, 25299,\n  31958, 23429, 27934, 26292, 36667, 34892, 38477, 35211, 24275, 20800, 21952, 22618,\n  26228, 20958, 29482, 30410, 31036, 31070, 31077, 31119, 38742, 31934, 32701, 34322,\n  35576, 36920, 37117, 39151, 39164, 39208, 40372, 37086, 38583, 20398, 20711, 20813,\n  21193, 21220, 21329, 21917, 22022, 22120, 22592, 22696, 23652, 23662, 24724, 24936,\n  24974, 25074, 25935, 26082, 26257, 26757, 28023, 28186, 28450, 29038, 29227, 29730,\n  30865, 31038, 31049, 31048, 31056, 31062, 31069, 31117, 31118, 31296, 31361, 31680,\n  32244, 32265, 32321, 32626, 32773, 33261, 33401, 33401, 33879, 35088, 35222, 35585,\n  35641, 36051, 36104, 36790, 36920, 38627, 38911, 38971, 24693, 148206, 33304, 20006,\n  20917, 20840, 20352, 20805, 20864, 21191, 21242, 21917, 21845, 21913, 21986, 22618,\n  22707, 22852, 22868, 23138, 23336, 24274, 24281, 24425, 24493, 24792, 24910, 24840,\n  24974, 24928, 25074, 25140, 25540, 25628, 25682, 25942, 26228, 26391, 26395, 26454,\n  27513, 27578, 27969, 28379, 28363, 28450, 28702, 29038, 30631, 29237, 29359, 29482,\n  29809, 29958, 30011, 30237, 30239, 30410, 30427, 30452, 30538, 30528, 30924, 31409,\n  31680, 31867, 32091, 32244, 32574, 32773, 33618, 33775, 34681, 35137, 35206, 35222,\n  35519, 35576, 35531, 35585, 35582, 35565, 35641, 35722, 36104, 36664, 36978, 37273,\n  37494, 38524, 38627, 38742, 38875, 38911, 38923, 38971, 39698, 40860, 141386, 141380,\n  144341, 15261, 16408, 16441, 152137, 154832, 163539, 40771, 40846, 1497, 1460, 1522,\n  1463, 1513, 1473, 1513, 1474, 1513, 1468, 1473, 1513, 1468, 1474, 1488,\n  1463, 1488, 1464, 1488, 1468, 1489, 1468, 1490, 1468, 1491, 1468, 1492,\n  1468, 1493, 1468, 1494, 1468, 1496, 1468, 1497, 1468, 1498, 1468, 1499,\n  1468, 1500, 1468, 1502, 1468, 1504, 1468, 1505, 1468, 1507, 1468, 1508,\n  1468, 1510, 1468, 1511, 1468, 1512, 1468, 1513, 1468, 1514, 1468, 1493,\n  1465, 1489, 1471, 1499, 1471, 1508, 1471, 67026, 775, 67034, 775, 69785,\n  69818, 69787, 69818, 69797, 69818, 69937, 69927, 69938, 69927, 70471, 70462, 70471,\n  70487, 70530, 70601, 70532, 70587, 70539, 70594, 70544, 70601, 70594, 70594, 70594,\n  70584, 70594, 70601, 70841, 70842, 70841, 70832, 70841, 70845, 71096, 71087, 71097,\n  71087, 71989, 71984, 90398, 90398, 90398, 90409, 90398, 90399, 90409, 90399, 90398,\n  90400, 90398, 90398, 90399, 90398, 90409, 90399, 90398, 90398, 90400, 93543, 93543,\n  93539, 93543, 93539, 93543, 93543, 119127, 119141, 119128, 119141, 119128, 119141, 119150,\n  119128, 119141, 119151, 119128, 119141, 119152, 119128, 119141, 119153, 119128, 119141, 119154,\n  119225, 119141, 119226, 119141, 119225, 119141, 119150, 119226, 119141, 119150, 119225, 119141,\n  119151, 119226, 119141, 119151, 20029, 20024, 20033, 131362, 20320, 20398, 20411, 20482,\n  20602, 20633, 20711, 20687, 13470, 132666, 20813, 20820, 20836, 20855, 132380, 13497,\n  20839, 20877, 132427, 20887, 20900, 20172, 20908, 20917, 168415, 20981, 20995, 13535,\n  21051, 21062, 21106, 21111, 13589, 21191, 21193, 21220, 21242, 21253, 21254, 21271,\n  21321, 21329, 21338, 21363, 21373, 21375, 21375, 21375, 133676, 28784, 21450, 21471,\n  133987, 21483, 21489, 21510, 21662, 21560, 21576, 21608, 21666, 21750, 21776, 21843,\n  21859, 21892, 21892, 21913, 21931, 21939, 21954, 22294, 22022, 22295, 22097, 22132,\n  20999, 22766, 22478, 22516, 22541, 22411, 22578, 22577, 22700, 136420, 22770, 22775,\n  22790, 22810, 22818, 22882, 136872, 136938, 23020, 23067, 23079, 23000, 23142, 14062,\n  14076, 23304, 23358, 23358, 137672, 23491, 23512, 23527, 23539, 138008, 23551, 23558,\n  24403, 23586, 14209, 23648, 23662, 23744, 23693, 138724, 23875, 138726, 23918, 23915,\n  23932, 24033, 24034, 14383, 24061, 24104, 24125, 24169, 14434, 139651, 14460, 24240,\n  24243, 24246, 24266, 172946, 24318, 140081, 140081, 33281, 24354, 24354, 14535, 144056,\n  156122, 24418, 24427, 14563, 24474, 24525, 24535, 24569, 24705, 14650, 14620, 24724,\n  141012, 24775, 24904, 24908, 24910, 24908, 24954, 24974, 25010, 24996, 25007, 25054,\n  25074, 25078, 25104, 25115, 25181, 25265, 25300, 25424, 142092, 25405, 25340, 25448,\n  25475, 25572, 142321, 25634, 25541, 25513, 14894, 25705, 25726, 25757, 25719, 14956,\n  25935, 25964, 143370, 26083, 26360, 26185, 15129, 26257, 15112, 15076, 20882, 20885,\n  26368, 26268, 32941, 17369, 26391, 26395, 26401, 26462, 26451, 144323, 15177, 26618,\n  26501, 26706, 26757, 144493, 26766, 26655, 26900, 15261, 26946, 27043, 27114, 27304,\n  145059, 27355, 15384, 27425, 145575, 27476, 15438, 27506, 27551, 27578, 27579, 146061,\n  138507, 146170, 27726, 146620, 27839, 27853, 27751, 27926, 27966, 28023, 27969, 28009,\n  28024, 28037, 146718, 27956, 28207, 28270, 15667, 28363, 28359, 147153, 28153, 28526,\n  147294, 147342, 28614, 28729, 28702, 28699, 15766, 28746, 28797, 28791, 28845, 132389,\n  28997, 148067, 29084, 148395, 29224, 29237, 29264, 149000, 29312, 29333, 149301, 149524,\n  29562, 29579, 16044, 29605, 16056, 16056, 29767, 29788, 29809, 29829, 29898, 16155,\n  29988, 150582, 30014, 150674, 30064, 139679, 30224, 151457, 151480, 151620, 16380, 16392,\n  30452, 151795, 151794, 151833, 151859, 30494, 30495, 30495, 30538, 16441, 30603, 16454,\n  16534, 152605, 30798, 30860, 30924, 16611, 153126, 31062, 153242, 153285, 31119, 31211,\n  16687, 31296, 31306, 31311, 153980, 154279, 154279, 31470, 16898, 154539, 31686, 31689,\n  16935, 154752, 31954, 17056, 31976, 31971, 32000, 155526, 32099, 17153, 32199, 32258,\n  32325, 17204, 156200, 156231, 17241, 156377, 32634, 156478, 32661, 32762, 32773, 156890,\n  156963, 32864, 157096, 32880, 144223, 17365, 32946, 33027, 17419, 33086, 23221, 157607,\n  157621, 144275, 144284, 33281, 33284, 36766, 17515, 33425, 33419, 33437, 21171, 33457,\n  33459, 33469, 33510, 158524, 33509, 33565, 33635, 33709, 33571, 33725, 33767, 33879,\n  33619, 33738, 33740, 33756, 158774, 159083, 158933, 17707, 34033, 34035, 34070, 160714,\n  34148, 159532, 17757, 17761, 159665, 159954, 17771, 34384, 34396, 34407, 34409, 34473,\n  34440, 34574, 34530, 34681, 34600, 34667, 34694, 17879, 34785, 34817, 17913, 34912,\n  34915, 161383, 35031, 35038, 17973, 35066, 13499, 161966, 162150, 18110, 18119, 35488,\n  35565, 35722, 35925, 162984, 36011, 36033, 36123, 36215, 163631, 133124, 36299, 36284,\n  36336, 133342, 36564, 36664, 165330, 165357, 37012, 37105, 37137, 165678, 37147, 37432,\n  37591, 37592, 37500, 37881, 37909, 166906, 38283, 18837, 38327, 167287, 18918, 38595,\n  23986, 38691, 168261, 168474, 19054, 19062, 38880, 168970, 19122, 169110, 38923, 38923,\n  38953, 169398, 39138, 19251, 39209, 39335, 39362, 39422, 19406, 170800, 39698, 40000,\n  40189, 19662, 19693, 40295, 172238, 19704, 172293, 172558, 172689, 40635, 19798, 40697,\n  40702, 40709, 40719, 40726, 40763, 173568,\n]\n\nexport let CANONICAL_COMBINING_CLASS_KEYS: Array<int> = [\n  768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779,\n  780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791,\n  792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803,\n  804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815,\n  816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827,\n  828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839,\n  840, 841, 842, 843, 844, 845, 846, 848, 849, 850, 851, 852,\n  853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,\n  865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876,\n  877, 878, 879, 1155, 1156, 1157, 1158, 1159, 1425, 1426, 1427, 1428,\n  1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440,\n  1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452,\n  1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464,\n  1465, 1466, 1467, 1468, 1469, 1471, 1473, 1474, 1476, 1477, 1479, 1552,\n  1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1611, 1612,\n  1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624,\n  1625, 1626, 1627, 1628, 1629, 1630, 1631, 1648, 1750, 1751, 1752, 1753,\n  1754, 1755, 1756, 1759, 1760, 1761, 1762, 1763, 1764, 1767, 1768, 1770,\n  1771, 1772, 1773, 1809, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847,\n  1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859,\n  1860, 1861, 1862, 1863, 1864, 1865, 1866, 2027, 2028, 2029, 2030, 2031,\n  2032, 2033, 2034, 2035, 2045, 2070, 2071, 2072, 2073, 2075, 2076, 2077,\n  2078, 2079, 2080, 2081, 2082, 2083, 2085, 2086, 2087, 2089, 2090, 2091,\n  2092, 2093, 2137, 2138, 2139, 2199, 2200, 2201, 2202, 2203, 2204, 2205,\n  2206, 2207, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259,\n  2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271,\n  2272, 2273, 2275, 2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284,\n  2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296,\n  2297, 2298, 2299, 2300, 2301, 2302, 2303, 2364, 2381, 2385, 2386, 2387,\n  2388, 2492, 2509, 2558, 2620, 2637, 2748, 2765, 2876, 2893, 3021, 3132,\n  3149, 3157, 3158, 3260, 3277, 3387, 3388, 3405, 3530, 3640, 3641, 3642,\n  3656, 3657, 3658, 3659, 3768, 3769, 3770, 3784, 3785, 3786, 3787, 3864,\n  3865, 3893, 3895, 3897, 3953, 3954, 3956, 3962, 3963, 3964, 3965, 3968,\n  3970, 3971, 3972, 3974, 3975, 4038, 4151, 4153, 4154, 4237, 4957, 4958,\n  4959, 5908, 5909, 5940, 6098, 6109, 6313, 6457, 6458, 6459, 6679, 6680,\n  6752, 6773, 6774, 6775, 6776, 6777, 6778, 6779, 6780, 6783, 6832, 6833,\n  6834, 6835, 6836, 6837, 6838, 6839, 6840, 6841, 6842, 6843, 6844, 6845,\n  6847, 6848, 6849, 6850, 6851, 6852, 6853, 6854, 6855, 6856, 6857, 6858,\n  6859, 6860, 6861, 6862, 6964, 6980, 7019, 7020, 7021, 7022, 7023, 7024,\n  7025, 7026, 7027, 7082, 7083, 7142, 7154, 7155, 7223, 7376, 7377, 7378,\n  7380, 7381, 7382, 7383, 7384, 7385, 7386, 7387, 7388, 7389, 7390, 7391,\n  7392, 7394, 7395, 7396, 7397, 7398, 7399, 7400, 7405, 7412, 7416, 7417,\n  7616, 7617, 7618, 7619, 7620, 7621, 7622, 7623, 7624, 7625, 7626, 7627,\n  7628, 7629, 7630, 7631, 7632, 7633, 7634, 7635, 7636, 7637, 7638, 7639,\n  7640, 7641, 7642, 7643, 7644, 7645, 7646, 7647, 7648, 7649, 7650, 7651,\n  7652, 7653, 7654, 7655, 7656, 7657, 7658, 7659, 7660, 7661, 7662, 7663,\n  7664, 7665, 7666, 7667, 7668, 7669, 7670, 7671, 7672, 7673, 7674, 7675,\n  7676, 7677, 7678, 7679, 8400, 8401, 8402, 8403, 8404, 8405, 8406, 8407,\n  8408, 8409, 8410, 8411, 8412, 8417, 8421, 8422, 8423, 8424, 8425, 8426,\n  8427, 8428, 8429, 8430, 8431, 8432, 11503, 11504, 11505, 11647, 11744, 11745,\n  11746, 11747, 11748, 11749, 11750, 11751, 11752, 11753, 11754, 11755, 11756, 11757,\n  11758, 11759, 11760, 11761, 11762, 11763, 11764, 11765, 11766, 11767, 11768, 11769,\n  11770, 11771, 11772, 11773, 11774, 11775, 12330, 12331, 12332, 12333, 12334, 12335,\n  12441, 12442, 42607, 42612, 42613, 42614, 42615, 42616, 42617, 42618, 42619, 42620,\n  42621, 42654, 42655, 42736, 42737, 43014, 43052, 43204, 43232, 43233, 43234, 43235,\n  43236, 43237, 43238, 43239, 43240, 43241, 43242, 43243, 43244, 43245, 43246, 43247,\n  43248, 43249, 43307, 43308, 43309, 43347, 43443, 43456, 43696, 43698, 43699, 43700,\n  43703, 43704, 43710, 43711, 43713, 43766, 44013, 64286, 65056, 65057, 65058, 65059,\n  65060, 65061, 65062, 65063, 65064, 65065, 65066, 65067, 65068, 65069, 65070, 65071,\n  66045, 66272, 66422, 66423, 66424, 66425, 66426, 68109, 68111, 68152, 68153, 68154,\n  68159, 68325, 68326, 68900, 68901, 68902, 68903, 68969, 68970, 68971, 68972, 68973,\n  69291, 69292, 69373, 69374, 69375, 69446, 69447, 69448, 69449, 69450, 69451, 69452,\n  69453, 69454, 69455, 69456, 69506, 69507, 69508, 69509, 69702, 69744, 69759, 69817,\n  69818, 69888, 69889, 69890, 69939, 69940, 70003, 70080, 70090, 70197, 70198, 70377,\n  70378, 70459, 70460, 70477, 70502, 70503, 70504, 70505, 70506, 70507, 70508, 70512,\n  70513, 70514, 70515, 70516, 70606, 70607, 70608, 70722, 70726, 70750, 70850, 70851,\n  71103, 71104, 71231, 71350, 71351, 71467, 71737, 71738, 71997, 71998, 72003, 72160,\n  72244, 72263, 72345, 72767, 73026, 73028, 73029, 73111, 73537, 73538, 90415, 92912,\n  92913, 92914, 92915, 92916, 92976, 92977, 92978, 92979, 92980, 92981, 92982, 94192,\n  94193, 113822, 119141, 119142, 119143, 119144, 119145, 119149, 119150, 119151, 119152, 119153,\n  119154, 119163, 119164, 119165, 119166, 119167, 119168, 119169, 119170, 119173, 119174, 119175,\n  119176, 119177, 119178, 119179, 119210, 119211, 119212, 119213, 119362, 119363, 119364, 122880,\n  122881, 122882, 122883, 122884, 122885, 122886, 122888, 122889, 122890, 122891, 122892, 122893,\n  122894, 122895, 122896, 122897, 122898, 122899, 122900, 122901, 122902, 122903, 122904, 122907,\n  122908, 122909, 122910, 122911, 122912, 122913, 122915, 122916, 122918, 122919, 122920, 122921,\n  122922, 123023, 123184, 123185, 123186, 123187, 123188, 123189, 123190, 123566, 123628, 123629,\n  123630, 123631, 124140, 124141, 124142, 124143, 124398, 124399, 125136, 125137, 125138, 125139,\n  125140, 125141, 125142, 125252, 125253, 125254, 125255, 125256, 125257, 125258,\n]\n\nexport let CANONICAL_COMBINING_CLASS_VALUES: Array<int> = [\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 232, 220, 220,\n  220, 220, 232, 216, 220, 220, 220, 220, 220, 202, 202, 220,\n  220, 220, 220, 202, 202, 220, 220, 220, 220, 220, 220, 220,\n  220, 220, 220, 220, 1, 1, 1, 1, 1, 220, 220, 220,\n  220, 230, 230, 230, 230, 230, 230, 230, 230, 240, 230, 220,\n  220, 220, 230, 230, 230, 220, 220, 230, 230, 230, 220, 220,\n  220, 220, 230, 232, 220, 220, 230, 233, 234, 234, 233, 234,\n  234, 233, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 220, 230, 230, 230,\n  230, 220, 230, 230, 230, 222, 220, 230, 230, 230, 230, 230,\n  230, 220, 220, 220, 220, 220, 220, 230, 230, 220, 230, 230,\n  222, 228, 230, 10, 11, 12, 13, 14, 15, 16, 17, 18,\n  19, 19, 20, 21, 22, 23, 24, 25, 230, 220, 18, 230,\n  230, 230, 230, 230, 230, 230, 230, 30, 31, 32, 27, 28,\n  29, 30, 31, 32, 33, 34, 230, 230, 220, 220, 230, 230,\n  230, 230, 230, 220, 230, 230, 220, 35, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 220, 230, 230, 230, 220,\n  230, 230, 220, 36, 230, 220, 230, 230, 220, 230, 230, 220,\n  220, 220, 230, 220, 220, 230, 220, 230, 230, 230, 220, 230,\n  220, 230, 220, 230, 220, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 220, 230, 220, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 220, 220, 220, 230, 230, 220, 220, 220, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 220, 220, 220, 220, 220,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 220, 230, 230, 220, 230, 230, 220, 230, 230, 230,\n  220, 220, 220, 27, 28, 29, 230, 230, 230, 220, 230, 230,\n  220, 220, 230, 230, 230, 230, 230, 7, 9, 230, 220, 230,\n  230, 7, 9, 230, 7, 9, 7, 9, 7, 9, 9, 7,\n  9, 84, 91, 7, 9, 9, 9, 9, 9, 103, 103, 9,\n  107, 107, 107, 107, 118, 118, 9, 122, 122, 122, 122, 220,\n  220, 220, 220, 216, 129, 130, 132, 130, 130, 130, 130, 130,\n  230, 230, 9, 230, 230, 220, 7, 9, 9, 220, 230, 230,\n  230, 9, 9, 9, 9, 230, 228, 222, 230, 220, 230, 220,\n  9, 230, 230, 230, 230, 230, 230, 230, 230, 220, 230, 230,\n  230, 230, 230, 220, 220, 220, 220, 220, 220, 230, 230, 220,\n  220, 220, 230, 230, 220, 220, 230, 230, 230, 230, 230, 220,\n  230, 230, 230, 230, 7, 9, 230, 220, 230, 230, 230, 230,\n  230, 230, 230, 9, 9, 7, 9, 9, 7, 230, 230, 230,\n  1, 220, 220, 220, 220, 220, 230, 230, 220, 220, 220, 220,\n  230, 1, 1, 1, 1, 1, 1, 1, 220, 230, 230, 230,\n  230, 230, 220, 230, 230, 230, 230, 230, 230, 230, 220, 230,\n  230, 234, 214, 220, 202, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 232, 228, 228, 220, 218, 230,\n  233, 220, 230, 220, 230, 230, 1, 1, 230, 230, 230, 230,\n  1, 1, 1, 230, 230, 230, 1, 1, 230, 220, 230, 1,\n  1, 220, 220, 220, 220, 230, 230, 230, 230, 9, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 218, 228, 232, 222, 224, 224,\n  8, 8, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 9, 9, 9, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 220, 220, 220, 9, 7, 9, 230, 230, 230, 220,\n  230, 230, 230, 230, 230, 9, 9, 26, 230, 230, 230, 230,\n  230, 230, 230, 220, 220, 220, 220, 220, 220, 220, 230, 230,\n  220, 220, 230, 230, 230, 230, 230, 220, 230, 230, 1, 220,\n  9, 230, 220, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 220, 220, 220, 220, 220, 230, 230, 230, 220, 230,\n  220, 220, 220, 220, 230, 220, 230, 220, 9, 9, 9, 9,\n  7, 230, 230, 230, 9, 9, 7, 9, 7, 9, 7, 7,\n  9, 7, 7, 9, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 9, 9, 9, 9, 7, 230, 9, 7,\n  9, 7, 9, 9, 7, 9, 9, 7, 9, 9, 7, 9,\n  9, 9, 9, 9, 7, 9, 9, 9, 9, 9, 9, 1,\n  1, 1, 1, 1, 230, 230, 230, 230, 230, 230, 230, 6,\n  6, 1, 216, 216, 1, 1, 1, 226, 216, 216, 216, 216,\n  216, 220, 220, 220, 220, 220, 220, 220, 220, 230, 230, 230,\n  230, 230, 220, 220, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,\n  230, 230, 232, 232, 220, 230, 230, 220, 220, 220, 220, 220,\n  220, 220, 220, 230, 230, 230, 230, 230, 230, 7,\n]\n",
      "sourceSha256": "16293a12c70d71705abbf76523c0667497c52a4f30360a794e2e80995aceae3c"
    }
  ],
  "bundleSha256": "fda288f89d72c0eb95cbe9e9c1db44406bbb5f8790414bf85f2686448ff6248c",
  "publication": {
    "notices": "SOURCE-NOTICES.txt",
    "statusEn": "Compiler sources from the Topaz 5.21.0 release. Compatibility code for earlier language modes is retained.",
    "statusKo": "토파즈 5.21.0 출하 컴파일러 소스다. 이전 언어 모드의 호환 코드는 유지한다.",
    "editing": "Reviewed comments may be edited for publication. sourceSha256 identifies the upstream file. sha256 identifies the published file. Executable code is unchanged."
  }
}
