fhirpath-ts 0.0.0-bootstrap.0 → 0.2.0

package/src/engine/type-matching.ts

@@ -1,22 +1,14 @@
 import { FhirPathTypeError } from '../errors.ts'
-import { resolveByInput, type UnsatisfiedInput, unsatisfiedInput } from '../values/type-compat.ts'
+import {
+  resolveByInput,
+  SYSTEM_TYPE_LOCAL_NAMES,
+  type UnsatisfiedInput,
+  unsatisfiedInput,
+} from '../values/type-compat.ts'
 import { OBJECT_TYPE, type TypedValue, typeLocalName } from '../values/typed-value.ts'
 import type { EvaluationContext, HostFunction, HostSingleFunction } from './context.ts'
 
-const SYSTEM_LOCAL_NAMES = new Set([
-  'Any',
-  'Boolean',
-  'String',
-  'Integer',
-  'Long',
-  'Decimal',
-  'Date',
-  'DateTime',
-  'Time',
-  'Quantity',
-])
-
-const SYSTEM_LOCAL_NAMES_LOWER = new Set([...SYSTEM_LOCAL_NAMES].map(name => name.toLowerCase()))
+const SYSTEM_LOCAL_NAMES_LOWER = new Set([...SYSTEM_TYPE_LOCAL_NAMES].map(name => name.toLowerCase()))
 
 /** True when an unqualified name may mean a System primitive and requires exact `as`/`ofType` matching. */
 function isSystemAmbiguousName(name: string): boolean {
@@ -126,13 +118,15 @@ function* focusTypes(input: TypedValue[]): Iterable<string> {
 /** True when a single-part type name resolves in the model or the System namespace. */
 export function isKnownTypeName(context: EvaluationContext, parts: string[]): boolean {
   if (parts.length === 2) {
-    return parts[0] === 'System' ? SYSTEM_LOCAL_NAMES.has(parts[1] as string) : parts[0] === context.model?.namespace
+    return parts[0] === 'System'
+      ? SYSTEM_TYPE_LOCAL_NAMES.has(parts[1] as string)
+      : parts[0] === context.model?.namespace
   }
   const name = parts[0] as string
   if (context.model?.resolveType(name) !== undefined) {
     return true
   }
-  return SYSTEM_LOCAL_NAMES.has(name)
+  return SYSTEM_TYPE_LOCAL_NAMES.has(name)
 }
 
 function matchesSystemType(item: TypedValue, name: string): boolean {

package/src/index.ts

@@ -2,8 +2,11 @@ export type { CustomFunctionSignature, ValueArgSpec } from './analyzer/signature
 export type { BundleLike } from './api/bundle.ts'
 export type {
   AnyExpression,
+  CompiledExpressionResult,
   CustomFunction,
+  Declaring,
   EvaluateOptions,
+  InferredExpressionResult,
   OverloadedCustomFunction,
   SingleCustomFunction,
 } from './api/compile.ts'
@@ -11,7 +14,16 @@ export { compile, CompiledExpression, DEFAULT_PARSE_CACHE_SIZE } from './api/com
 export type { ConstraintCheckResult, ConstraintIssue, FhirConstraint, OperationOutcome } from './api/constraints.ts'
 export type { ColumnTypeMismatch, DtoBase, DtoClass, DtoEnv, DtoInstance, DtoOptions, DtoRow } from './api/dto.ts'
 export { column, criteria, defineDto } from './api/dto.ts'
-export type { EngineInput, EngineOptions, TypedEvaluateOptions } from './api/engine.ts'
+export type {
+  EngineExpression,
+  EngineInput,
+  EngineInputRoot,
+  EngineOptions,
+  EngineProjection,
+  EngineProjectionContext,
+  EngineResult,
+  TypedEvaluateOptions,
+} from './api/engine.ts'
 export { BoundExpression, FhirPathEngine, recordEngines } from './api/engine.ts'
 export { evaluate } from './api/evaluate.ts'
 export type { ColumnOptions, ColumnResult, Projection, ProjectionColumn, ProjectionColumns } from './api/project.ts'
@@ -23,7 +35,18 @@ export type { ElementInfo, ModelProvider } from './model/provider.ts'
 export type { AstNode } from './parser/ast.ts'
 export { parse } from './parser/parser.ts'
 export { printExpression } from './parser/printer.ts'
-export type { FhirpathInput, FhirpathResult, FhirpathResultIn, FhirTypeName } from './typed/infer.ts'
+export type { EmptyContextMap } from './typed/context-maps.ts'
+export type {
+  EmptyFhirpathTypeContext,
+  FhirpathFunctionDeclaration,
+  FhirpathInput,
+  FhirpathResult,
+  FhirpathResultIn,
+  FhirpathTypeContext,
+  FhirpathTypeDeclaration,
+  FhirpathTypeDeclarations,
+  FhirTypeName,
+} from './typed/infer.ts'
 export { Temporal } from './values/datetime.ts'
 export { Decimal } from './values/decimal.ts'
 export type { ValueKind } from './values/type-compat.ts'

package/src/parser/parser.ts

@@ -5,13 +5,11 @@ import { FhirPathSyntaxError, type SourceSpan } from '../errors.ts'
 import { tokenize } from '../lexer/lexer.ts'
 import { CALENDAR_DURATION_UNITS, type Token } from '../lexer/tokens.ts'
 import type { AstNode, BinaryOperator, TypeSpecifier, UnaryOperator } from './ast.ts'
-import { BindingPower, INFIX_BINDING_POWER } from './precedence.ts'
+import { INFIX_PARSELETS, type InfixParseletRecord, PREFIX_PARSELETS, type PrefixParseletRecord } from './precedence.ts'
 
 /** Keywords the grammar also accepts as element names, e.g. `'abc'.contains('b')`. */
 const KEYWORDS_USABLE_AS_IDENTIFIERS: ReadonlySet<string> = new Set(['as', 'contains', 'in', 'is'])
 
-const TYPE_OPERATORS: ReadonlySet<string> = new Set(['is', 'as'])
-
 /**
  * Nesting far beyond anything a real expression uses. Without a cap, adversarial
  * input like ((((…)))) overflows the call stack as a native RangeError instead of
@@ -47,13 +45,12 @@ class Parser {
       let left = this.parsePrefix()
       for (;;) {
         const token = this.peek()
-        const key = token.kind === 'operator' || token.kind === 'punct' || token.kind === 'keyword' ? token.text : ''
-        const bindingPower = INFIX_BINDING_POWER[key]
-        if (bindingPower === undefined || bindingPower <= minBindingPower) {
+        const parselet = this.infixParselet(token)
+        if (parselet === undefined || parselet.bindingPower <= minBindingPower) {
           return left
         }
         this.advance()
-        left = this.parseInfix(left, token, bindingPower)
+        left = this.parseInfix(left, token, parselet)
       }
     } finally {
       this.depth--
@@ -62,9 +59,29 @@ class Parser {
 
   private parsePrefix(): AstNode {
     const token = this.peek()
+    const parselet = this.prefixParselet(token)
+    if (parselet === undefined) {
+      throw this.error(token.kind === 'end' ? 'Unexpected end of expression' : `Unexpected '${token.text}'`, token)
+    }
+    switch (parselet.reducer) {
+      case 'identifier':
+        this.advance()
+        return parselet.tokenKind === 'variable'
+          ? { kind: 'special', name: token.value as 'this' | 'index' | 'total', span: token.span }
+          : { kind: 'identifier', name: token.value, span: token.span }
+      case 'literal':
+        return this.parseLiteral(token)
+      case 'unary':
+        return this.parseUnary(token, parselet)
+      case 'group':
+      case 'empty':
+      case 'external':
+        return this.parsePunctPrefix(token, parselet)
+    }
+  }
+
+  private parseLiteral(token: Token): AstNode {
     switch (token.kind) {
-      case 'end':
-        throw this.error('Unexpected end of expression', token)
       case 'number':
         return this.parseNumberOrQuantity()
       case 'string':
@@ -79,44 +96,18 @@ class Parser {
       case 'time':
         this.advance()
         return { kind: 'time', text: token.value, span: token.span }
-      case 'specialVariable':
-        this.advance()
-        return { kind: 'special', name: token.value as 'this' | 'index' | 'total', span: token.span }
-      case 'identifier':
-      case 'delimitedIdentifier':
-        this.advance()
-        return { kind: 'identifier', name: token.value, span: token.span }
       case 'keyword':
-        return this.parseKeywordPrefix(token)
-      case 'operator':
-        return this.parseUnary(token)
-      case 'punct':
-        return this.parsePunctPrefix(token)
-      /* v8 ignore start -- exhaustive fallback, every token kind has a case above */
+        this.advance()
+        return { kind: 'boolean', value: token.text === 'true', span: token.span }
+      /* v8 ignore next -- prefixTokenKind admits only literal token kinds here */
       default:
-        throw this.error(`Unexpected '${token.text}'`, token)
-      /* v8 ignore stop */
-    }
-  }
-
-  private parseKeywordPrefix(token: Token): AstNode {
-    if (token.text === 'true' || token.text === 'false') {
-      this.advance()
-      return { kind: 'boolean', value: token.text === 'true', span: token.span }
-    }
-    if (KEYWORDS_USABLE_AS_IDENTIFIERS.has(token.text)) {
-      this.advance()
-      return { kind: 'identifier', name: token.value, span: token.span }
+        throw new Error(`Invalid literal parselet for '${token.text}'`)
     }
-    throw this.error(`Unexpected '${token.text}'`, token)
   }
 
-  private parseUnary(token: Token): AstNode {
-    if (token.text !== '+' && token.text !== '-') {
-      throw this.error(`Unexpected '${token.text}'`, token)
-    }
+  private parseUnary(token: Token, parselet: Extract<PrefixParseletRecord, { reducer: 'unary' }>): AstNode {
     this.advance()
-    const operand = this.parseExpression(BindingPower.Unary)
+    const operand = this.parseExpression(parselet.bindingPower)
     return {
       kind: 'unary',
       operator: token.text as UnaryOperator,
@@ -125,21 +116,24 @@ class Parser {
     }
   }
 
-  private parsePunctPrefix(token: Token): AstNode {
-    switch (token.text) {
-      case '(': {
+  private parsePunctPrefix(
+    token: Token,
+    parselet: Extract<PrefixParseletRecord, { reducer: 'group' | 'empty' | 'external' }>
+  ): AstNode {
+    switch (parselet.reducer) {
+      case 'group': {
         this.advance()
         const inner = this.parseExpression(0)
         this.expect(')')
         this.parenthesized.add(inner)
         return inner
       }
-      case '{': {
+      case 'empty': {
         this.advance()
         const close = this.expect('}')
         return { kind: 'null', span: this.spanBetween(token.span, close.span) }
       }
-      case '%': {
+      case 'external': {
         this.advance()
         const name = this.peek()
         if (name.kind !== 'identifier' && name.kind !== 'delimitedIdentifier' && name.kind !== 'string') {
@@ -148,8 +142,6 @@ class Parser {
         this.advance()
         return { kind: 'external', name: name.value, span: this.spanBetween(token.span, name.span) }
       }
-      default:
-        throw this.error(`Unexpected '${token.text}'`, token)
     }
   }
 
@@ -184,40 +176,52 @@ class Parser {
     return { kind: 'number', text: token.value, isDecimal: token.value.includes('.'), span: token.span }
   }
 
-  private parseInfix(left: AstNode, token: Token, bindingPower: number): AstNode {
-    switch (token.text) {
-      case '.':
+  private parseInfix(left: AstNode, token: Token, parselet: InfixParseletRecord): AstNode {
+    switch (parselet.reducer) {
+      case 'dot':
         return this.parseDot(left)
-      case '[': {
+      case 'indexer': {
         const index = this.parseExpression(0)
         const close = this.expect(']')
         return { kind: 'indexer', target: left, index, span: this.spanBetween(left.span, close.span) }
       }
-      case '(':
+      case 'call':
         return this.parseCall(left)
-      default:
-        break
-    }
-    if (TYPE_OPERATORS.has(token.text)) {
-      const type = this.parseTypeSpecifier()
-      return {
-        kind: 'typeOp',
-        operator: token.text as 'is' | 'as',
-        operand: left,
-        type,
-        span: this.spanBetween(left.span, type.span),
+      case 'type': {
+        const type = this.parseTypeSpecifier()
+        return {
+          kind: 'typeOp',
+          operator: token.text as 'is' | 'as',
+          operand: left,
+          type,
+          span: this.spanBetween(left.span, type.span),
+        }
+      }
+      case 'binary': {
+        const right = this.parseExpression(parselet.bindingPower)
+        return {
+          kind: 'binary',
+          operator: token.text as BinaryOperator,
+          left,
+          right,
+          span: this.spanBetween(left.span, right.span),
+        }
       }
     }
-    // All FHIRPath binary operators are left-associative, so the right side
-    // parses at this operator's own binding power.
-    const right = this.parseExpression(bindingPower)
-    return {
-      kind: 'binary',
-      operator: token.text as BinaryOperator,
-      left,
-      right,
-      span: this.spanBetween(left.span, right.span),
-    }
+  }
+
+  private infixParselet(token: Token): InfixParseletRecord | undefined {
+    if (token.kind !== 'operator' && token.kind !== 'keyword' && token.kind !== 'punct') return undefined
+    const parselet = INFIX_PARSELETS[token.text as keyof typeof INFIX_PARSELETS] as InfixParseletRecord | undefined
+    return parselet?.tokenKind === token.kind ? parselet : undefined
+  }
+
+  private prefixParselet(token: Token): PrefixParseletRecord | undefined {
+    const tokenKind = prefixTokenKind(token)
+    if (tokenKind === undefined) return undefined
+    const key = tokenKind === 'operator' || tokenKind === 'punct' ? token.text : tokenKind
+    const parselet = PREFIX_PARSELETS[key as keyof typeof PREFIX_PARSELETS] as PrefixParseletRecord | undefined
+    return parselet?.tokenKind === tokenKind ? parselet : undefined
   }
 
   /**
@@ -315,6 +319,34 @@ class Parser {
   }
 }
 
+function prefixTokenKind(token: Token): PrefixParseletRecord['tokenKind'] | undefined {
+  switch (token.kind) {
+    case 'identifier':
+    case 'delimitedIdentifier':
+      return 'identifier'
+    case 'number':
+    case 'string':
+    case 'date':
+    case 'dateTime':
+    case 'time':
+      return 'literal'
+    case 'specialVariable':
+      return 'variable'
+    case 'operator':
+      return 'operator'
+    case 'punct':
+      return 'punct'
+    case 'keyword':
+      return token.text === 'true' || token.text === 'false'
+        ? 'literal'
+        : KEYWORDS_USABLE_AS_IDENTIFIERS.has(token.text)
+          ? 'identifier'
+          : undefined
+    case 'end':
+      return undefined
+  }
+}
+
 /** Parse a FHIRPath expression into its AST. Throws `FhirPathSyntaxError` with a position on bad input. */
 export function parse(source: string): AstNode {
   return new Parser(source).parse()

package/src/parser/precedence.ts

@@ -1,7 +1,8 @@
+import type { BinaryOperator } from './ast.ts'
+
 /**
- * Binding powers derived from the spec's 13-level operator precedence table
- * (https://hl7.org/fhirpath/#operator-precedence). Higher binds tighter; the
- * spec numbers levels the other way around (1 = `.`, 13 = `implies`).
+ * Binding powers derived from the spec's 13-level operator precedence table.
+ * Higher binds tighter; the spec numbers levels in the opposite direction.
  */
 export const BindingPower = {
   Implies: 1,
@@ -20,33 +21,249 @@ export const BindingPower = {
   FunctionCall: 14,
 } as const
 
-/** Binding power for every infix (and postfix) construct, keyed by token text. */
-export const INFIX_BINDING_POWER: Readonly<Record<string, number>> = {
-  implies: BindingPower.Implies,
-  or: BindingPower.OrXor,
-  xor: BindingPower.OrXor,
-  and: BindingPower.And,
-  in: BindingPower.Membership,
-  contains: BindingPower.Membership,
-  '=': BindingPower.Equality,
-  '~': BindingPower.Equality,
-  '!=': BindingPower.Equality,
-  '!~': BindingPower.Equality,
-  '<': BindingPower.Comparison,
-  '>': BindingPower.Comparison,
-  '<=': BindingPower.Comparison,
-  '>=': BindingPower.Comparison,
-  '|': BindingPower.Union,
-  is: BindingPower.TypeOps,
-  as: BindingPower.TypeOps,
-  '+': BindingPower.Additive,
-  '-': BindingPower.Additive,
-  '&': BindingPower.Additive,
-  '*': BindingPower.Multiplicative,
-  '/': BindingPower.Multiplicative,
-  div: BindingPower.Multiplicative,
-  mod: BindingPower.Multiplicative,
-  '[': BindingPower.Indexer,
-  '.': BindingPower.Dot,
-  '(': BindingPower.FunctionCall,
-}
+export type InfixParseletRecord =
+  | {
+      tokenKind: 'operator' | 'keyword'
+      fixity: 'infix'
+      bindingPower: number
+      associativity: 'left'
+      rhs: 'expression'
+      reducer: 'binary'
+    }
+  | {
+      tokenKind: 'keyword'
+      fixity: 'infix'
+      bindingPower: number
+      associativity: 'left'
+      rhs: 'type-name'
+      reducer: 'type'
+    }
+  | {
+      tokenKind: 'punct'
+      fixity: 'infix'
+      bindingPower: number
+      associativity: 'left'
+      rhs: 'path'
+      reducer: 'dot'
+    }
+  | {
+      tokenKind: 'punct'
+      fixity: 'postfix'
+      bindingPower: number
+      associativity: 'left'
+      rhs: 'index'
+      reducer: 'indexer'
+    }
+  | {
+      tokenKind: 'punct'
+      fixity: 'postfix'
+      bindingPower: number
+      associativity: 'left'
+      rhs: 'arguments'
+      reducer: 'call'
+    }
+
+export type PrefixParseletRecord =
+  | {
+      tokenKind: 'identifier' | 'variable'
+      fixity: 'prefix'
+      bindingPower: number
+      associativity: 'none'
+      rhs: 'none'
+      reducer: 'identifier'
+    }
+  | {
+      tokenKind: 'literal'
+      fixity: 'prefix'
+      bindingPower: number
+      associativity: 'none'
+      rhs: 'none'
+      reducer: 'literal'
+    }
+  | {
+      tokenKind: 'operator'
+      fixity: 'prefix'
+      bindingPower: number
+      associativity: 'right'
+      rhs: 'expression'
+      reducer: 'unary'
+    }
+  | {
+      tokenKind: 'punct'
+      fixity: 'prefix'
+      bindingPower: number
+      associativity: 'none'
+      rhs: 'group'
+      reducer: 'group'
+    }
+  | {
+      tokenKind: 'punct'
+      fixity: 'prefix'
+      bindingPower: number
+      associativity: 'none'
+      rhs: 'none'
+      reducer: 'empty'
+    }
+  | {
+      tokenKind: 'punct'
+      fixity: 'prefix'
+      bindingPower: number
+      associativity: 'none'
+      rhs: 'external-name'
+      reducer: 'external'
+    }
+
+/** Single source of truth for tokens and token kinds accepted before an operand. */
+export const PREFIX_PARSELETS = {
+  identifier: {
+    tokenKind: 'identifier',
+    fixity: 'prefix',
+    bindingPower: 0,
+    associativity: 'none',
+    rhs: 'none',
+    reducer: 'identifier',
+  },
+  literal: {
+    tokenKind: 'literal',
+    fixity: 'prefix',
+    bindingPower: 0,
+    associativity: 'none',
+    rhs: 'none',
+    reducer: 'literal',
+  },
+  variable: {
+    tokenKind: 'variable',
+    fixity: 'prefix',
+    bindingPower: 0,
+    associativity: 'none',
+    rhs: 'none',
+    reducer: 'identifier',
+  },
+  '+': {
+    tokenKind: 'operator',
+    fixity: 'prefix',
+    bindingPower: BindingPower.Unary,
+    associativity: 'right',
+    rhs: 'expression',
+    reducer: 'unary',
+  },
+  '-': {
+    tokenKind: 'operator',
+    fixity: 'prefix',
+    bindingPower: BindingPower.Unary,
+    associativity: 'right',
+    rhs: 'expression',
+    reducer: 'unary',
+  },
+  '(': {
+    tokenKind: 'punct',
+    fixity: 'prefix',
+    bindingPower: 0,
+    associativity: 'none',
+    rhs: 'group',
+    reducer: 'group',
+  },
+  '{': {
+    tokenKind: 'punct',
+    fixity: 'prefix',
+    bindingPower: 0,
+    associativity: 'none',
+    rhs: 'none',
+    reducer: 'empty',
+  },
+  '%': {
+    tokenKind: 'punct',
+    fixity: 'prefix',
+    bindingPower: 0,
+    associativity: 'none',
+    rhs: 'external-name',
+    reducer: 'external',
+  },
+} as const satisfies Record<string, PrefixParseletRecord>
+
+const binary = (
+  tokenKind: 'operator' | 'keyword',
+  bindingPower: number
+): Extract<InfixParseletRecord, { reducer: 'binary' }> => ({
+  tokenKind,
+  fixity: 'infix',
+  bindingPower,
+  associativity: 'left',
+  rhs: 'expression',
+  reducer: 'binary',
+})
+
+/** Single source of truth for every token accepted after an operand. */
+export const INFIX_PARSELETS = {
+  implies: binary('keyword', BindingPower.Implies),
+  or: binary('keyword', BindingPower.OrXor),
+  xor: binary('keyword', BindingPower.OrXor),
+  and: binary('keyword', BindingPower.And),
+  in: binary('keyword', BindingPower.Membership),
+  contains: binary('keyword', BindingPower.Membership),
+  '=': binary('operator', BindingPower.Equality),
+  '~': binary('operator', BindingPower.Equality),
+  '!=': binary('operator', BindingPower.Equality),
+  '!~': binary('operator', BindingPower.Equality),
+  '<': binary('operator', BindingPower.Comparison),
+  '>': binary('operator', BindingPower.Comparison),
+  '<=': binary('operator', BindingPower.Comparison),
+  '>=': binary('operator', BindingPower.Comparison),
+  '|': binary('operator', BindingPower.Union),
+  is: {
+    tokenKind: 'keyword',
+    fixity: 'infix',
+    bindingPower: BindingPower.TypeOps,
+    associativity: 'left',
+    rhs: 'type-name',
+    reducer: 'type',
+  },
+  as: {
+    tokenKind: 'keyword',
+    fixity: 'infix',
+    bindingPower: BindingPower.TypeOps,
+    associativity: 'left',
+    rhs: 'type-name',
+    reducer: 'type',
+  },
+  '+': binary('operator', BindingPower.Additive),
+  '-': binary('operator', BindingPower.Additive),
+  '&': binary('operator', BindingPower.Additive),
+  '*': binary('operator', BindingPower.Multiplicative),
+  '/': binary('operator', BindingPower.Multiplicative),
+  div: binary('keyword', BindingPower.Multiplicative),
+  mod: binary('keyword', BindingPower.Multiplicative),
+  '[': {
+    tokenKind: 'punct',
+    fixity: 'postfix',
+    bindingPower: BindingPower.Indexer,
+    associativity: 'left',
+    rhs: 'index',
+    reducer: 'indexer',
+  },
+  '.': {
+    tokenKind: 'punct',
+    fixity: 'infix',
+    bindingPower: BindingPower.Dot,
+    associativity: 'left',
+    rhs: 'path',
+    reducer: 'dot',
+  },
+  '(': {
+    tokenKind: 'punct',
+    fixity: 'postfix',
+    bindingPower: BindingPower.FunctionCall,
+    associativity: 'left',
+    rhs: 'arguments',
+    reducer: 'call',
+  },
+} as const satisfies Record<string, InfixParseletRecord>
+
+/** Compatibility view used by callers that only need precedence. */
+export const INFIX_BINDING_POWER: Readonly<Record<string, number>> = Object.fromEntries(
+  Object.entries(INFIX_PARSELETS).map(([token, record]) => [token, record.bindingPower])
+)
+
+/** Compile-time coverage: every binary AST operator has a binary parselet. */
+const _binaryOperatorCoverage: Record<BinaryOperator, InfixParseletRecord> = INFIX_PARSELETS
+void _binaryOperatorCoverage