fhirpath-ts 0.1.0 → 0.2.1

package/src/analyzer/analyze.ts

@@ -1,15 +1,34 @@
 import '../functions/install.ts'
 
-import { BUILTIN_ENV_VARIABLE_NAMES } from '../engine/context.ts'
+import { bareEnvironmentName, BUILTIN_ENV_VARIABLE_NAMES, normalizeEnvKeys } from '../engine/context.ts'
 import { FhirPathSyntaxError, type SourceSpan } from '../errors.ts'
 import { describeArity, functions } from '../functions/registry.ts'
 import type { ElementInfo, ModelProvider } from '../model/provider.ts'
 import type { AstNode } from '../parser/ast.ts'
 import { parse } from '../parser/parser.ts'
-import { unsatisfiedInput, type ValueKind, valueKindOfTypeName } from '../values/type-compat.ts'
+import type { FhirpathTypeDeclarations } from '../typed/infer.ts'
+import {
+  canonicalFocusType,
+  commonValueKind,
+  resolveByInput,
+  resolveSystemTypeName,
+  rootTypeMatches,
+  SYSTEM_TYPE_LOCAL_NAMES,
+  unsatisfiedInput,
+  type ValueKind,
+} from '../values/type-compat.ts'
 import { FHIR_PRIMITIVE_TO_SYSTEM, typeLocalName } from '../values/typed-value.ts'
+import {
+  analyzerEnvironmentVariables,
+  type AnalyzerVariable,
+  type AnalyzerVariableState,
+  isRuntimeAnalyzerVariable,
+  runtimeAnalyzerEnvironmentVariables,
+} from './declarations.ts'
+import { applyOperatorResultRule, applyTypeOperatorResultRule } from './operator-rules.ts'
 import { hasNestedUnboundedQuantifier } from './regex-safety.ts'
 import {
+  applyResultRule,
   type CustomFunctionSignature,
   FUNCTION_SIGNATURES,
   type FunctionSignature,
@@ -30,22 +49,27 @@ export interface AnalyzerDiagnostic {
 }
 
 /** A host variable known to the analyzer. Omit its types to keep the value unknown. */
-export interface DeclaredVariable {
-  /** Candidate type names ('Patient', 'System.String'); omit to leave the type unknown. */
-  types?: string[]
-  /** True when the variable always holds at most one item. */
-  single?: boolean
-}
+export type DeclaredVariable = AnalyzerVariable
 
 /** A host function declaration. Arity resolves the call; an optional signature checks it. */
 export type SingleDeclaredFunction =
-  | { minArity?: number; maxArity?: number; expression?: never; signature?: CustomFunctionSignature }
+  | {
+      minArity?: number
+      maxArity?: number
+      expression?: never
+      signature?: CustomFunctionSignature
+      criteria?: never
+      envTypes?: never
+    }
   | {
       /** The body of an expression-defined CustomFunction; its presence pins the arity to 0. */
       expression: unknown
       minArity?: never
       maxArity?: never
       signature?: CustomFunctionSignature
+      criteria?: boolean
+      env?: Record<string, unknown>
+      envTypes?: FhirpathTypeDeclarations
     }
 
 /** Same-name functions selected by the call focus. Unknown focus keeps only their shared claims. */
@@ -69,6 +93,11 @@ export interface AnalyzeOptions {
   variables?: Record<string, DeclaredVariable>
 }
 
+/** Internal strict-analysis options whose variables may retain exact runtime focus types. */
+export interface RuntimeAnalyzeOptions extends Omit<AnalyzeOptions, 'variables'> {
+  variables?: Record<string, AnalyzerVariableState>
+}
+
 /**
  * Candidate type names and cardinality for one sub-expression. `undefined`
  * means unknown and pauses checks that need that fact. `single` is true for at
@@ -77,6 +106,8 @@ export interface AnalyzeOptions {
 interface StaticState {
   types: string[] | undefined
   single: boolean | undefined
+  /** Exact runtime focus types, present only while strict analysis can still prove them. */
+  exactTypes?: string[]
   /**
    * Canonical resource types a Reference-valued state may point to (from
    * `Reference.targetProfile`) — what resolve() yields. Carried by element
@@ -89,6 +120,17 @@ interface StaticState {
 
 const UNKNOWN: StaticState = { types: undefined, single: undefined }
 
+/** A runtime-analyzed function result no longer has exact facts about its input focus. */
+function callResult(state: Pick<StaticState, 'types' | 'single' | 'targets'>, runtime: boolean): StaticState {
+  return runtime
+    ? {
+        types: state.types,
+        single: state.single,
+        ...(state.targets !== undefined && { targets: state.targets }),
+      }
+    : state
+}
+
 /**
  * Variables visible at one point in analysis. Operators and arguments receive a
  * copy. A dynamic variable name prevents later unknown-variable diagnostics in
@@ -126,6 +168,14 @@ export interface AnalysisDetails {
   elementDependencies: string[]
 }
 
+/** Runtime-known input state used by strict evaluation. Not part of the public analyzer API. */
+export interface AnalyzerRoot {
+  types: string[] | undefined
+  single: boolean | undefined
+  /** Canonical runtime types in focus order; an empty array means an exactly empty focus. */
+  exactTypes?: string[]
+}
+
 /**
  * Statically check one expression against the model: spec §11's strict-mode rules
  * (singleton misuse, wrong operand and argument types, incomparable equality)
@@ -199,7 +249,16 @@ export function analyzeExpressionDetailed(expression: string, options?: AnalyzeO
       result: { types: undefined, single: undefined },
     }
   }
-  const analyzer = new Analyzer(options)
+  return analyzeAstDetailed(ast, options)
+}
+
+/** Analyze an already parsed expression, optionally with a runtime-derived input state. */
+function analyzeAstDetailed(
+  ast: AstNode,
+  options?: AnalyzeOptions | RuntimeAnalyzeOptions,
+  root?: AnalyzerRoot
+): AnalysisDetails {
+  const analyzer = new Analyzer(options, root)
   const state = analyzer.walk(ast, analyzer.rootState(), emptyScope())
   return {
     diagnostics: analyzer.diagnostics,
@@ -208,36 +267,54 @@ export function analyzeExpressionDetailed(expression: string, options?: AnalyzeO
   }
 }
 
+/** Analyze a parsed expression using facts from the actual evaluation focus. */
+export function analyzeRuntimeAstDetailed(
+  ast: AstNode,
+  options: RuntimeAnalyzeOptions,
+  root: AnalyzerRoot
+): AnalysisDetails {
+  return analyzeAstDetailed(ast, options, root)
+}
+
 class Analyzer {
   readonly diagnostics: AnalyzerDiagnostic[] = []
   readonly dependencies = new Set<string>()
   private readonly model: ModelProvider | undefined
-  private readonly inputType: string | undefined
+  private readonly root: AnalyzerRoot
+  private readonly runtime: boolean
   private readonly frames: StaticState[] = []
   /** Every declaration of each host-supplied name; one entry unless the name is overloaded. */
   private readonly customFunctions: ReadonlyMap<string, readonly ResolvedDeclaration[]>
-  private readonly declaredVariables: ReadonlyMap<string, DeclaredVariable>
+  private readonly declaredVariables: ReadonlyMap<string, AnalyzerVariableState>
+  private readonly activeExpressionFunctions = new Set<string>()
 
-  constructor(options: AnalyzeOptions | undefined) {
+  constructor(options: AnalyzeOptions | RuntimeAnalyzeOptions | undefined, root: AnalyzerRoot | undefined) {
     this.model = options?.model
+    this.runtime = root !== undefined
     const inputType = options?.inputType
-    this.inputType = inputType === undefined ? undefined : (this.model?.resolveType(inputType) ?? inputType)
+    this.root =
+      root ??
+      (inputType === undefined
+        ? { types: undefined, single: undefined }
+        : { types: [this.model?.resolveType(inputType) ?? inputType], single: true })
     this.customFunctions = new Map(
       Object.entries(options?.functions ?? {}).map(([name, declared]) => [
         name,
-        ('overloads' in declared ? declared.overloads : [declared]).map(resolvedDeclaration),
-      ])
-    )
-    this.declaredVariables = new Map(
-      Object.entries(options?.variables ?? {}).map(([name, variable]) => [
-        name.startsWith('%') ? name.slice(1) : name,
-        variable,
+        ('overloads' in declared ? declared.overloads : [declared]).map(declaration =>
+          resolvedDeclaration(declaration, this.model, this.runtime)
+        ),
       ])
     )
+    this.declaredVariables = new Map(Object.entries(normalizeEnvKeys(options?.variables)))
   }
 
   rootState(): StaticState {
-    return this.inputType === undefined ? UNKNOWN : { types: [this.inputType], single: true, rawInput: true }
+    return {
+      types: this.root.types,
+      single: this.root.single,
+      rawInput: true,
+      ...(this.root.exactTypes !== undefined && { exactTypes: this.root.exactTypes }),
+    }
   }
 
   walk(node: AstNode, input: StaticState, scope: VariableScope): StaticState {
@@ -312,7 +389,7 @@ class Analyzer {
     }
     const declared = this.declaredVariables.get(node.name)
     if (declared !== undefined) {
-      return { types: declared.types?.map(type => this.canonicalize(type)), single: declared.single }
+      return this.declaredVariableState(declared)
     }
     switch (node.name) {
       case 'context':
@@ -362,30 +439,54 @@ class Analyzer {
     if (input.types !== undefined && input.types.length === 0) {
       return { types: [], single: true }
     }
+    const exactTypes = input.exactTypes?.filter(type => rootTypeMatches(this.model, type, node.name))
+    if (exactTypes !== undefined && exactTypes.length > 0) {
+      const types = input.types?.filter(type => rootTypeMatches(this.model, type, node.name))
+      return {
+        types: types === undefined ? undefined : [...new Set(types)],
+        single: input.single,
+        exactTypes,
+        ...(input.rawInput === true && { rawInput: true }),
+      }
+    }
     if (input.types === undefined) {
       // Even with an unknown input, a root identifier naming a model type anchors
       // the state — this is what checks `Patient.nope` without an inputType option.
-      const asType = this.model?.resolveType(node.name)
+      const asType = this.model?.resolveType(node.name) ?? resolveSystemTypeName(node.name)
       if (asType !== undefined) {
-        return { types: [asType], single: true }
+        return {
+          types: [asType],
+          single: true,
+          ...(input.exactTypes !== undefined && {
+            exactTypes: input.exactTypes.filter(type => this.model?.isSubtypeOf(type, asType) === true),
+          }),
+        }
       }
       return UNKNOWN
     }
     // Root rule: an identifier naming the (super)type of the context is the context.
-    if (this.model) {
-      const asType = this.model.resolveType(node.name)
-      if (asType !== undefined && input.types.some(type => this.model?.isSubtypeOf(type, asType))) {
+    {
+      const asType = this.model?.resolveType(node.name) ?? resolveSystemTypeName(node.name)
+      let matchingTypes: string[] = []
+      if (asType !== undefined) {
+        matchingTypes = input.types.filter(type => rootTypeMatches(this.model, type, node.name))
+      }
+      if (asType !== undefined && matchingTypes.length > 0) {
         // The runtime matches a type name against the raw input only through the
         // resourceType discriminator (values/typed-value.ts), so a non-resource
         // name never matches there and the whole path navigates to empty.
-        if (input.rawInput === true && !this.isResourceType(asType)) {
+        if (input.rawInput === true && !asType.startsWith('System.') && !this.isResourceType(asType)) {
           this.report(
             'datatype-root',
             `'${node.name}' is not a resource type, and a type-name root matches only a resource's resourceType, so this always evaluates to empty — navigate from the input with a relative path`,
             node.span
           )
         }
-        return input
+        return {
+          ...input,
+          types: matchingTypes,
+          ...(input.exactTypes !== undefined && { exactTypes: input.exactTypes }),
+        }
       }
     }
     const found: string[] = []
@@ -528,7 +629,8 @@ class Analyzer {
     const signature = registered !== undefined ? FUNCTION_SIGNATURES[node.name] : this.toSignature(custom?.signature)
     if (!signature) {
       this.walkUncheckedArguments(node, input, scope)
-      return UNKNOWN
+      const expressionResult = this.expressionFunctionResult(node.name, custom, input, scope)
+      return expressionResult === undefined ? UNKNOWN : callResult(expressionResult, this.runtime)
     }
     this.checkCallInput(node, signature, input)
     const { argStates, typeTarget } = this.walkArguments(node, signature, input, scope)
@@ -541,7 +643,125 @@ class Analyzer {
     if ((node.name === 'ofType' || node.name === 'as') && typeTarget !== undefined) {
       return { types: this.narrowTypes(input, typeTarget, node.span), single: input.single }
     }
-    return signature.result(input, argStates)
+    const expressionResult = this.expressionFunctionResult(node.name, custom, input, scope)
+    if (expressionResult !== undefined) {
+      return callResult(expressionResult, this.runtime)
+    }
+    return callResult(applyResultRule(signature.result, input, argStates), this.runtime)
+  }
+
+  /** Apply the expression-body and criteria rules in one place for signed and unsigned declarations. */
+  private expressionFunctionResult(
+    name: string,
+    declaration: ResolvedDeclaration | undefined,
+    input: StaticState,
+    scope: VariableScope
+  ): StaticState | undefined {
+    if (declaration?.expression === undefined) {
+      for (const possible of declaration?.possibleBodies ?? []) {
+        if (possible.expression !== undefined) {
+          this.walkExpressionFunction(
+            name,
+            possible.expression,
+            possible.variables,
+            this.expressionBodyInput(possible, input),
+            scope
+          )
+        }
+      }
+      return undefined
+    }
+    const expression = declaration.expression
+    const bodyInput = this.expressionBodyInput(declaration, input)
+    if (declaration.criteria === true) {
+      this.walkExpressionFunction(name, expression, declaration.variables, bodyInput, scope)
+      return { types: ['System.Boolean'], single: true }
+    }
+    if (declaration.signature?.result === undefined) {
+      return this.walkExpressionFunction(name, expression, declaration.variables, bodyInput, scope)
+    }
+    if (this.runtime) {
+      this.walkExpressionFunction(name, expression, declaration.variables, bodyInput, scope)
+    }
+    return undefined
+  }
+
+  /** A declared input type is the contract an expression body must satisfy. */
+  private expressionBodyInput(declaration: ResolvedDeclaration, callInput: StaticState): StaticState {
+    const declared = declaration.signature?.input?.types
+    if (declared === undefined) {
+      return callInput
+    }
+    const types = declared
+      .map(type =>
+        this.model === undefined ? resolveSystemTypeName(typeLocalName(type)) : canonicalFocusType(this.model, type)
+      )
+      .filter((type): type is string => type !== undefined)
+    if (types.length === 0) {
+      return callInput
+    }
+    return {
+      types: [...new Set(types)],
+      single: callInput.single,
+      ...(callInput.targets !== undefined && { targets: callInput.targets }),
+    }
+  }
+
+  /** Infer a literal expression-function body under its call focus and temporary local environment declarations. */
+  private walkExpressionFunction(
+    name: string,
+    expression: NonNullable<ResolvedDeclaration['expression']>,
+    variables: ResolvedDeclaration['variables'],
+    input: StaticState,
+    callerScope: VariableScope
+  ): StaticState {
+    if (this.activeExpressionFunctions.has(name)) {
+      return UNKNOWN
+    }
+    let ast = expression.ast
+    if (ast === undefined) {
+      try {
+        ast = parse(expression.source)
+      } catch {
+        return UNKNOWN
+      }
+    }
+    const functionScope = forkScope(callerScope)
+    for (const [declaredName, variable] of Object.entries(variables ?? {})) {
+      const bare = bareEnvironmentName(declaredName)
+      // defineVariable() values have priority over environment overlays at runtime.
+      if (!functionScope.vars.has(bare)) {
+        functionScope.vars.set(bare, this.declaredVariableState(variable))
+      }
+    }
+    const diagnosticCount = this.diagnostics.length
+    this.activeExpressionFunctions.add(name)
+    this.frames.push(input)
+    try {
+      return this.walk(ast, input, functionScope)
+    } finally {
+      if (this.runtime) {
+        for (const diagnostic of this.diagnostics.slice(diagnosticCount)) {
+          diagnostic.message = `Custom function '${name}': ${diagnostic.message}`
+        }
+      } else {
+        // Body spans index another source string, so callers cannot display these diagnostics correctly.
+        this.diagnostics.length = diagnosticCount
+      }
+      this.frames.pop()
+      this.activeExpressionFunctions.delete(name)
+    }
+  }
+
+  /** Convert one declared environment value into the same state used for scoped variables. */
+  private declaredVariableState(declared: AnalyzerVariableState): StaticState {
+    const exactTypes = this.runtime && isRuntimeAnalyzerVariable(declared) ? declared.exactTypes : undefined
+    return {
+      types: declared.types?.map(type => this.canonicalize(type)),
+      single: declared.single,
+      ...(declared.targets !== undefined && { targets: declared.targets.map(type => this.canonicalize(type)) }),
+      ...(exactTypes !== undefined && { exactTypes }),
+    }
   }
 
   /**
@@ -554,11 +774,25 @@ class Analyzer {
     if (candidates === undefined || candidates.length <= 1) {
       return candidates?.[0]
     }
+    if (this.runtime && (input.exactTypes !== undefined || this.model === undefined)) {
+      const resolution = resolveByInput(
+        this.model,
+        candidates,
+        candidate => candidate.signature?.input?.types,
+        input.exactTypes ?? []
+      )
+      return 'resolved' in resolution ? resolution.resolved : mergedDeclaration(candidates)
+    }
     const focus = input.types ?? []
     const fitting = candidates.filter(
       candidate => unsatisfiedInput(this.model, candidate.signature?.input?.types, focus) === undefined
     )
-    return fitting.length === 1 ? fitting[0] : mergedDeclaration(fitting.length === 0 ? candidates : fitting)
+    if (fitting.length === 1) {
+      return fitting[0]
+    }
+    const possible = fitting.length === 0 ? candidates : fitting
+    const merged = mergedDeclaration(possible)
+    return this.runtime ? { ...merged, possibleBodies: possible } : merged
   }
 
   /** Without a signature the arguments still walk (for their own diagnostics), each in a scope fork. */
@@ -740,7 +974,11 @@ class Analyzer {
     return {
       ...(declared.input !== undefined && { input: declared.input }),
       ...(declared.args !== undefined && { args: declared.args }),
-      result: () => ({ types, single }),
+      result: {
+        kind: 'fixed',
+        ...(types !== undefined && { types }),
+        ...(single !== undefined && { single }),
+      },
     }
   }
 
@@ -793,7 +1031,7 @@ class Analyzer {
   /** Check a type name; returns its canonical form, or undefined when it was reported unknown. */
   private checkTypeName(parts: string[], span: SourceSpan): string | undefined {
     if (parts.length === 2 && parts[0] === 'System') {
-      if (!SYSTEM_TYPE_NAMES.has(parts[1] as string)) {
+      if (!SYSTEM_TYPE_LOCAL_NAMES.has(parts[1] as string)) {
         this.report('unknown-type', `Unknown type 'System.${parts[1]}'`, span)
         return undefined
       }
@@ -805,11 +1043,11 @@ class Analyzer {
       return undefined
     }
     const resolved = this.model?.resolveType(name)
-    if (this.model && resolved === undefined && !SYSTEM_TYPE_NAMES.has(name)) {
+    if (this.model && resolved === undefined && !SYSTEM_TYPE_LOCAL_NAMES.has(name)) {
       this.report('unknown-type', `Unknown type '${parts.join('.')}'`, span)
       return undefined
     }
-    return resolved ?? (SYSTEM_TYPE_NAMES.has(name) ? `System.${name}` : name)
+    return resolved ?? (SYSTEM_TYPE_LOCAL_NAMES.has(name) ? `System.${name}` : name)
   }
 
   private walkBinary(node: AstNode & { kind: 'binary' }, input: StaticState, scope: VariableScope): StaticState {
@@ -826,24 +1064,14 @@ class Analyzer {
       case 'div':
       case 'mod': {
         this.checkArithmetic(node.operator, left, right, node.span)
-        // Quantity arithmetic yields Quantity (4.0 'g' / 2.0 'm' is 2 'g/m');
-        // plain division yields Decimal; everything else keeps the operand type.
-        const quantity =
-          (node.operator === '*' || node.operator === '/') &&
-          (kindOf(left) === 'Quantity' || kindOf(right) === 'Quantity')
-        const types = quantity
-          ? ['System.Quantity']
-          : node.operator === '/'
-            ? ['System.Decimal']
-            : (left.types ?? right.types)
-        return { types, single: true }
+        return applyOperatorResultRule(node.operator, left, right)
       }
       case '&':
         this.requireSingle(left, node.left.span, "'&' expects single-item operands")
         this.requireSingle(right, node.right.span, "'&' expects single-item operands")
         this.requireKind(left, 'String', node.left.span, "'&' expects String operands")
         this.requireKind(right, 'String', node.right.span, "'&' expects String operands")
-        return { types: ['System.String'], single: true }
+        return applyOperatorResultRule(node.operator, left, right)
       case '<':
       case '>':
       case '<=':
@@ -851,13 +1079,13 @@ class Analyzer {
         this.requireSingle(left, node.left.span, `Operator '${node.operator}' expects single-item operands`)
         this.requireSingle(right, node.right.span, `Operator '${node.operator}' expects single-item operands`)
         this.checkComparable(left, right, node.span)
-        return { types: ['System.Boolean'], single: true }
+        return applyOperatorResultRule(node.operator, left, right)
       case '=':
       case '!=':
       case '~':
       case '!~':
         this.checkEquality(left, right, node.span)
-        return { types: ['System.Boolean'], single: true }
+        return applyOperatorResultRule(node.operator, left, right)
       case 'and':
       case 'or':
       case 'xor':
@@ -866,17 +1094,10 @@ class Analyzer {
         // rule, so only cardinality is checkable here.
         this.requireSingle(left, node.left.span, `'${node.operator}' expects single-item operands`)
         this.requireSingle(right, node.right.span, `'${node.operator}' expects single-item operands`)
-        return { types: ['System.Boolean'], single: true }
+        return applyOperatorResultRule(node.operator, left, right)
       }
       case '|': {
-        // A statically empty side contributes nothing: `{} | true` is one item.
-        if (left.types?.length === 0) {
-          return right
-        }
-        if (right.types?.length === 0) {
-          return left
-        }
-        return withSingle(unionStates([left, right]), false)
+        return applyOperatorResultRule(node.operator, left, right)
       }
       case 'in':
       case 'contains': {
@@ -887,7 +1108,7 @@ class Analyzer {
           singletonSpan,
           `The ${node.operator === 'in' ? 'left' : 'right'} operand of '${node.operator}' must be a single item`
         )
-        return { types: ['System.Boolean'], single: true }
+        return applyOperatorResultRule(node.operator, left, right)
       }
       /* v8 ignore start -- the parser produces no other binary operators */
       default:
@@ -907,13 +1128,9 @@ class Analyzer {
     const operand = this.walk(node.operand, input, scope)
     this.requireSingle(operand, node.operand.span, `'${node.operator}' expects a single item operand`)
     const resolved = this.checkTypeName(node.type.parts, node.type.span)
-    if (node.operator === 'is') {
-      return { types: ['System.Boolean'], single: true }
-    }
-    if (resolved === undefined) {
-      return UNKNOWN
-    }
-    return { types: this.narrowTypes(operand, resolved, node.span), single: true }
+    const narrowed =
+      node.operator === 'as' && resolved !== undefined ? this.narrowTypes(operand, resolved, node.span) : undefined
+    return applyTypeOperatorResultRule(node.operator, narrowed)
   }
 
   private checkArithmetic(operator: string, left: StaticState, right: StaticState, span: SourceSpan): void {
@@ -921,8 +1138,8 @@ class Analyzer {
       this.report('singleton-required', `Operator '${operator}' expects single-item operands${NARROW_HINT}`, span)
       return
     }
-    const leftKind = kindOf(left)
-    const rightKind = kindOf(right)
+    const leftKind = commonValueKind(left.types)
+    const rightKind = commonValueKind(right.types)
     if (leftKind === undefined || rightKind === undefined || leftKind === 'Complex' || rightKind === 'Complex') {
       return
     }
@@ -941,8 +1158,8 @@ class Analyzer {
   }
 
   private checkComparable(left: StaticState, right: StaticState, span: SourceSpan): void {
-    const leftKind = kindOf(left)
-    const rightKind = kindOf(right)
+    const leftKind = commonValueKind(left.types)
+    const rightKind = commonValueKind(right.types)
     if (leftKind === undefined || rightKind === undefined) {
       return
     }
@@ -952,8 +1169,8 @@ class Analyzer {
   }
 
   private checkEquality(left: StaticState, right: StaticState, span: SourceSpan): void {
-    const leftKind = kindOf(left)
-    const rightKind = kindOf(right)
+    const leftKind = commonValueKind(left.types)
+    const rightKind = commonValueKind(right.types)
     if (leftKind === undefined || rightKind === undefined || leftKind === 'Complex' || rightKind === 'Complex') {
       return
     }
@@ -963,7 +1180,7 @@ class Analyzer {
   }
 
   private requireKind(state: StaticState, kind: ValueKind, span: SourceSpan, message: string): void {
-    const actual = kindOf(state)
+    const actual = commonValueKind(state.types)
     if (actual === undefined) {
       return
     }
@@ -987,19 +1204,6 @@ class Analyzer {
 /** Functions whose first argument is a regular expression pattern. */
 const REGEX_PATTERN_FUNCTIONS = new Set(['matches', 'matchesFull', 'replaceMatches'])
 
-const SYSTEM_TYPE_NAMES = new Set([
-  'Any',
-  'Boolean',
-  'String',
-  'Integer',
-  'Long',
-  'Decimal',
-  'Date',
-  'DateTime',
-  'Time',
-  'Quantity',
-])
-
 /** Appended to singleton-misuse messages so the fix is spelled out, not just the rule. */
 const NARROW_HINT = ' — narrow it to one item with first(), last(), or single()'
 
@@ -1016,15 +1220,54 @@ interface ResolvedDeclaration {
   minArity?: number
   maxArity?: number
   signature?: CustomFunctionSignature
+  expression?: { source: string; ast?: AstNode }
+  criteria?: boolean
+  variables?: Readonly<Record<string, AnalyzerVariableState>>
+  /** Expression declarations runtime dispatch may select when static focus is not exact. */
+  possibleBodies?: readonly ResolvedDeclaration[]
 }
 
-function resolvedDeclaration(declared: SingleDeclaredFunction): ResolvedDeclaration {
+function resolvedDeclaration(
+  declared: SingleDeclaredFunction,
+  model: ModelProvider | undefined,
+  runtime: boolean
+): ResolvedDeclaration {
   if (declared.expression === undefined) {
-    return declared
+    return {
+      ...(declared.minArity !== undefined && { minArity: declared.minArity }),
+      ...(declared.maxArity !== undefined && { maxArity: declared.maxArity }),
+      ...(declared.signature !== undefined && { signature: declared.signature }),
+    }
   }
   // An expression-defined function takes no arguments, which is how the runtime
   // calls it (`evaluateHostFunction`).
-  return { minArity: 0, maxArity: 0, ...(declared.signature !== undefined && { signature: declared.signature }) }
+  const expression = resolvedExpression(declared.expression)
+  return {
+    minArity: 0,
+    maxArity: 0,
+    ...(declared.signature !== undefined && { signature: declared.signature }),
+    ...(expression !== undefined && { expression }),
+    ...(declared.criteria !== undefined && { criteria: declared.criteria }),
+    ...((declared.env !== undefined || declared.envTypes !== undefined) && {
+      variables: runtime
+        ? runtimeAnalyzerEnvironmentVariables(declared.env, declared.envTypes, model)
+        : analyzerEnvironmentVariables(declared.env, declared.envTypes, model),
+    }),
+  }
+}
+
+function resolvedExpression(expression: unknown): { source: string; ast?: AstNode } | undefined {
+  if (typeof expression === 'string') {
+    return { source: expression }
+  }
+  const compiled = expression as { source?: unknown; ast?: unknown } | undefined
+  if (typeof compiled?.source !== 'string') {
+    return undefined
+  }
+  return {
+    source: compiled.source,
+    ...(compiled.ast !== undefined && { ast: compiled.ast as AstNode }),
+  }
 }
 
 /**
@@ -1061,7 +1304,7 @@ function mergedInput(candidates: readonly ResolvedDeclaration[]): InputSpec | un
 function mergedResult(candidates: readonly ResolvedDeclaration[]): { types?: string[]; single?: boolean } | undefined {
   const union = unionStates(
     candidates.map(candidate => ({
-      types: candidate.signature?.result?.types,
+      types: candidate.signature?.result?.types === undefined ? undefined : [...candidate.signature.result.types],
       single: candidate.signature?.result?.single,
     }))
   )
@@ -1074,23 +1317,6 @@ function mergedResult(candidates: readonly ResolvedDeclaration[]): { types?: str
   }
 }
 
-/** The behavior kind shared by every candidate type, or undefined when mixed/unknown. */
-function kindOf(state: StaticState): ValueKind | undefined {
-  if (state.types === undefined || state.types.length === 0) {
-    return undefined
-  }
-  let kind: ValueKind | undefined
-  for (const type of state.types) {
-    const typeKind = valueKindOfTypeName(type)
-    if (kind === undefined) {
-      kind = typeKind
-    } else if (kind !== typeKind) {
-      return undefined
-    }
-  }
-  return kind
-}
-
 function typeSpecifierParts(node: AstNode): string[] | undefined {
   if (node.kind === 'identifier') {
     return [node.name]