@atomic-ehr/fhirpath 0.0.2 → 0.0.3-canary.2be66fb.20250905161900

package/src/registry.ts

@@ -161,7 +161,7 @@ export class Registry {
   /**
    * Get functions applicable to a specific type
    */
-  getFunctionsForType(typeName: TypeName | string): FunctionDefinition[] {
+  getFunctionsForType = (typeName: TypeName | string): FunctionDefinition[] => {
     const results: FunctionDefinition[] = [];
     
     for (const [_, func] of this.functions) {
@@ -200,53 +200,64 @@ export class Registry {
   /**
    * Check if a function is applicable to a type
    */
-  isFunctionApplicableToType(functionName: string, typeName: TypeName | string): boolean {
+  private getTypeInfoFromString(type: string): TypeInfo {
+    const isCollection = type.endsWith('[]');
+    const typeName = isCollection ? type.slice(0, -2) : type;
+    return {
+      type: typeName as TypeName,
+      singleton: !isCollection,
+    };
+  }
+
+  public isTypeCompatible(inputType: TypeInfo, requiredType: TypeInfo): boolean {
+    // Check singleton compatibility
+    if (requiredType.singleton && !inputType.singleton) {
+      return false;
+    }
+
+    const numericTypes: TypeName[] = ['Integer', 'Decimal'];
+    const temporalTypes: TypeName[] = ['Date', 'DateTime', 'Time'];
+
+    // 'Any' type is always compatible
+    if (requiredType.type === 'Any') {
+      return true;
+    }
+
+    // Direct type match
+    if (inputType.type === requiredType.type) {
+      return true;
+    }
+
+    // Numeric types are compatible with each other
+    if (numericTypes.includes(inputType.type) && numericTypes.includes(requiredType.type)) {
+      return true;
+    }
+
+    // Temporal types are compatible with each other
+    if (temporalTypes.includes(inputType.type) && temporalTypes.includes(requiredType.type)) {
+      return true;
+    }
+
+    // TODO: Add model-aware subtype checking here
+    // For now, we only handle the above cases.
+    // A full implementation would require a ModelProvider to check subtype relationships.
+
+    return false;
+  }
+
+  isFunctionApplicableToType(functionName: string, type: string): boolean {
     const func = this.getFunction(functionName);
     if (!func) return false;
-    
-    // If no signatures, function works with any type
-    if (!func.signatures || func.signatures.length === 0) return true;
-    
-    // Check if we're dealing with a collection type
-    const isCollection = typeof typeName === 'string' && typeName.endsWith('[]');
-    
-    // Check if ANY signature matches the type
+
+    // New logic: check all signatures
     for (const signature of func.signatures) {
-      // If no input type specified, this signature works with any type
-      if (!signature.input) return true;
-      
-      const inputType = signature.input.type;
-      const requiresSingleton = signature.input.singleton;
-      
-      // If function requires singleton but we have a collection, skip this signature
-      if (requiresSingleton && isCollection) {
-        continue;
-      }
-      
-      // 'Any' type accepts all inputs (but still respects singleton constraint checked above)
-      if (inputType === 'Any') return true;
-      
-      // Direct type match
-      if (inputType === typeName) return true;
-      
-      // For collection types, check if function can work with collections
-      if (typeof typeName === 'string' && typeName.endsWith('[]')) {
-        const itemType = typeName.slice(0, -2);
-        // Only allow if function doesn't require singleton
-        if (inputType === itemType && !requiresSingleton) {
-          return true;
-        }
-      }
-      
-      // Check if it's a numeric type and function accepts numeric types
-      const numericTypes = ['Integer', 'Decimal', 'Number'];
-      if (numericTypes.includes(typeName as string) && numericTypes.includes(inputType as string)) {
+      if (!signature.input) {
+        // No input constraint, so it's applicable
         return true;
       }
       
-      // Check if it's a temporal type and function accepts temporal types
-      const temporalTypes = ['Date', 'DateTime', 'Time', 'Instant'];
-      if (temporalTypes.includes(typeName as string) && temporalTypes.includes(inputType as string)) {
+      const inputType = this.getTypeInfoFromString(type);
+      if (this.isTypeCompatible(inputType, signature.input)) {
         return true;
       }
     }

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { Token, TokenType } from './lexer';
+import type { AnyCursorNode } from './parser/cursor-nodes';
 
 // Precedence levels (higher number = higher precedence)
 export enum PRECEDENCE {
@@ -25,6 +26,9 @@ export interface TypeInfo<TypeContext = unknown> {
   // FHIRPath type
   type: TypeName;
   singleton?: boolean;
+  
+  // Indicates this is definitely an empty collection
+  isEmpty?: boolean;
 
   // Model type information FHIR.Patient; FHIR.string; 
   namespace?: string;
@@ -77,6 +81,7 @@ export interface OperatorSignature {
 export interface OperatorDefinition {
   symbol: string;
   name: string;
+  doesNotPropagateEmpty?: boolean;
   category: string[];
   precedence: PRECEDENCE;
   associativity: 'left' | 'right';
@@ -97,6 +102,7 @@ export interface FunctionSignature {
     optional?: boolean;
     type: TypeInfo;
     expression?: boolean;
+    typeReference?: boolean; // When true, this parameter expects a type name (e.g., ofType(Patient))
   }>;
   result: TypeInfo | 'inputType' | 'inputTypeSingleton' | 'parameterType';
 }
@@ -108,6 +114,16 @@ export interface FunctionDefinition {
   examples: string[];
   signatures: FunctionSignature[];
   evaluate: FunctionEvaluator;
+  inferResultType?: (
+    analyzer: any,
+    node: any,
+    inputType?: TypeInfo
+  ) => Promise<TypeInfo>;
+  analyze?: (
+    context: AnalysisContext,
+    args: ASTNode[]
+  ) => Promise<InternalAnalysisResult> | InternalAnalysisResult;
+  doesNotPropagateEmpty?: boolean;  // When true, function doesn't propagate empty collections
 }
 
 // Node types enum - string-based for better debugging
@@ -115,9 +131,9 @@ export enum NodeType {
   EOF = 'EOF',
   Binary = 'Binary',
   Unary = 'Unary',
-  TypeOrIdentifier = 'TypeOrIdentifier',
   Identifier = 'Identifier',
   Literal = 'Literal',
+  TemporalLiteral = 'TemporalLiteral',
   Function = 'Function',
   Variable = 'Variable',
   Index = 'Index',
@@ -170,7 +186,7 @@ export interface ParserOptions {
 // Base structure for all AST nodes
 export interface BaseASTNode {
   // Core properties - always present
-  type: NodeType | 'Error';
+  type: NodeType | 'Error' | 'CursorNode';
   
   // LSP-compatible range - always present for LSP features
   range: Range;
@@ -211,15 +227,17 @@ export interface IdentifierNode extends BaseASTNode {
   symbolKind?: SymbolKind.Variable | SymbolKind.Function | SymbolKind.Property;
 }
 
-export interface TypeOrIdentifierNode extends BaseASTNode {
-  type: NodeType.TypeOrIdentifier;
-  name: string;
-}
-
 export interface LiteralNode extends BaseASTNode {
   type: NodeType.Literal;
   value: any;
-  valueType: 'string' | 'number' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
+  valueType: 'string' | 'number' | 'decimal' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
+}
+
+export interface TemporalLiteralNode extends BaseASTNode {
+  type: NodeType.TemporalLiteral;
+  value: any; // The parsed temporal object
+  valueType: 'date' | 'time' | 'datetime';
+  rawValue: string; // The original string value (without @)
 }
 
 export interface BinaryNode extends BaseASTNode {
@@ -281,14 +299,13 @@ export interface QuantityNode extends BaseASTNode {
   type: NodeType.Quantity;
   value: number;
   unit: string;
-  isCalendarUnit?: boolean;
 }
 
 // Unified ASTNode type - discriminated union
 export type ASTNode = 
   | IdentifierNode
-  | TypeOrIdentifierNode
   | LiteralNode
+  | TemporalLiteralNode
   | BinaryNode
   | UnaryNode
   | FunctionNode
@@ -299,7 +316,8 @@ export type ASTNode =
   | CollectionNode
   | TypeReferenceNode
   | QuantityNode
-  | ErrorNode;
+  | ErrorNode
+  | AnyCursorNode;
 
 export interface RuntimeContext {
   input: any[];
@@ -311,7 +329,7 @@ export interface RuntimeContext {
 
 // Evaluation result - everything is a collection of boxed values
 export interface EvaluationResult {
-  value: import('./boxing').FHIRPathValue[];
+  value: import('./interpreter/boxing').FHIRPathValue[];
   context: RuntimeContext;
 }
 
@@ -337,6 +355,8 @@ export interface Diagnostic {
 export interface AnalysisResult {
   diagnostics: Diagnostic[];
   ast: ASTNode;
+  type?: TypeInfo;
+  userVariables?: Map<string, TypeInfo>;
 }
 
 // Parse error type
@@ -353,7 +373,7 @@ export interface ParseResult {
   errors: ParseError[];
   indexes?: {
     nodeById: Map<string, ASTNode>;
-    nodesByType: Map<NodeType | 'Error', ASTNode[]>;
+    nodesByType: Map<NodeType | 'Error' | 'CursorNode', ASTNode[]>;
     identifiers: Map<string, ASTNode[]>;
   };
   cursorContext?: {
@@ -363,15 +383,15 @@ export interface ParseResult {
   };
 }
 
-export type NodeEvaluator = (node: ASTNode, input: import('./boxing').FHIRPathValue[], context: RuntimeContext) => Promise<EvaluationResult>;
+export type NodeEvaluator = (node: ASTNode, input: import('./interpreter/boxing').FHIRPathValue[], context: RuntimeContext) => Promise<EvaluationResult>;
 
-export type OperationEvaluator = (input: import('./boxing').FHIRPathValue[], context: RuntimeContext, ...args: any[]) => Promise<EvaluationResult>;
+export type OperationEvaluator = (input: import('./interpreter/boxing').FHIRPathValue[], context: RuntimeContext, ...args: any[]) => Promise<EvaluationResult>;
 
 export type FunctionEvaluator = (
-  input: import('./boxing').FHIRPathValue[],
+  input: import('./interpreter/boxing').FHIRPathValue[],
   context: RuntimeContext,
   args: ASTNode[],
-  evaluator: (node: ASTNode, input: import('./boxing').FHIRPathValue[], context: RuntimeContext) => Promise<EvaluationResult>
+  evaluator: (node: ASTNode, input: import('./interpreter/boxing').FHIRPathValue[], context: RuntimeContext) => Promise<EvaluationResult>
 ) => Promise<EvaluationResult>;
 
 // Type guards for optional properties
@@ -403,3 +423,95 @@ export function isFunctionNode(node: ASTNode): node is FunctionNode {
   return node.type === NodeType.Function;
 }
 
+/**
+ * Result of analyzing a single AST node in the context-flow architecture.
+ */
+export interface InternalAnalysisResult {
+  type: TypeInfo;
+  diagnostics: Diagnostic[];
+  context?: AnalysisContext;
+}
+
+/**
+ * Immutable context that flows through the analysis tree.
+ * Carries variable scopes and input types through the AST.
+ */
+export class AnalysisContext {
+  constructor(
+    public readonly inputType: TypeInfo,
+    public readonly systemVariables: ReadonlyMap<string, TypeInfo>,
+    public readonly userVariables: ReadonlyMap<string, TypeInfo>,
+    private readonly analyzeNodeCallback: (node: ASTNode, ctx: AnalysisContext) => Promise<InternalAnalysisResult>,
+    public readonly modelProvider?: ModelProvider,
+    public readonly hasDynamicVariables: boolean = false,
+    public readonly _chainHead: boolean = true
+  ) {}
+
+  withUserVariable(name: string, type: TypeInfo): AnalysisContext {
+    const newUserVars = new Map(this.userVariables);
+    newUserVars.set(name, type);
+    return new AnalysisContext(
+      this.inputType,
+      this.systemVariables,
+      newUserVars,
+      this.analyzeNodeCallback,
+      this.modelProvider,
+      this.hasDynamicVariables,
+      this._chainHead
+    );
+  }
+
+  withSystemVariable(name: string, type: TypeInfo): AnalysisContext {
+    const newSystemVars = new Map(this.systemVariables);
+    newSystemVars.set(name, type);
+    return new AnalysisContext(
+      this.inputType,
+      newSystemVars,
+      this.userVariables,
+      this.analyzeNodeCallback,
+      this.modelProvider,
+      this.hasDynamicVariables,
+      this._chainHead
+    );
+  }
+
+  withInputType(type: TypeInfo): AnalysisContext {
+    return new AnalysisContext(
+      type,
+      this.systemVariables,
+      this.userVariables,
+      this.analyzeNodeCallback,
+      this.modelProvider,
+      this.hasDynamicVariables,
+      false
+    );
+  }
+
+  withDynamicVariables(): AnalysisContext {
+    return new AnalysisContext(
+      this.inputType,
+      this.systemVariables,
+      this.userVariables,
+      this.analyzeNodeCallback,
+      this.modelProvider,
+      true,
+      this._chainHead
+    );
+  }
+
+  fork(): AnalysisContext {
+    return new AnalysisContext(
+      this.inputType,
+      new Map(this.systemVariables),
+      new Map(this.userVariables),
+      this.analyzeNodeCallback,
+      this.modelProvider,
+      this.hasDynamicVariables,
+      this._chainHead
+    );
+  }
+
+  analyzeNode(node: ASTNode): Promise<InternalAnalysisResult> {
+    return this.analyzeNodeCallback(node, this);
+  }
+}

package/src/utils/decimal.ts

@@ -0,0 +1,76 @@
+/**
+ * Utility functions for handling decimal precision in FHIRPath
+ */
+
+/**
+ * Get the number of decimal places in a number
+ */
+export function getDecimalPlaces(n: number): number {
+  if (Number.isInteger(n)) {
+    return 0;
+  }
+  
+  // Convert to string and count decimal places
+  // Use toFixed(10) then strip trailing zeros to get actual precision
+  const str = n.toFixed(10).replace(/0+$/, '').replace(/\.$/, '');
+  const decimalIndex = str.indexOf('.');
+  
+  if (decimalIndex === -1) {
+    return 0;
+  }
+  
+  return str.length - decimalIndex - 1;
+}
+
+/**
+ * Round a number to a specific number of decimal places
+ */
+export function roundToDecimalPlaces(n: number, places: number): number {
+  if (places < 0) {
+    throw new Error('Decimal places must be non-negative');
+  }
+  
+  const multiplier = Math.pow(10, places);
+  return Math.round(n * multiplier) / multiplier;
+}
+
+/**
+ * Normalize a decimal result based on the precision of the operands
+ * According to FHIRPath spec, arithmetic operations should preserve
+ * the appropriate precision based on the input values
+ */
+export function normalizeDecimalResult(result: number, leftOperand: number, rightOperand: number): number {
+  // If result is effectively an integer, return it as is
+  if (Number.isInteger(result)) {
+    return result;
+  }
+  
+  // Get the precision of both operands
+  const leftPlaces = getDecimalPlaces(leftOperand);
+  const rightPlaces = getDecimalPlaces(rightOperand);
+  
+  // For addition and subtraction, use the maximum precision
+  // For multiplication, sum the precisions
+  // For division and modulo, use a reasonable precision (8 decimal places max)
+  const maxPrecision = Math.max(leftPlaces, rightPlaces);
+  
+  // Round to the appropriate precision to eliminate floating point artifacts
+  return roundToDecimalPlaces(result, Math.min(maxPrecision, 8));
+}
+
+/**
+ * Normalize a decimal for modulo operation
+ * Modulo has special precision rules
+ */
+export function normalizeModuloResult(result: number, leftOperand: number, rightOperand: number): number {
+  // If result is effectively an integer, return it as is
+  if (Number.isInteger(result)) {
+    return result;
+  }
+  
+  // For modulo, use the precision of the divisor (right operand)
+  const rightPlaces = getDecimalPlaces(rightOperand);
+  
+  // Round to the appropriate precision
+  return roundToDecimalPlaces(result, Math.min(rightPlaces, 8));
+}

package/src/utils/pprint.ts

@@ -0,0 +1,151 @@
+import { NodeType } from '../types';
+import type {
+  ASTNode,
+  IdentifierNode,
+  LiteralNode,
+  UnaryNode,
+  BinaryNode,
+  FunctionNode,
+  IndexNode,
+  MembershipTestNode,
+  TypeCastNode,
+  CollectionNode,
+  TypeReferenceNode,
+  QuantityNode,
+} from '../types';
+
+export function pprint(node: ASTNode, indent: number = 0): string {
+  const spaces = ' '.repeat(indent);
+
+  switch (node.type) {
+    case NodeType.Literal: {
+      const lit = node as LiteralNode;
+      if (lit.valueType === 'string') {
+        return `"${lit.value}"`;
+      } else if (lit.valueType === 'null') {
+        return 'null';
+      }
+      return String(lit.value);
+    }
+
+    case NodeType.Identifier: {
+      const id = node as IdentifierNode;
+      return id.name;
+    }
+
+    case NodeType.Variable: {
+      return (node as any).name;
+    }
+
+    case NodeType.Binary: {
+      const bin = node as BinaryNode;
+      const op = bin.operator;
+
+      const leftStr = pprint(bin.left, 0);
+      const rightStr = pprint(bin.right, 0);
+
+      if (leftStr.length + rightStr.length + op.length + 4 < 60 &&
+          !leftStr.includes('\n') && !rightStr.includes('\n')) {
+        return `(${op} ${leftStr} ${rightStr})`;
+      }
+
+      return `(${op}\n${spaces}  ${pprint(bin.left, indent + 2)}\n${spaces}  ${pprint(bin.right, indent + 2)})`;
+    }
+
+    case NodeType.Unary: {
+      const un = node as UnaryNode;
+      const operandStr = pprint(un.operand, 0);
+
+      if (operandStr.length < 40 && !operandStr.includes('\n')) {
+        return `(${un.operator} ${operandStr})`;
+      }
+
+      return `(${un.operator}\n${spaces}  ${pprint(un.operand, indent + 2)})`;
+    }
+
+    case NodeType.Function: {
+      const fn = node as FunctionNode;
+      const nameStr = pprint(fn.name, 0);
+
+      if (fn.arguments.length === 0) {
+        return `(${nameStr})`;
+      }
+
+      const argStrs = fn.arguments.map(arg => pprint(arg, 0));
+      const totalLen = nameStr.length + argStrs.reduce((sum, s) => sum + s.length + 1, 0) + 2;
+
+      if (totalLen < 60 && argStrs.every(s => !s.includes('\n'))) {
+        return `(${nameStr} ${argStrs.join(' ')})`;
+      }
+
+      const argLines = fn.arguments.map(arg => `${spaces}  ${pprint(arg, indent + 2)}`);
+      return `(${nameStr}\n${argLines.join('\n')})`;
+    }
+
+    case NodeType.Index: {
+      const idx = node as IndexNode;
+      const exprStr = pprint(idx.expression, 0);
+      const indexStr = pprint(idx.index, 0);
+
+      if (exprStr.length + indexStr.length < 50 &&
+          !exprStr.includes('\n') && !indexStr.includes('\n')) {
+        return `([] ${exprStr} ${indexStr})`;
+      }
+
+      return `([]\n${spaces}  ${pprint(idx.expression, indent + 2)}\n${spaces}  ${pprint(idx.index, indent + 2)})`;
+    }
+
+    case NodeType.MembershipTest: {
+      const mt = node as MembershipTestNode;
+      const exprStr = pprint(mt.expression, 0);
+
+      if (exprStr.length + mt.targetType.length < 50 && !exprStr.includes('\n')) {
+        return `(is ${exprStr} ${mt.targetType})`;
+      }
+
+      return `(is\n${spaces}  ${pprint(mt.expression, indent + 2)}\n${spaces}  ${mt.targetType})`;
+    }
+
+    case NodeType.TypeCast: {
+      const tc = node as TypeCastNode;
+      const exprStr = pprint(tc.expression, 0);
+
+      if (exprStr.length + tc.targetType.length < 50 && !exprStr.includes('\n')) {
+        return `(as ${exprStr} ${tc.targetType})`;
+      }
+
+      return `(as\n${spaces}  ${pprint(tc.expression, indent + 2)}\n${spaces}  ${tc.targetType})`;
+    }
+
+    case NodeType.Collection: {
+      const coll = node as CollectionNode;
+
+      if (coll.elements.length === 0) {
+        return '{}';
+      }
+
+      const elemStrs = coll.elements.map(e => pprint(e, 0));
+      const totalLen = elemStrs.reduce((sum, s) => sum + s.length + 1, 2);
+
+      if (totalLen < 60 && elemStrs.every(s => !s.includes('\n'))) {
+        return `{${elemStrs.join(' ')}}`;
+      }
+
+      const elemLines = coll.elements.map(e => `${spaces}  ${pprint(e, indent + 2)}`);
+      return `{\n${elemLines.join('\n')}\n${spaces}}`;
+    }
+
+    case NodeType.TypeReference: {
+      const tr = node as TypeReferenceNode;
+      return `Type[${tr.typeName}]`;
+    }
+
+    case NodeType.Quantity: {
+      const q = node as QuantityNode;
+      return `${q.value} '${q.unit}'`;
+    }
+
+    default:
+      return `<unknown:${(node as any).type}>`;
+  }
+}