@chenglou/freerange 0.0.2 → 0.0.4

package/src/lower/program.ts

@@ -4,18 +4,17 @@ import {moduleInitializerName, nodeSpan, type DeclaredKind, type FunctionIR, typ
 import type {CheckedSource} from '../typescript/check.ts'
 import {assertAccepted, evalMention, typeCheckSuppressionMention} from './accept.ts'
 import {addInstructionAtSite, addSite, createFunctionContext, LoweringStop, requiredSymbol, sealBlocks, terminate, unsupported, type MutableBlock, type TopLevelFunction} from './context.ts'
-import {valueKind} from './expression.ts'
+import {lowerExpression, valueKind} from './expression.ts'
+import {callableSignature, topLevelFunctionUnits} from './function-unit.ts'
 import {parameterDefaultFits, parameterDefaultLiteral, type ParameterDefaultLiteral} from './literals.ts'
 import {declaredKind, lowerModuleInitializer, scanModuleBindings, tupleHasOptionalOrRestPositions, type ModuleScan} from './module.ts'
 import {scanStaticAnnotations, type StaticAnnotation} from './static-intrinsics.ts'
 import {lowerStatements} from './statements.ts'
 
 export function lowerSource(checked: CheckedSource, baseDirectory: string = process.cwd()): ProgramIR {
-  const {sourceFile, checker} = checked
-  const declarations: ts.FunctionDeclaration[] = []
-  for (const statement of sourceFile.statements) {
-    if (ts.isFunctionDeclaration(statement) && statement.name != null) declarations.push(statement)
-  }
+  const {sourceFile, program} = checked
+  const checker = program.getTypeChecker()
+  const declarations = topLevelFunctionUnits(sourceFile)
   const staticScan = scanStaticAnnotations(sourceFile, declarations, checker)
   const recordStaticAnnotationIssues = (sites: SourceSpan[]): ProgramIR['staticAnnotationIssues'] =>
     staticScan.outsideTopLevelFunctions.map(call => {
@@ -34,9 +33,9 @@ export function lowerSource(checked: CheckedSource, baseDirectory: string = proc
       baseDirectory,
       lineStarts: [...sourceFile.getLineStarts()],
       sites,
-      functions: declarations.map((declaration, index) => ({
+      functions: declarations.map((unit, index) => ({
         kind: 'unsupported',
-        name: declaration.name!.text,
+        name: unit.name.text,
         hasStaticAnnotations: staticScan.functions[index]!.length > 0,
         site: 0,
         reason,
@@ -62,39 +61,51 @@ export function lowerSource(checked: CheckedSource, baseDirectory: string = proc
     return rejectFile(nodeSpan(sourceFile, evalNode), {kind: 'evalInFile'})
   }
   const functionsBySymbol = new Map<ts.Symbol, TopLevelFunction>()
+  const scan = scanModuleBindings(sourceFile, checker)
+  const topLevelFunctions: TopLevelFunction[] = []
   for (let index = 0; index < declarations.length; index++) {
-    const declaration = declarations[index]!
+    const unit = declarations[index]!
     // This loop runs outside the per-function catch below, so a missing symbol here is an
     // invariant crash, not a recorded reason: a declaration name that type-checked always
     // has a symbol.
-    const symbol = checker.getSymbolAtLocation(declaration.name!)
-    if (symbol == null) throw new Error(`Function declaration ${declaration.name!.text} has no TypeScript symbol`)
-    functionsBySymbol.set(symbol, {id: index, declaration})
+    const symbol = checker.getSymbolAtLocation(unit.name)
+    if (symbol == null) throw new Error(`Function ${unit.name.text} has no TypeScript symbol`)
+    const binding = scan.bindingsBySymbol.get(symbol)
+    if (unit.initializer != null && binding == null) {
+      throw new Error(`Const-bound function ${unit.name.text} has no module binding`)
+    }
+    const fn: TopLevelFunction = {
+      ...unit,
+      id: index,
+      binding: unit.initializer == null ? null : binding!,
+      signature: callableSignature(unit, checker),
+    }
+    topLevelFunctions.push(fn)
+    functionsBySymbol.set(symbol, fn)
   }
-  const scan = scanModuleBindings(sourceFile, checker)
   const sites: SourceSpan[] = []
   const staticAnnotationIssues = recordStaticAnnotationIssues(sites)
   const functions: FunctionLowering[] = []
-  for (let index = 0; index < declarations.length; index++) {
-    const declaration = declarations[index]!
+  for (let index = 0; index < topLevelFunctions.length; index++) {
+    const declaration = topLevelFunctions[index]!
     const staticAnnotations = staticScan.functions[index]!
     // A failed function lowering discards the half-built FunctionContext wholesale; only
     // the name, annotation presence, offending node's site, and tagged reason survive.
     try {
-      functions.push(lowerFunction(declaration, staticAnnotations, sourceFile, checker, functionsBySymbol, scan, sites))
+      functions.push(lowerFunction(declaration, staticAnnotations, sourceFile, checker, program, functionsBySymbol, scan, sites))
     } catch (error) {
       if (!(error instanceof LoweringStop)) throw error
       sites.push(nodeSpan(sourceFile, error.node))
       functions.push({
         kind: 'unsupported',
-        name: declaration.name!.text,
+        name: declaration.name.text,
         hasStaticAnnotations: staticAnnotations.length > 0,
         site: sites.length - 1,
         reason: error.reason,
       })
     }
   }
-  const {initializer, skips} = lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, sites)
+  const {initializer, skips} = lowerModuleInitializer(sourceFile, checker, program, functionsBySymbol, scan, sites)
   return {
     file: sourceFile.fileName,
     baseDirectory,
@@ -109,14 +120,16 @@ export function lowerSource(checked: CheckedSource, baseDirectory: string = proc
 }
 
 function lowerFunction(
-  declaration: ts.FunctionDeclaration,
+  unit: TopLevelFunction,
   staticAnnotations: StaticAnnotation[],
   sourceFile: ts.SourceFile,
   checker: ts.TypeChecker,
+  program: ts.Program,
   functionsBySymbol: Map<ts.Symbol, TopLevelFunction>,
   scan: ModuleScan,
   sites: SourceSpan[],
 ): FunctionIR {
+  const {declaration} = unit
   for (const annotation of staticAnnotations) {
     if (annotation.kind === 'invalid') {
       throw unsupported(annotation.node, {kind: 'staticAssertionForm', problem: annotation.problem})
@@ -126,18 +139,18 @@ function lowerFunction(
   // An async body returns a Promise and a generator returns an iterator; lowering either
   // as if it ran synchronously would publish the body's values as the caller-visible
   // result. Rejected wholesale.
-  if (declaration.asteriskToken != null || declaration.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) === true) {
+  if ((!ts.isArrowFunction(declaration) && declaration.asteriskToken != null)
+    || declaration.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) === true) {
     throw unsupported(declaration, {kind: 'asyncOrGeneratorFunction'})
   }
   assertAccepted(declaration)
-  const signature = checker.getSignatureFromDeclaration(declaration)
-  // A type predicate (`shape is Circle`, `asserts x`) is the checker taking the author's
-  // word: callers' narrowing then exposes properties the analysis cannot confirm the
-  // value carries. Rejecting the declaring function stops every caller at the call.
-  if (signature != null && checker.getTypePredicateOfSignature(signature) != null) {
-    throw unsupported(declaration, {kind: 'typePredicate'})
+  const signature = unit.signature
+  if (signature == null) {
+    throw unsupported(unit.name, {
+      kind: unit.initializer == null ? 'functionWithoutSignature' : 'constFunctionSignature',
+    })
   }
-  const returnType = functionReturnType(declaration, checker)
+  const returnType = checker.getReturnTypeOfSignature(signature)
   // `never` counts as returning nothing: the idiomatic annotation for an always-throwing
   // helper (`function fail(code: number): never`), whose paths all end in throw — the
   // always-throws analysis and the calleeAlwaysThrows caller stop handle the rest.
@@ -150,20 +163,26 @@ function lowerFunction(
   const context = createFunctionContext(
     sourceFile,
     checker,
+    program,
     functionsBySymbol,
     scan.bindingsBySymbol,
     sites,
     staticAnnotations,
+    returnsVoid,
   )
   const entry = context.currentBlock
-  for (const parameter of declaration.parameters) {
+  for (let parameterIndex = 0; parameterIndex < declaration.parameters.length; parameterIndex++) {
+    const parameter = declaration.parameters[parameterIndex]!
+    const parameterType = unit.initializer == null
+      ? checker.getTypeAtLocation(parameter)
+      : checker.getTypeOfSymbolAtLocation(signature.parameters[parameterIndex]!, signature.declaration!)
     // `function area({width, height}: Size)` lowers as a synthetic record parameter plus
     // one property read per name — the same classification named parameters use, the
     // same reads body destructuring uses. The report metadata below keeps the local
     // names, so a condition says `width` rather than `{width, height}.width`. Defaults
     // and rest inside the pattern stay out, like the body form.
     if (ts.isObjectBindingPattern(parameter.name)) {
-      const type = lowerParameterType(parameter, checker)
+      const type = lowerParameterType(parameter, parameterType, checker)
       // The pattern text becomes the parameter's report name; a pattern the author wrapped
       // across source lines would otherwise break the one-fact-per-line report format
       // (`assumes: {` and orphan fragments — a corpus census caught eight of these).
@@ -201,7 +220,7 @@ function lowerFunction(
     if (parameter.dotDotDotToken != null) {
       throw unsupported(parameter, {kind: 'parameterType', typeText: `...${checker.typeToString(checker.getTypeAtLocation(parameter))}`, optionalOrRestTuple: false})
     }
-    let type = lowerParameterType(parameter, checker)
+    let type = lowerParameterType(parameter, parameterType, checker)
     // A default value applies whenever a caller omits the argument. Literal defaults can
     // be represented exactly and checked against the declared assumptions: `zoom: number
     // = 5` supplies a finite number. Anything else — `= Infinity`, `= readConfig()` —
@@ -218,7 +237,16 @@ function lowerFunction(
     context.parameters.push({value, name: parameter.name.text, type, site: addSite(context, parameter), bindings: null})
   }
   lowerFiniteInputRequirements(context)
-  lowerStatements(declaration.body.statements, context)
+  if (ts.isBlock(declaration.body)) {
+    lowerStatements(declaration.body.statements, context)
+  } else {
+    const value = lowerExpression(declaration.body, context)
+    terminate(context.currentBlock, {
+      kind: 'return',
+      value: returnsVoid ? null : value,
+      site: addSite(context, declaration.body),
+    })
+  }
   if (context.currentBlock.terminator == null) {
     if (!returnsVoid) {
       // A non-void path reaching the end without a return is a per-path STOP, not a
@@ -234,12 +262,12 @@ function lowerFunction(
   }
   return {
     kind: 'lowered',
-    name: declaration.name!.text,
+    name: unit.name.text,
     assertions: context.assertions,
     parameters: context.parameters,
     returnPropertyNames: declaredRecordReturnNames(returnType, checker),
     entry: 0,
-    blocks: sealBlocks(context.blocks, declaration.name!.text),
+    blocks: sealBlocks(context.blocks, unit.name.text),
   }
 }
 
@@ -287,11 +315,14 @@ function declaredRecordReturnNames(returnType: ts.Type, checker: ts.TypeChecker)
   return null
 }
 
-function lowerParameterType(parameter: ts.ParameterDeclaration, checker: ts.TypeChecker): DeclaredKind {
+function lowerParameterType(
+  parameter: ts.ParameterDeclaration,
+  type: ts.Type,
+  checker: ts.TypeChecker,
+): DeclaredKind {
   // The same recursive classification module bindings use: numbers, booleans, records
   // (opaque leaves included — an id: string property is carried, not rejected), nullable
   // wrappers, arrays, tuples, and bare opaque (a plain string parameter).
-  const type = checker.getTypeAtLocation(parameter)
   const declared = declaredKind(type, checker, [])
   if (declared == null) {
     throw unsupported(parameter, {
@@ -302,9 +333,3 @@ function lowerParameterType(parameter: ts.ParameterDeclaration, checker: ts.Type
   }
   return declared
 }
-
-function functionReturnType(declaration: ts.FunctionDeclaration, checker: ts.TypeChecker): ts.Type {
-  const signature = checker.getSignatureFromDeclaration(declaration)
-  if (signature == null) throw unsupported(declaration, {kind: 'functionWithoutSignature'})
-  return checker.getReturnTypeOfSignature(signature)
-}

package/src/lower/statements.ts

@@ -14,7 +14,6 @@ import {
   type MutableBlock,
 } from './context.ts'
 import {taggedUnionTagRead, identifierAssignment, lowerBranchingCondition, lowerExpression, lowerStatementExpression, requireBooleanCondition, valueKind} from './expression.ts'
-import {declaredOnlyInDeclarationFiles} from './platform.ts'
 
 export function lowerStatements(statements: readonly ts.Statement[], context: FunctionContext): void {
   for (const statement of statements) {
@@ -30,17 +29,12 @@ export function lowerStatement(statement: ts.Statement, context: FunctionContext
   }
   if (ts.isReturnStatement(statement)) {
     let value = statement.expression == null ? null : lowerExpression(statement.expression, context)
+    if (context.returnsVoid) value = null
     // A bare `return` in a function that returns a value IS `return undefined` — the
     // common early exit in a `T | undefined` function. In void functions (and the module
     // initializer) the return stays valueless.
-    if (value == null) {
-      const enclosing = ts.findAncestor(statement, ts.isFunctionDeclaration)
-      const signature = enclosing == null ? undefined : context.checker.getSignatureFromDeclaration(enclosing)
-      const returnType = signature == null ? null : context.checker.getReturnTypeOfSignature(signature)
-      const returnsVoid = returnType == null || (returnType.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined)) !== 0
-      if (!returnsVoid) {
-        value = addInstruction(context, statement, {kind: 'nullishConstant', sentinel: 'undefined'})
-      }
+    if (value == null && !context.returnsVoid) {
+      value = addInstruction(context, statement, {kind: 'nullishConstant', sentinel: 'undefined'})
     }
     terminate(context.currentBlock, {kind: 'return', value, site: addSite(context, statement)})
     return
@@ -494,15 +488,8 @@ function lowerVariableDeclarationList(declarations: ts.VariableDeclarationList,
             : null
         if (property == null) throw unsupported(element, {kind: 'variableDeclarationShape'})
         const elementType = context.checker.getTypeAtLocation(element.name)
-        const sourceType = context.checker.getTypeAtLocation(declaration.initializer)
-        const propertySymbol = context.checker.getPropertyOfType(sourceType, property)
-        // Optional properties destructure like any other read now that the filling
-        // invariant guarantees the record value carries them as maybe-undefined (the old
-        // gate here predated the optionals milestone). Prototype members stay out via
-        // the same ownership rule property reads use.
-        if (propertySymbol != null && declaredOnlyInDeclarationFiles(propertySymbol)) {
-          throw unsupported(element, {kind: 'prototypeMemberRead', property})
-        }
+        // Optional properties destructure like other reads because the record carries
+        // omitted properties as maybe-undefined values.
         if (valueKind(elementType, context.checker) == null) {
           throw unsupported(element, {kind: 'valueType', typeText: context.checker.typeToString(elementType)})
         }

package/src/lower/static-intrinsics.ts

@@ -1,4 +1,5 @@
 import * as ts from 'typescript'
+import type {TopLevelFunctionUnit} from './function-unit.ts'
 
 type StaticAnnotationRole = 'requirement' | 'assertion'
 
@@ -19,19 +20,19 @@ type StaticAnnotationScan = {
 
 export function scanStaticAnnotations(
   sourceFile: ts.SourceFile,
-  declarations: ts.FunctionDeclaration[],
+  functions: TopLevelFunctionUnit[],
   checker: ts.TypeChecker,
 ): StaticAnnotationScan {
-  const ownerIndex = new Map<ts.FunctionDeclaration, number>(
-    declarations.map((declaration, index) => [declaration, index]),
+  const ownerIndex = new Map<ts.SignatureDeclaration, number>(
+    functions.map((unit, index) => [unit.declaration, index]),
   )
-  const callsByFunction = declarations.map(() => [] as ts.CallExpression[])
+  const callsByFunction = functions.map(() => [] as ts.CallExpression[])
   const outsideTopLevelFunctions: ts.CallExpression[] = []
 
   const visit = (node: ts.Node): void => {
     if (ts.isCallExpression(node) && isStaticIntent(node, checker)) {
       const owner = ts.findAncestor(node, ts.isFunctionLike)
-      const index = owner != null && ts.isFunctionDeclaration(owner) ? ownerIndex.get(owner) : undefined
+      const index = owner == null ? undefined : ownerIndex.get(owner)
       if (index == null) outsideTopLevelFunctions.push(node)
       else callsByFunction[index]!.push(node)
     }
@@ -40,12 +41,12 @@ export function scanStaticAnnotations(
   visit(sourceFile)
 
   return {
-    functions: declarations.map((declaration, index) => {
+    functions: functions.map((unit, index) => {
       const calls = callsByFunction[index]!
       const callSet = new Set(calls)
       const leading = new Set<ts.CallExpression>()
-      if (declaration.body != null) {
-        for (const statement of declaration.body.statements) {
+      if (unit.declaration.body != null && ts.isBlock(unit.declaration.body)) {
+        for (const statement of unit.declaration.body.statements) {
           if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression)
             || !callSet.has(statement.expression)) break
           leading.add(statement.expression)

package/src/project.ts

@@ -301,7 +301,7 @@ function collectLintFindings({program, analysis}: DetailedAnalysis): LintFinding
     addError(
       issue.site,
       'console-assert',
-      'console.assert is only supported inside a named top-level function declaration',
+      'console.assert is only supported inside a named top-level function',
     )
   }
   for (const fn of analysis.functions) {
@@ -409,7 +409,7 @@ function formatLintPrefix(finding: LintFinding, rule: string, pretty: boolean):
 }
 
 function formatCoverage(coverage: ProjectCoverage): string {
-  return `coverage: ${coverage.analyzed}/${coverage.functions} named top-level function declarations fully analyzed; ${coverage.partial} partially supported; ${coverage.unsupported} unsupported.`
+  return `coverage: ${coverage.analyzed}/${coverage.functions} named top-level functions fully analyzed; ${coverage.partial} partially supported; ${coverage.unsupported} unsupported.`
 }
 
 // A target file analyzed on its own, with the output styling its project configures.
@@ -461,7 +461,7 @@ function analyzeProjectSource(
 ): DetailedAnalysis {
   return analyzeCheckedSource({
     sourceFile: source.sourceFile,
-    checker: source.project.program.getTypeChecker(),
+    program: source.project.program,
   }, reportBaseDirectory)
 }
 

package/src/report/index.ts

@@ -837,6 +837,7 @@ function formatStop(stop: Stop, program: ProgramIR, analysis: ProgramAnalysis):
         // read of one can only happen in the initializer's own top-level code.
         case 'value':
         case 'kind':
+        case 'function':
           return `reads ${binding.name} before it is initialized (read at ${formatSite(program, stop.site)})`
       }
     }
@@ -905,6 +906,7 @@ export function formatUnsupportedReason(reason: UnsupportedReason): string {
     case 'unknownIdentifier': return `unknown identifier ${reason.name}`
     case 'missingSymbol': return 'node without a TypeScript symbol'
     case 'functionWithoutSignature': return 'function without a TypeScript signature'
+    case 'constFunctionSignature': return 'a top-level const function whose declared call shape differs from its implementation'
     case 'functionWithoutBody': return 'function declarations need bodies'
     case 'destructuredParameter': return 'destructured parameters (take a named parameter and destructure it in the body)'
     case 'parameterType': return reason.optionalOrRestTuple
@@ -916,10 +918,8 @@ export function formatUnsupportedReason(reason: UnsupportedReason): string {
     case 'computedPropertyName': return 'computed object property name'
     case 'objectSpread': return 'object spread (list every field explicitly, e.g. {gain: config.gain})'
     case 'asyncOrGeneratorFunction': return 'an async or generator function (the runtime result is a Promise or iterator, not the body\'s return value)'
-    case 'typePredicate': return 'a type predicate (the checker takes the predicate on faith; return a plain boolean and check properties where they are read)'
     case 'protoProperty': return 'a property named __proto__ (prototype-setting syntax at runtime, not a data property)'
     case 'enumMemberRead': return 'an enum member read (replace the enum with plain module consts, e.g. const directionUp = 1)'
-    case 'prototypeMemberRead': return `read of the inherited prototype member ${reason.property} (records carry only their own data properties)`
     case 'binaryOperator': return reason.operator === 'in'
       ? 'the `in` operator (use a distinct string or boolean tag when property presence distinguishes union variants)'
       : `binary operator ${reason.operator} (supported: + - * / %, comparisons, and boolean && || !)`

package/src/requirements/infer.ts

@@ -1,15 +1,22 @@
 import type {SiteID, ValueID} from '../ir/ids.ts'
 import type {InstructionIR} from '../ir/instructions.ts'
 import type {FunctionIR} from '../ir/program.ts'
+import {
+  createValueIdentityOwner,
+  sameValueIdentity,
+  type ValueIdentity,
+  type ValueIdentityOwner,
+} from '../domain/value-identity.ts'
 import type {InferredPrecondition, NumericExpression} from './model.ts'
 
 export type ExpressionContext = {
   parameterExpressions: Array<NumericExpression | null>
-  // Calls pass the caller's value keys directly, so duplicate arguments and facts created
-  // in a callee refer to the same identity as the caller. Local keys use a nested namespace
-  // to avoid colliding with the caller's ValueIDs.
-  parameterIdentityKeys: string[]
-  identityNamespace: string
+  // Calls pass the caller's identities directly, so duplicate arguments and facts created
+  // in a callee refer to the same stored value. Local identities use the evaluation's
+  // owner token, which distinguishes separate calls without encoding the call path.
+  parameterIdentities: ValueIdentity[]
+  identityOwner: ValueIdentityOwner
+  identityByValue: Array<ValueIdentity | undefined>
   parameterIndexByValue: Array<number | undefined>
   instructionByValue: Array<InstructionIR | undefined>
   instructionCount: number
@@ -18,21 +25,27 @@ export type ExpressionContext = {
 export function createExpressionContext(
   fn: FunctionIR,
   parameterExpressions: Array<NumericExpression | null>,
-  parameterIdentityKeys?: string[],
-  identityNamespace = `${fn.name}/`,
+  parameterIdentities?: ValueIdentity[],
+  identityOwner = createValueIdentityOwner(),
 ): ExpressionContext {
-  const identityKeys = parameterIdentityKeys ?? fn.parameters.map((_, index) => `p${index}`)
-  if (identityKeys.length !== fn.parameters.length) {
-    throw new Error(`Expected ${fn.parameters.length} parameter identity keys for ${fn.name}`)
-  }
   const context: ExpressionContext = {
     parameterExpressions,
-    parameterIdentityKeys: identityKeys,
-    identityNamespace,
+    parameterIdentities: [],
+    identityOwner,
+    identityByValue: [],
     parameterIndexByValue: [],
     instructionByValue: [],
     instructionCount: 0,
   }
+  context.parameterIdentities = parameterIdentities
+    ?? fn.parameters.map(parameter => ({
+      kind: 'local',
+      owner: identityOwner,
+      value: parameter.value,
+    }))
+  if (context.parameterIdentities.length !== fn.parameters.length) {
+    throw new Error(`Expected ${fn.parameters.length} parameter identities for ${fn.name}`)
+  }
   for (let index = 0; index < fn.parameters.length; index++) {
     context.parameterIndexByValue[fn.parameters[index]!.value] = index
   }
@@ -159,29 +172,67 @@ export function staticRequirement(
   return null
 }
 
-// A stable name for the runtime value an IR value holds. Forward value facts and exact
+// A stable identity for the runtime value an IR value holds. Forward value facts and exact
 // same-value operations share this rule instead of maintaining separate notions of
 // identity. Property and array reads are stable under the accepted subset's immutability
 // rules; module and platform reads stay value-keyed because they may change between reads.
-export function canonicalValueKey(value: ValueID, context: ExpressionContext): string {
+export function canonicalValueIdentity(
+  value: ValueID,
+  context: ExpressionContext,
+): ValueIdentity {
+  const cached = context.identityByValue[value]
+  if (cached != null) return cached
   const stored = resolveStoredValue(value, context)
-  if (stored !== value) return canonicalValueKey(stored, context)
+  if (stored !== value) {
+    const identity = canonicalValueIdentity(stored, context)
+    context.identityByValue[value] = identity
+    return identity
+  }
   const parameterIndex = context.parameterIndexByValue[value]
-  if (parameterIndex != null) return context.parameterIdentityKeys[parameterIndex] ?? `p${parameterIndex}`
+  if (parameterIndex != null) {
+    const identity = context.parameterIdentities[parameterIndex]
+    if (identity == null) throw new Error(`Missing identity for parameter ${parameterIndex}`)
+    context.identityByValue[value] = identity
+    return identity
+  }
   const producer = context.instructionByValue[value]
+  let identity: ValueIdentity
   if (producer?.kind === 'property') {
-    return `${canonicalValueKey(producer.object, context)}.${JSON.stringify(producer.property)}`
-  }
-  if (producer?.kind === 'arrayLength') return `${canonicalValueKey(producer.array, context)}.length`
-  if (producer?.kind === 'stringLength') return `${canonicalValueKey(producer.value, context)}.length`
-  if (producer?.kind === 'arrayIndex') {
-    return `${canonicalValueKey(producer.array, context)}[${canonicalValueKey(producer.index, context)}]`
+    identity = {
+      kind: 'property',
+      object: canonicalValueIdentity(producer.object, context),
+      property: producer.property,
+    }
+  } else if (producer?.kind === 'arrayLength') {
+    identity = {
+      kind: 'property',
+      object: canonicalValueIdentity(producer.array, context),
+      property: 'length',
+    }
+  } else if (producer?.kind === 'stringLength') {
+    identity = {
+      kind: 'property',
+      object: canonicalValueIdentity(producer.value, context),
+      property: 'length',
+    }
+  } else if (producer?.kind === 'arrayIndex') {
+    identity = {
+      kind: 'arrayIndex',
+      array: canonicalValueIdentity(producer.array, context),
+      index: canonicalValueIdentity(producer.index, context),
+    }
+  } else {
+    identity = {kind: 'local', owner: context.identityOwner, value}
   }
-  return `v:${context.identityNamespace}${value}`
+  context.identityByValue[value] = identity
+  return identity
 }
 
 export function sameRuntimeValue(left: ValueID, right: ValueID, context: ExpressionContext): boolean {
-  return left === right || canonicalValueKey(left, context) === canonicalValueKey(right, context)
+  return left === right || sameValueIdentity(
+    canonicalValueIdentity(left, context),
+    canonicalValueIdentity(right, context),
+  )
 }
 
 export function addPrecondition(preconditions: InferredPrecondition[], candidate: InferredPrecondition): void {

package/src/typescript/check.ts

@@ -4,7 +4,7 @@ import {TypeScriptDiagnosticsError} from './diagnostics.ts'
 
 export type CheckedSource = {
   sourceFile: ts.SourceFile
-  checker: ts.TypeChecker
+  program: ts.Program
 }
 
 // When no tsconfig is in scope, single-file analysis gets the recommended authoring
@@ -52,5 +52,5 @@ function checkedSource(program: ts.Program, file: string, options: ts.CompilerOp
   }
   const sourceFile = program.getSourceFile(file)
   if (sourceFile == null) throw new Error(`TypeScript did not load ${file}`)
-  return {sourceFile, checker: program.getTypeChecker()}
+  return {sourceFile, program}
 }