@chenglou/freerange 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenglou/freerange",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Static numeric range analysis for TypeScript",
   "license": "MIT",
   "repository": {

package/src/audit.ts

@@ -286,7 +286,7 @@ export function createFileAudit({program, analysis}: {program: ProgramIR; analys
 
 function formatAuditCoverage(coverage: AuditCoverage): string {
   const parts = coverage.functions === 0
-    ? ['no named function declarations']
+    ? ['no named top-level functions']
     : [`${coverage.analyzed}/${coverage.functions} functions fully analyzed`]
   if (coverage.partial > 0) parts.push(`${coverage.partial} partially supported`)
   if (coverage.unsupported > 0) parts.push(`${coverage.unsupported} unsupported`)
@@ -405,6 +405,7 @@ function guidesForUnsupportedReason(reason: UnsupportedReason): RefactorGuideID[
     case 'unknownIdentifier':
     case 'missingSymbol':
     case 'functionWithoutSignature':
+    case 'constFunctionSignature':
     case 'functionWithoutBody':
     case 'destructuredParameter':
     case 'parameterType':
@@ -414,10 +415,8 @@ function guidesForUnsupportedReason(reason: UnsupportedReason): RefactorGuideID[
     case 'computedPropertyName':
     case 'objectSpread':
     case 'asyncOrGeneratorFunction':
-    case 'typePredicate':
     case 'protoProperty':
     case 'enumMemberRead':
-    case 'prototypeMemberRead':
     case 'binaryOperator':
     case 'callWithFewerArguments':
     case 'callWithMoreArguments':

package/src/domain/value-identity.ts

@@ -0,0 +1,56 @@
+import type {ValueID} from '../ir/ids.ts'
+
+export type ValueIdentityOwner = {
+  kind: 'valueIdentityOwner'
+  parent: ValueIdentityOwner | null
+}
+
+export type ValueIdentity =
+  | {kind: 'local'; owner: ValueIdentityOwner; value: ValueID}
+  | {kind: 'property'; object: ValueIdentity; property: string}
+  | {kind: 'arrayIndex'; array: ValueIdentity; index: ValueIdentity}
+
+export function createValueIdentityOwner(
+  parent: ValueIdentityOwner | null = null,
+): ValueIdentityOwner {
+  return {kind: 'valueIdentityOwner', parent}
+}
+
+export function sameValueIdentity(left: ValueIdentity, right: ValueIdentity): boolean {
+  if (left === right) return true
+  if (left.kind !== right.kind) return false
+  switch (left.kind) {
+    case 'local':
+      return right.kind === 'local'
+        && left.owner === right.owner
+        && left.value === right.value
+    case 'property':
+      return right.kind === 'property'
+        && left.property === right.property
+        && sameValueIdentity(left.object, right.object)
+    case 'arrayIndex':
+      return right.kind === 'arrayIndex'
+        && sameValueIdentity(left.array, right.array)
+        && sameValueIdentity(left.index, right.index)
+  }
+}
+
+export function valueIdentityUsesOwner(
+  identity: ValueIdentity,
+  owner: ValueIdentityOwner,
+): boolean {
+  switch (identity.kind) {
+    case 'local': {
+      let current: ValueIdentityOwner | null = identity.owner
+      while (current != null) {
+        if (current === owner) return true
+        current = current.parent
+      }
+      return false
+    }
+    case 'property': return valueIdentityUsesOwner(identity.object, owner)
+    case 'arrayIndex':
+      return valueIdentityUsesOwner(identity.array, owner)
+        || valueIdentityUsesOwner(identity.index, owner)
+  }
+}

package/src/engine/analyze.ts

@@ -1,11 +1,17 @@
 import {constantNumber} from '../domain/number.ts'
 import {joinValues, type AbstractValue} from '../domain/value.ts'
+import type {ValueIdentity, ValueIdentityOwner} from '../domain/value-identity.ts'
 import type {BlockID, FunctionID, ModuleBindingID, SiteID} from '../ir/ids.ts'
 import {functionUsage, transitiveModuleBindings} from '../ir/function-usage.ts'
 import {finiteInputExpression, finiteInputs} from '../ir/finite-inputs.ts'
 import type {EdgeIR} from '../ir/instructions.ts'
 import {declaredKindOf, declaredKindValue, holdsMutableStructure, type FunctionIR, type ProgramIR} from '../ir/program.ts'
-import {addPrecondition, constantRequirementStatus, createExpressionContext, staticRequirement} from '../requirements/infer.ts'
+import {
+  addPrecondition,
+  constantRequirementStatus,
+  createExpressionContext,
+  staticRequirement,
+} from '../requirements/infer.ts'
 import type {BoundsAssumption, InferredPrecondition, NumericExpression} from '../requirements/model.ts'
 import {
   completedEvaluation,
@@ -63,7 +69,6 @@ export function analyzeProgram(program: ProgramIR): ProgramAnalysis {
     initializerState,
     program,
     [],
-    {identityNamespace: 'module/'},
   )
   const moduleValues = publishedModuleValues(program, initializer.run, initializer.evaluation)
   const functionEntrySharedState = seedModuleSlots(program, moduleValues)
@@ -98,7 +103,6 @@ export function analyzeProgram(program: ProgramIR): ProgramAnalysis {
       [],
       {
         boundsAssumptions: moduleReads[functionID]!.size > 0 ? initializerBounds : [],
-        identityNamespace: `function:${functionID}/`,
       },
     )
     functions.push(publishedAnalysis(fn, evaluation))
@@ -252,10 +256,13 @@ function publishedModuleValues(
     && program.functions.every(lowered => lowered.kind === 'lowered')
 
   return program.moduleBindings.map((binding, index) => {
-    if (binding.category.kind !== 'value' || demoted.has(index)) return null
+    if ((binding.category.kind !== 'value' && binding.category.kind !== 'function')
+      || demoted.has(index)) return null
     // holdsMutableStructure, not a top-level tag check: a `number[] | null` binding is
     // nullish at the top level yet the array inside is exactly as alias-mutable.
-    if (holdsMutableStructure(binding.category.declaredKind) && !fullyAnalyzed) return null
+    if (binding.category.kind === 'value'
+      && holdsMutableStructure(binding.category.declaredKind)
+      && !fullyAnalyzed) return null
     const slot = end?.[index]
     return slot ?? null
   })
@@ -307,8 +314,8 @@ type EvaluationRun = {
 type EvaluationSeed = {
   boundsAssumptions?: BoundsAssumption[]
   valueFacts?: ValueFact[]
-  parameterIdentityKeys?: string[]
-  identityNamespace?: string
+  parameterIdentities?: ValueIdentity[]
+  identityOwner?: ValueIdentityOwner
 }
 
 function runEvaluation(
@@ -334,8 +341,8 @@ function runEvaluation(
   const expressionContext = createExpressionContext(
     fn,
     argumentExpressions,
-    seed.parameterIdentityKeys,
-    seed.identityNamespace ?? fn.name,
+    seed.parameterIdentities,
+    seed.identityOwner,
   )
   const preconditions: InferredPrecondition[] = []
   const boundsAssumptions: BoundsAssumption[] = [...(seed.boundsAssumptions ?? [])]
@@ -365,8 +372,8 @@ function runEvaluation(
       calleeState: SharedState,
       stack: FunctionID[],
       valueFacts: ValueFact[],
-      parameterIdentityKeys: string[],
-      identityNamespace: string,
+      parameterIdentities: ValueIdentity[],
+      identityOwner: ValueIdentityOwner,
     ) => {
       const calleeFn = program.functions[callee]
       if (calleeFn == null) throw new Error(`Unknown function ${callee}`)
@@ -380,7 +387,7 @@ function runEvaluation(
         calleeState,
         program,
         stack,
-        {valueFacts, parameterIdentityKeys, identityNamespace},
+        {valueFacts, parameterIdentities, identityOwner},
       ).evaluation
     },
   }

package/src/engine/state.ts

@@ -1,5 +1,9 @@
 import type {AbstractValue} from '../domain/value.ts'
 import {joinValues, sameValues, widenValue} from '../domain/value.ts'
+import {
+  sameValueIdentity,
+  type ValueIdentity,
+} from '../domain/value-identity.ts'
 
 // Indexed by ModuleBindingID, fixed length per program. Flows through calls, so a
 // callee's module writes are visible to the caller after a completed call. Null means the
@@ -17,24 +21,28 @@ export type ExecutionState = {
 }
 
 export type ValueFact =
-  | {kind: 'nonzero'; value: string}
+  | {kind: 'nonzero'; value: ValueIdentity}
   // The strict `index < array.length` half of a bounds guard. The index's own abstract
   // number must still prove integer, non-NaN, and nonnegative.
-  | {kind: 'belowLength'; index: string; array: string}
+  | {kind: 'belowLength'; index: ValueIdentity; array: ValueIdentity}
   // A requirement or assumption for an asserted read proves the complete condition.
-  | {kind: 'validIndex'; index: string; array: string}
+  | {kind: 'validIndex'; index: ValueIdentity; array: ValueIdentity}
 
-export function hasNonzeroFact(facts: ValueFact[], value: string): boolean {
-  return facts.some(fact => fact.kind === 'nonzero' && fact.value === value)
+export function hasNonzeroFact(facts: ValueFact[], value: ValueIdentity): boolean {
+  return facts.some(fact =>
+    fact.kind === 'nonzero' && sameValueIdentity(fact.value, value))
 }
 
 export function hasIndexFact(
   facts: ValueFact[],
   kind: 'belowLength' | 'validIndex',
-  index: string,
-  array: string,
+  index: ValueIdentity,
+  array: ValueIdentity,
 ): boolean {
-  return facts.some(fact => fact.kind === kind && fact.index === index && fact.array === array)
+  return facts.some(fact =>
+    fact.kind === kind
+    && sameValueIdentity(fact.index, index)
+    && sameValueIdentity(fact.array, array))
 }
 
 export function addValueFact(facts: ValueFact[], candidate: ValueFact): void {
@@ -55,15 +63,19 @@ export function intersectValueFacts(left: ValueFact[], right: ValueFact[]): Valu
 function intersectValueFact(left: ValueFact, right: ValueFact): ValueFact | null {
   if (sameValueFact(left, right)) return left
   if (left.kind === 'nonzero' || right.kind === 'nonzero') return null
-  if (left.index !== right.index || left.array !== right.array) return null
+  if (!sameValueIdentity(left.index, right.index)
+    || !sameValueIdentity(left.array, right.array)) return null
   return {kind: 'belowLength', index: left.index, array: left.array}
 }
 
 function sameValueFact(left: ValueFact, right: ValueFact): boolean {
   if (left.kind !== right.kind) return false
-  if (left.kind === 'nonzero' && right.kind === 'nonzero') return left.value === right.value
+  if (left.kind === 'nonzero' && right.kind === 'nonzero') {
+    return sameValueIdentity(left.value, right.value)
+  }
   if (left.kind === 'nonzero' || right.kind === 'nonzero') return false
-  return left.index === right.index && left.array === right.array
+  return sameValueIdentity(left.index, right.index)
+    && sameValueIdentity(left.array, right.array)
 }
 
 export function emptySharedState(moduleCount: number): SharedState {

package/src/engine/transfer.ts

@@ -34,14 +34,21 @@ import {
   type AbstractValue,
   type TaggedVariant,
 } from '../domain/value.ts'
+import {
+  createValueIdentityOwner,
+  sameValueIdentity,
+  valueIdentityUsesOwner,
+  type ValueIdentity,
+  type ValueIdentityOwner,
+} from '../domain/value-identity.ts'
 import type {FunctionID, SiteID, ValueID} from '../ir/ids.ts'
 import type {ComparisonOperator, InstructionIR} from '../ir/instructions.ts'
 import {coveringKindValue, declaredKindOf, type DeclaredKind, type ProgramIR} from '../ir/program.ts'
 import {
   addPrecondition,
+  canonicalValueIdentity,
   constantRequirementStatus,
   peelNonzero,
-  canonicalValueKey,
   numericExpression,
   resolveStoredValue,
   sameRuntimeValue,
@@ -67,8 +74,8 @@ type EvaluateFunction = (
   sharedState: SharedState,
   callStack: FunctionID[],
   valueFacts: ValueFact[],
-  parameterIdentityKeys: string[],
-  identityNamespace: string,
+  parameterIdentities: ValueIdentity[],
+  identityOwner: ValueIdentityOwner,
 ) => FunctionEvaluation
 
 export type TransferContext = {
@@ -210,16 +217,32 @@ function evaluateInstructionKinded(
         ? tupleElement(sequence, index)
         : sequence.element
       const length = sequence.kind === 'tuple' ? constantNumber(sequence.elements.length) : sequence.length
-      const indexKey = canonicalValueKey(instruction.index, context.expressionContext)
-      const arrayKey = canonicalValueKey(instruction.array, context.expressionContext)
-      const assumedValid = hasIndexFact(state.valueFacts, 'validIndex', indexKey, arrayKey)
+      const indexIdentity = canonicalValueIdentity(
+        instruction.index,
+        context.expressionContext,
+      )
+      const arrayIdentity = canonicalValueIdentity(
+        instruction.array,
+        context.expressionContext,
+      )
+      const assumedValid = hasIndexFact(
+        state.valueFacts,
+        'validIndex',
+        indexIdentity,
+        arrayIdentity,
+      )
       // Three proofs of in-bounds: a complete prior requirement, intervals, or the strict
       // below-length half from a guard combined with the index's own integer/nonnegative
       // facts. A for-of loop reaches the same third proof through its generated guard.
       const inBounds = assumedValid
         || (index.integer && !index.mayBeNaN && index.lower >= 0 && index.upper < length.lower)
         || (index.integer && !index.mayBeNaN && index.lower >= 0
-          && hasIndexFact(state.valueFacts, 'belowLength', indexKey, arrayKey))
+          && hasIndexFact(
+            state.valueFacts,
+            'belowLength',
+            indexIdentity,
+            arrayIdentity,
+          ))
       // A provably out-of-bounds read: for the asserted form the assertion lied; for the
       // bare form the value is exactly undefined. An empty sequence is the special case
       // where every read is out of bounds.
@@ -263,7 +286,11 @@ function evaluateInstructionKinded(
           state, instruction.index, validIndexNumber(index),
           context.expressionContext.instructionByValue,
         )
-        addValueFact(state.valueFacts, {kind: 'validIndex', index: indexKey, array: arrayKey})
+        addValueFact(state.valueFacts, {
+          kind: 'validIndex',
+          index: indexIdentity,
+          array: arrayIdentity,
+        })
       }
       return passthroughValue(element)
     }
@@ -330,9 +357,9 @@ function evaluateInstructionKinded(
       // An opaque binding's declared type spans value kinds (e.g. `unknown`), so two paths
       // could put a number and a boolean in one slot and meet at a join, which only handles
       // matching kinds. Reads of opaque bindings stop regardless, so the slot stays
-      // uninitialized instead of holding a value nothing may consume. Every other writable
-      // category is single-kind: value/kind writes are type-checked against the declared
-      // number, boolean, or record shape.
+      // uninitialized instead of holding a value nothing may consume. Every other value
+      // category is single-kind; a function binding stores only the internal marker that
+      // its top-level initializer has run.
       if (binding.category.kind !== 'opaque') {
         state.shared[instruction.binding] = assigned
       }
@@ -525,6 +552,15 @@ function evaluateInstructionKinded(
       return computedNumber(maximumNumbers(operands), operands, instruction.site)
     }
     case 'call': {
+      if (instruction.binding != null && state.shared[instruction.binding] == null) {
+        return {
+          kind: 'stop',
+          stop: {
+            site: instruction.site,
+            reason: {kind: 'moduleRead', binding: instruction.binding},
+          },
+        }
+      }
       const callee = context.program.functions[instruction.function]
       if (callee == null) throw new Error(`Unknown function ${instruction.function}`)
       if (callee.kind === 'unsupported') {
@@ -535,11 +571,14 @@ function evaluateInstructionKinded(
       }
       const arguments_ = instruction.arguments.map(id => requiredValue(state, id))
       const argumentExpressions = instruction.arguments.map(id => numericExpression(id, context.expressionContext))
-      // Parameters use their caller arguments' identity keys. The same small fact list
+      // Parameters use their caller arguments' identities. The same small fact list
       // therefore works inside the callee and comes back after every normal return, so a
       // requirement established by a completed helper call applies below that call.
-      const argumentKeys = instruction.arguments.map(id => canonicalValueKey(id, context.expressionContext))
-      const calleeNamespace = `${context.expressionContext.identityNamespace}call:${instruction.function}:${instruction.site}/`
+      const argumentIdentities = instruction.arguments.map(id =>
+        canonicalValueIdentity(id, context.expressionContext))
+      const calleeOwner = createValueIdentityOwner(
+        context.expressionContext.identityOwner,
+      )
       const evaluation = context.evaluateFunction(
         instruction.function,
         arguments_,
@@ -547,8 +586,8 @@ function evaluateInstructionKinded(
         state.shared,
         context.callStack,
         state.valueFacts,
-        argumentKeys,
-        calleeNamespace,
+        argumentIdentities,
+        calleeOwner,
       )
       // A partial callee's result is discarded wholesale: the callee ran on a clone, and
       // state.shared is assigned only on the complete path below, so a partial callee's
@@ -576,7 +615,7 @@ function evaluateInstructionKinded(
       }
       state.shared = completed.sharedState
       state.valueFacts = completed.valueFacts.filter(fact =>
-        !valueFactUsesNamespace(fact, calleeNamespace))
+        !valueFactUsesOwner(fact, calleeOwner))
       for (let index = 0; index < callee.parameters.length; index++) {
         refineFiniteCallArgument(
           state,
@@ -664,10 +703,13 @@ export function addBoundsAssumption(assumptions: BoundsAssumption[], candidate:
   }
 }
 
-function valueFactUsesNamespace(fact: ValueFact, namespace: string): boolean {
-  const marker = `v:${namespace}`
-  if (fact.kind === 'nonzero') return fact.value.includes(marker)
-  return fact.index.includes(marker) || fact.array.includes(marker)
+function valueFactUsesOwner(
+  fact: ValueFact,
+  owner: ValueIdentityOwner,
+): boolean {
+  if (fact.kind === 'nonzero') return valueIdentityUsesOwner(fact.value, owner)
+  return valueIdentityUsesOwner(fact.index, owner)
+    || valueIdentityUsesOwner(fact.array, owner)
 }
 
 function sentinelsAdmit(sentinels: 'null' | 'undefined' | 'both', sentinel: 'null' | 'undefined'): boolean {
@@ -1114,8 +1156,8 @@ function refineComparison(
     if (rightProducer?.kind === 'arrayLength') {
       addValueFact(result.valueFacts, {
         kind: 'belowLength',
-        index: canonicalValueKey(comparison.left, expressionContext),
-        array: canonicalValueKey(rightProducer.array, expressionContext),
+        index: canonicalValueIdentity(comparison.left, expressionContext),
+        array: canonicalValueIdentity(rightProducer.array, expressionContext),
       })
     }
   }
@@ -1124,8 +1166,8 @@ function refineComparison(
     if (leftProducer?.kind === 'arrayLength') {
       addValueFact(result.valueFacts, {
         kind: 'belowLength',
-        index: canonicalValueKey(comparison.right, expressionContext),
-        array: canonicalValueKey(leftProducer.array, expressionContext),
+        index: canonicalValueIdentity(comparison.right, expressionContext),
+        array: canonicalValueIdentity(leftProducer.array, expressionContext),
       })
     }
   }
@@ -1212,11 +1254,15 @@ function numberWithFacts(
   const held = state.values[id]
   if (held?.kind !== 'number') return null
   let result = held
-  const key = canonicalValueKey(id, expressionContext)
-  if (state.valueFacts.some(fact => fact.kind === 'validIndex' && fact.index === key)) {
+  const identity = canonicalValueIdentity(id, expressionContext)
+  if (state.valueFacts.some(fact =>
+    fact.kind === 'validIndex'
+    && sameValueIdentity(fact.index, identity))) {
     result = validIndexNumber(result)
   }
-  if (hasNonzeroFact(state.valueFacts, key)) result = excludePointFrom(result, constantNumber(0))
+  if (hasNonzeroFact(state.valueFacts, identity)) {
+    result = excludePointFrom(result, constantNumber(0))
+  }
   return result
 }
 
@@ -1245,7 +1291,10 @@ function recordNonzeroValueFact(
   value: ValueID,
   expressionContext: ExpressionContext,
 ): void {
-  addValueFact(state.valueFacts, {kind: 'nonzero', value: canonicalValueKey(value, expressionContext)})
+  addValueFact(state.valueFacts, {
+    kind: 'nonzero',
+    value: canonicalValueIdentity(value, expressionContext),
+  })
 }
 
 export function requiredBoolean(state: ExecutionState, id: ValueID): AbstractBoolean {

package/src/ir/instructions.ts

@@ -94,7 +94,13 @@ export type InstructionIR =
   | (InstructionBase & {kind: 'staticRequire'; value: ValueID; purpose?: 'finiteInput'})
   | (InstructionBase & {kind: 'staticAssert'; value: ValueID; assertion: number})
   | (InstructionBase & {kind: 'minimum' | 'maximum'; values: ValueID[]})
-  | (InstructionBase & {kind: 'call'; function: FunctionID; arguments: ValueID[]})
+  | (InstructionBase & {
+      kind: 'call'
+      function: FunctionID
+      arguments: ValueID[]
+      // A const-bound function is unavailable until its top-level initializer runs.
+      binding: ModuleBindingID | null
+    })
   // tag is set when the literal's contextual type is a tagged union and the literal names
   // its tag with a string literal — the engine then builds a single-variant union, so
   // branches building different variants join per tag instead of dropping properties.

package/src/ir/program.ts

@@ -74,6 +74,9 @@ export type UnsupportedReason =
   // user source is a shaky boundary, so the case is recorded rather than crashed on.
   | {kind: 'missingSymbol'}
   | {kind: 'functionWithoutSignature'}
+  // A const-bound function's public type is overloaded, has a rest/this parameter, or has
+  // a different parameter count from the arrow or function expression.
+  | {kind: 'constFunctionSignature'}
   // Overload signatures and ambient declarations have no body to lower.
   | {kind: 'functionWithoutBody'}
   | {kind: 'destructuredParameter'}
@@ -94,11 +97,8 @@ export type UnsupportedReason =
   | {kind: 'computedPropertyName'}
   | {kind: 'objectSpread'}
   | {kind: 'asyncOrGeneratorFunction'}
-  | {kind: 'typePredicate'}
   | {kind: 'protoProperty'}
   | {kind: 'enumMemberRead'}
-  // point.toString and friends: a prototype member the record value cannot answer.
-  | {kind: 'prototypeMemberRead'; property: string}
   // e.g. '**', '>>', 'instanceof' in value position — the operators arithmetic and
   // comparison lowering do not claim ('%' and '??' lower now and no longer land here)
   | {kind: 'binaryOperator'; operator: string}
@@ -234,6 +234,9 @@ export type ModuleBindingCategory =
   // literal is trusted exactly, without analyzing the exporting module; the soundness
   // argument sits on importedCategory in src/lower/module.ts.
   | {kind: 'importedConstant'; value: number}
+  // A directly assigned const arrow or function expression. Its slot carries only whether
+  // module initialization has reached the declaration; calls use the FunctionIR itself.
+  | {kind: 'function'}
   // Every other declared type (unions with null, arrays, strings, functions, records with
   // optional or unrepresentable properties). Reads stop.
   | {kind: 'opaque'}
@@ -249,6 +252,7 @@ export function declaredKindOf(category: ModuleBindingCategory): DeclaredKind |
     // An imported constant needs no declared-kind hedge: its slot is always seeded with
     // the exact literal, so no assumes line and no havoc reset value apply.
     case 'importedConstant':
+    case 'function':
     case 'import':
     case 'opaque':
       return null

package/src/lower/accept.ts

@@ -6,10 +6,14 @@ import {unsupported} from './context.ts'
 // immutable after construction) and `var` — checked before lowering ever sees the code.
 // (`any`-typed values and type assertions used to be rejected here too; both are carried
 // claim-free now — see valueKind's opaque arm and unwrap's assertion peeling.) Called once
-// per function declaration and once per top-level statement of the module initializer; a
+// per analyzed top-level function and once per top-level statement of the module initializer; a
 // violation throws LoweringStop and is caught like any other rejection.
-export function assertAccepted(root: ts.Node): void {
+export function assertAccepted(root: ts.Node, deferFunctionBodies: boolean = false): void {
   const visit = (node: ts.Node): void => {
+    // Creating a nested function does not execute its body. The function gets its own
+    // acceptance check if it is a supported top-level unit; all other function values are
+    // rejected later where the surrounding lowering encounters them.
+    if (deferFunctionBodies && node !== root && ts.isFunctionLike(node)) return
     // Type annotations hold no runtime values, so there is nothing to check inside them.
     if (ts.isTypeNode(node)) return
     // JSX never lowers (the expression catch-all names it), but its tag names and

package/src/lower/context.ts

@@ -9,6 +9,7 @@ import type {
 import type {InstructionIR, TerminatorIR} from '../ir/instructions.ts'
 import {nodeSpan, type BlockIR, type FunctionIR, type SourceSpan, type UnsupportedReason} from '../ir/program.ts'
 import type {StaticAnnotation} from './static-intrinsics.ts'
+import type {TopLevelFunctionUnit} from './function-unit.ts'
 
 export type MutableBlock = {
   loopHeader: SiteID | null
@@ -17,17 +18,20 @@ export type MutableBlock = {
   terminator: TerminatorIR | null
 }
 
-// A top-level function declaration and its index in ProgramIR.functions. The call arm
-// keeps the declaration so omitted optional and literal-defaulted arguments can be filled
-// before emitting the fixed-arity call instruction.
-export type TopLevelFunction = {
+// A top-level function and its index in ProgramIR.functions. The call arm keeps the
+// declaration so omitted optional and literal-defaulted arguments can be filled before
+// emitting the fixed-arity call instruction. binding is present for a const-bound
+// function, whose initializer must run before the function can be called.
+export type TopLevelFunction = TopLevelFunctionUnit & {
   id: FunctionID
-  declaration: ts.FunctionDeclaration
+  binding: ModuleBindingID | null
+  signature: ts.Signature | null
 }
 
 export type FunctionContext = {
   sourceFile: ts.SourceFile
   checker: ts.TypeChecker
+  program: ts.Program
   functionsBySymbol: Map<ts.Symbol, TopLevelFunction>
   moduleBindingsBySymbol: Map<ts.Symbol, ModuleBindingID>
   staticAnnotations: Map<ts.CallExpression, StaticAnnotation>
@@ -40,6 +44,7 @@ export type FunctionContext = {
   bindings: Map<ts.Symbol, ValueID>
   parameters: FunctionIR['parameters']
   assertions: FunctionIR['assertions']
+  returnsVoid: boolean
   // Innermost-last stack of enclosing loops, consulted by `continue`. A continue runs the
   // loop's advance step (a for loop's incrementor, the for-of counter bump; nothing for
   // while), then jumps to the header carrying the loop's carried bindings plus whatever
@@ -56,15 +61,18 @@ export type LoopTarget = {
 export function createFunctionContext(
   sourceFile: ts.SourceFile,
   checker: ts.TypeChecker,
+  program: ts.Program,
   functionsBySymbol: Map<ts.Symbol, TopLevelFunction>,
   moduleBindingsBySymbol: Map<ts.Symbol, ModuleBindingID>,
   sites: SourceSpan[],
   staticAnnotations: StaticAnnotation[] = [],
+  returnsVoid: boolean = true,
 ): FunctionContext {
   const entry: MutableBlock = {loopHeader: null, parameters: [], instructions: [], terminator: null}
   return {
     sourceFile,
     checker,
+    program,
     functionsBySymbol,
     moduleBindingsBySymbol,
     staticAnnotations: new Map(staticAnnotations.map(annotation => [annotation.call, annotation])),
@@ -75,6 +83,7 @@ export function createFunctionContext(
     bindings: new Map(),
     parameters: [],
     assertions: [],
+    returnsVoid,
     loops: [],
   }
 }