@chenglou/freerange 0.0.1 → 0.0.3

package/src/lower/expression.ts

@@ -420,7 +420,10 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
             arguments_.push(lowerParameterDefault(default_, parameter.initializer, context))
             continue
           }
-          if (parameter.questionToken != null) {
+          const callableParameter = callee.signature?.declaration?.parameters[index]
+          if (callableParameter != null
+            && ts.isParameter(callableParameter)
+            && callableParameter.questionToken != null) {
             arguments_.push(addInstruction(context, parameter, {kind: 'nullishConstant', sentinel: 'undefined'}))
             continue
           }
@@ -452,7 +455,12 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
           context,
         ))
       }
-      return addInstruction(context, current, {kind: 'call', function: callee.id, arguments: arguments_})
+      return addInstruction(context, current, {
+        kind: 'call',
+        function: callee.id,
+        arguments: arguments_,
+        binding: callee.binding,
+      })
     }
     if (ts.isPropertyAccessExpression(current.expression)) {
       const platformCall = current.arguments.length === 0 ? platformFact(current.expression, true, context.checker) : null
@@ -882,12 +890,10 @@ export function compoundAssignmentOperator(kind: ts.SyntaxKind): Extract<Instruc
   }
 }
 
-// The shared value-producing branch shape: branch on the condition, lower each arm in its
-// own block, and join at a continuation whose single parameter carries the result. Arms are
-// provably assignment-free — assignments lower only through lowerStatementExpression — so
-// no bindings can change across the arms and the join needs no binding merge. Ternaries and
-// the logical operators are the two consumers; lowerIfStatement stays separate (no result
-// value, arms may terminate, and assignments are allowed there).
+// The shared value-producing branch shape: lower each arm in its own block, then join at
+// a continuation whose single parameter carries the result. Arms are assignment-free, so
+// the join needs no binding merge. One entry accepts an existing condition value; the other
+// keeps a compound condition split into branches so each check can narrow later operands.
 function lowerValueBranch(
   node: ts.Expression,
   condition: ValueID,
@@ -904,6 +910,44 @@ function lowerValueBranch(
     whenFalse: {block: whenFalse, arguments: []},
     site: addSite(context, node),
   })
+  return joinValueBranches(
+    node,
+    whenTrue,
+    whenFalse,
+    lowerTrueArm,
+    lowerFalseArm,
+    context,
+  )
+}
+
+function lowerBranchingValue(
+  node: ts.Expression,
+  condition: ts.Expression,
+  lowerTrueArm: () => ValueID,
+  lowerFalseArm: () => ValueID,
+  context: FunctionContext,
+): ValueID {
+  const whenTrue = createBlock(context)
+  const whenFalse = createBlock(context)
+  lowerBranchingCondition(condition, whenTrue, whenFalse, context)
+  return joinValueBranches(
+    node,
+    whenTrue,
+    whenFalse,
+    lowerTrueArm,
+    lowerFalseArm,
+    context,
+  )
+}
+
+function joinValueBranches(
+  node: ts.Expression,
+  whenTrue: number,
+  whenFalse: number,
+  lowerTrueArm: () => ValueID,
+  lowerFalseArm: () => ValueID,
+  context: FunctionContext,
+): ValueID {
   context.currentBlock = context.blocks[whenTrue]!
   const trueValue = lowerTrueArm()
   const trueBlock = context.currentBlock
@@ -937,28 +981,13 @@ function lowerConditionalExpression(expression: ts.ConditionalExpression, contex
   // condition as one boolean expression (the previous shape) hid the conjuncts behind a
   // joined block parameter no branch refinement could see through; a conversion pass on
   // the owner's repo caught the asymmetry.
-  const whenTrue = createBlock(context)
-  const whenFalse = createBlock(context)
-  lowerBranchingCondition(expression.condition, whenTrue, whenFalse, context)
-  context.currentBlock = context.blocks[whenTrue]!
-  const trueValue = lowerExpression(expression.whenTrue, context)
-  const trueBlock = context.currentBlock
-  context.currentBlock = context.blocks[whenFalse]!
-  const falseValue = lowerExpression(expression.whenFalse, context)
-  const falseBlock = context.currentBlock
-  const continuation = createBlock(context, 1)
-  terminate(trueBlock, {
-    kind: 'jump',
-    target: {block: continuation, arguments: [trueValue]},
-    site: addSite(context, expression),
-  })
-  terminate(falseBlock, {
-    kind: 'jump',
-    target: {block: continuation, arguments: [falseValue]},
-    site: addSite(context, expression),
-  })
-  context.currentBlock = context.blocks[continuation]!
-  return context.currentBlock.parameters[0]!
+  return lowerBranchingValue(
+    expression,
+    expression.condition,
+    () => lowerExpression(expression.whenTrue, context),
+    () => lowerExpression(expression.whenFalse, context),
+    context,
+  )
 }
 
 // `a && b` evaluates b only when a is true and yields false otherwise; `a || b` mirrors it —
@@ -1017,10 +1046,9 @@ function lowerLogicalExpression(expression: ts.BinaryExpression, context: Functi
   requireBooleanCondition(expression.left, context.checker)
   requireBooleanCondition(expression.right, context.checker)
   const isAnd = expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
-  const condition = lowerExpression(expression.left, context)
-  return lowerValueBranch(
+  return lowerBranchingValue(
     expression,
-    condition,
+    expression.left,
     () => isAnd
       ? lowerExpression(expression.right, context)
       : addInstruction(context, expression, {kind: 'booleanConstant', value: true}),

package/src/lower/function-unit.ts

@@ -0,0 +1,64 @@
+import * as ts from 'typescript'
+
+export type TopLevelFunctionNode =
+  | ts.FunctionDeclaration
+  | ts.ArrowFunction
+  | ts.FunctionExpression
+
+export type TopLevelFunctionUnit = {
+  name: ts.Identifier
+  declaration: TopLevelFunctionNode
+  initializer: ts.VariableDeclaration | null
+}
+
+export function callableSignature(
+  unit: TopLevelFunctionUnit,
+  checker: ts.TypeChecker,
+): ts.Signature | null {
+  if (unit.initializer == null) {
+    return checker.getSignatureFromDeclaration(unit.declaration) ?? null
+  }
+  const signatures = checker.getSignaturesOfType(
+    checker.getTypeAtLocation(unit.name),
+    ts.SignatureKind.Call,
+  )
+  if (signatures.length !== 1) return null
+  const signature = signatures[0]!
+  const signatureDeclaration = signature.declaration
+  if (signatureDeclaration == null
+    || signature.thisParameter != null
+    || signature.parameters.length !== unit.declaration.parameters.length
+    || signatureDeclaration.parameters.some(parameter =>
+      !ts.isParameter(parameter) || parameter.dotDotDotToken != null)) {
+    return null
+  }
+  return signature
+}
+
+export function topLevelFunctionUnits(sourceFile: ts.SourceFile): TopLevelFunctionUnit[] {
+  const units: TopLevelFunctionUnit[] = []
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name != null) {
+      units.push({name: statement.name, declaration: statement, initializer: null})
+      continue
+    }
+    if (!ts.isVariableStatement(statement)
+      || (statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue
+    for (const initializer of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(initializer.name) || initializer.initializer == null) continue
+      const declaration = directFunctionExpression(initializer.initializer)
+      if (declaration != null) {
+        units.push({name: initializer.name, declaration, initializer})
+      }
+    }
+  }
+  return units
+}
+
+export function directFunctionExpression(
+  expression: ts.Expression,
+): ts.ArrowFunction | ts.FunctionExpression | null {
+  return ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)
+    ? expression
+    : null
+}

package/src/lower/module.ts

@@ -18,6 +18,7 @@ import {numericLiteralValue} from './literals.ts'
 import {declaredOnlyInDeclarationFiles} from './platform.ts'
 import {addInstruction, addSite, createFunctionContext, LoweringStop, restoreLowering, sealBlocks, snapshotLowering, terminate, type FunctionContext, type TopLevelFunction} from './context.ts'
 import {lowerExpression, nonMissingUnionMembers, tagLiteralValues, taggedUnionProperty, valueKind} from './expression.ts'
+import {directFunctionExpression} from './function-unit.ts'
 import {lowerStatement} from './statements.ts'
 
 export type ModuleScan = {
@@ -45,9 +46,16 @@ export function scanModuleBindings(sourceFile: ts.SourceFile, checker: ts.TypeCh
       // the statement itself is skipped when the initializer reaches it, and functions
       // reading the name are rejected as unknown identifiers.
       if ((statement.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) === 0) continue
+      const isConst = (statement.declarationList.flags & ts.NodeFlags.Const) !== 0
       for (const declarator of statement.declarationList.declarations) {
         if (ts.isIdentifier(declarator.name)) {
-          register(declarator.name, declaredCategory(declarator.name, checker))
+          register(
+            declarator.name,
+            isConst && declarator.initializer != null
+              && directFunctionExpression(declarator.initializer) != null
+              ? {kind: 'function'}
+              : declaredCategory(declarator.name, checker),
+          )
           continue
         }
         // `const {cols} = gridSize` at the top level: each destructured name is its own
@@ -206,7 +214,7 @@ export function lowerModuleInitializer(
     if (skippedAtTopLevel(statement)) continue
     const recovery = snapshotLowering(context)
     try {
-      assertAccepted(statement)
+      assertAccepted(statement, true)
       if (ts.isVariableStatement(statement)) {
         lowerTopLevelDeclarations(statement, context, scan)
         continue
@@ -354,6 +362,12 @@ function lowerTopLevelDeclarations(statement: ts.VariableStatement, context: Fun
     const symbol = context.checker.getSymbolAtLocation(declarator.name)
     const binding = symbol == null ? undefined : scan.bindingsBySymbol.get(symbol)
     if (binding == null) throw new LoweringStop(declarator, {kind: 'variableDeclarationShape'})
+    if ((statement.declarationList.flags & ts.NodeFlags.Const) !== 0
+      && directFunctionExpression(declarator.initializer) != null) {
+      const marker = addInstruction(context, declarator.initializer, {kind: 'opaqueConstant'})
+      addInstruction(context, declarator, {kind: 'moduleWrite', binding, value: marker})
+      continue
+    }
     const value = lowerExpression(declarator.initializer, context)
     addInstruction(context, declarator, {kind: 'moduleWrite', binding, value})
   }
@@ -361,8 +375,9 @@ function lowerTopLevelDeclarations(statement: ts.VariableStatement, context: Fun
 
 function skippedAtTopLevel(statement: ts.Statement): boolean {
   // `export {alreadyDeclaredName}` and import declarations create bindings but run nothing.
-  // Only NAMED function declarations pass: those become program.functions entries, so
-  // unsupported code inside them keeps the fully-analyzed publish gate honest. An
+  // Named declarations pass here: those become program.functions entries, so unsupported
+  // code inside them keeps the fully-analyzed publish gate honest. Const-bound functions
+  // remain variable statements and lower above as function-initialization markers. An
   // anonymous `export default function` has no name to collect under, so it falls through
   // to ordinary statement lowering, which records it as an initializer skip — otherwise
   // its body would be runtime code invisible to every gate.
@@ -741,6 +756,7 @@ function demote(bindings: ModuleBindingIR[], binding: ModuleBindingID): void {
       break
     }
     case 'kind':
+    case 'function':
     case 'import':
     case 'opaque':
       break

package/src/lower/platform.ts

@@ -47,6 +47,9 @@ const catalog: PlatformEntry[] = [
   // resolution); Date.now is an integer count of milliseconds.
   {path: ['performance', 'now'], call: true, fact: {lower: 0, upper: Number.MAX_VALUE, integer: false}},
   {path: ['Date', 'now'], call: true, fact: {lower: 0, upper: Number.MAX_VALUE, integer: true}},
+  // Math.random returns one of JavaScript's discrete floating-point numbers below 1.
+  // Writing the predecessor of 1 keeps the exact closed range without adding open bounds.
+  {path: ['Math', 'random'], call: true, fact: {lower: 0, upper: 0.9999999999999999, integer: false}},
 ]
 
 // Matches a property chain rooted at a global whose symbol resolves into a declaration

package/src/lower/program.ts

@@ -4,7 +4,8 @@ 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'
@@ -12,10 +13,7 @@ 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 declarations = topLevelFunctionUnits(sourceFile)
   const staticScan = scanStaticAnnotations(sourceFile, declarations, checker)
   const recordStaticAnnotationIssues = (sites: SourceSpan[]): ProgramIR['staticAnnotationIssues'] =>
     staticScan.outsideTopLevelFunctions.map(call => {
@@ -34,9 +32,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,21 +60,33 @@ 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.
@@ -87,7 +97,7 @@ export function lowerSource(checked: CheckedSource, baseDirectory: string = proc
       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,
@@ -109,7 +119,7 @@ export function lowerSource(checked: CheckedSource, baseDirectory: string = proc
 }
 
 function lowerFunction(
-  declaration: ts.FunctionDeclaration,
+  unit: TopLevelFunction,
   staticAnnotations: StaticAnnotation[],
   sourceFile: ts.SourceFile,
   checker: ts.TypeChecker,
@@ -117,6 +127,7 @@ function lowerFunction(
   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 +137,24 @@ 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)
+  const signature = unit.signature
+  if (signature == null) {
+    throw unsupported(unit.name, {
+      kind: unit.initializer == null ? 'functionWithoutSignature' : 'constFunctionSignature',
+    })
+  }
   // 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) {
+  if (checker.getTypePredicateOfSignature(signature) != null) {
     throw unsupported(declaration, {kind: 'typePredicate'})
   }
-  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.
@@ -154,16 +171,21 @@ function lowerFunction(
     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 +223,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 +240,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 +265,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 +318,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 +336,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

@@ -30,17 +30,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

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.

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