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

package/src/operations/iif-function.ts

@@ -1,8 +1,10 @@
-import type { FunctionDefinition } from '../types';
-import { Errors } from '../errors';
+import type { FunctionDefinition, AnalysisContext, InternalAnalysisResult } from '../types';
+import { Errors, ErrorCodes } from '../errors';
 import type { FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
-import { RuntimeContextManager } from '../interpreter';
+import { box, unbox } from '../interpreter/boxing';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
+import { NodeType } from '../parser';
+import { DiagnosticSeverity } from '../types';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (args.length < 2) {
@@ -15,7 +17,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
   // Check for multiple items in input collection
   if (input.length > 1) {
-    throw Errors.invalidOperation('iif can only be used on single item or empty collections');
+    throw Errors.emptyNotAllowed('iif');
   }
 
   // Always evaluate condition
@@ -35,6 +37,12 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   
   const condResult = await evaluator(condExpr, input, evalContext);
   
+  // Check if condition is a singleton boolean
+  if (condResult.value.length > 1) {
+    // Multiple items in condition - should error per spec
+    throw Errors.invalidOperation('iif condition must be a single boolean value');
+  }
+  
   // Empty condition is treated as false
   if (condResult.value.length === 0) {
     // If no else expression provided, return empty
@@ -54,7 +62,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   
   // Check if condition is a boolean
   if (typeof condition !== 'boolean') {
-    // Non-boolean criteria returns empty
+    // Non-boolean singleton returns empty per FHIRPath spec behavior
     return { value: [], context };
   }
   
@@ -72,6 +80,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const iifFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'iif',
+  doesNotPropagateEmpty: true,  // iif evaluates even with empty input
   category: ['control'],
   description: 'If-then-else expression (immediate if)',
   examples: ['iif(gender = "male", "Mr.", "Ms.")'],
@@ -86,5 +95,181 @@ export const iifFunction: FunctionDefinition & { evaluate: FunctionEvaluator } =
     ],
     result: { type: 'Any', singleton: false },
   }],
-  evaluate
-};
+  evaluate,
+  
+  /**
+   * Analysis-time behavior for iif with lazy evaluation.
+   * Only analyzes reachable branches when condition is a literal.
+   */
+  async analyze(context: AnalysisContext, args): Promise<InternalAnalysisResult> {
+    const diagnostics: any[] = [];
+    
+    // Validate argument count
+    if (args.length < 2) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'iif requires at least 2 arguments',
+          severity: DiagnosticSeverity.Error,
+          code: ErrorCodes.WRONG_ARGUMENT_COUNT,
+          source: 'fhirpath',
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    
+    if (args.length > 3) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'iif takes at most 3 arguments',
+          severity: DiagnosticSeverity.Error,
+          code: ErrorCodes.WRONG_ARGUMENT_COUNT,
+          source: 'fhirpath',
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    
+    // Analyze condition
+    const conditionArg = args[0];
+    if (!conditionArg) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'iif requires a condition argument',
+          severity: DiagnosticSeverity.Error,
+          code: ErrorCodes.WRONG_ARGUMENT_COUNT,
+          source: 'fhirpath',
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    const condResult = await context.analyzeNode(conditionArg);
+    diagnostics.push(...condResult.diagnostics);
+    
+    // Check if condition is a literal boolean
+    let isLiteralTrue = false;
+    let isLiteralFalse = false;
+    
+    if (conditionArg.type === NodeType.Literal) {
+      const literalValue = (conditionArg as any).value;
+      if (literalValue === true) {
+        isLiteralTrue = true;
+      } else if (literalValue === false) {
+        isLiteralFalse = true;
+      }
+    }
+    
+    let trueBranchType = { type: 'Any', singleton: false } as any;
+    let falseBranchType = { type: 'Any', singleton: false } as any;
+    
+    // Lazy evaluation: only analyze reachable branches
+    if (isLiteralTrue) {
+      // Only true branch is reachable
+      const trueBranch = args[1];
+      if (!trueBranch) {
+        return {
+          type: { type: 'Any', singleton: false },
+          diagnostics
+        };
+      }
+      const trueBranchResult = await context.analyzeNode(trueBranch);
+      diagnostics.push(...trueBranchResult.diagnostics);
+      trueBranchType = trueBranchResult.type;
+      
+      // Warn about unreachable false branch
+      if (args.length === 3 && args[2]) {
+        diagnostics.push({
+          message: 'Unreachable code: false branch will never execute',
+          severity: DiagnosticSeverity.Warning,
+          code: ErrorCodes.UNREACHABLE_CODE,
+          source: 'fhirpath',
+          range: args[2].range || { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        });
+      }
+      
+      return { type: trueBranchType, diagnostics };
+    } else if (isLiteralFalse) {
+      // Only false branch is reachable (if it exists)
+      // Warn about unreachable true branch
+      const trueBranch = args[1];
+      if (trueBranch) {
+        diagnostics.push({
+          message: 'Unreachable code: true branch will never execute',
+          severity: DiagnosticSeverity.Warning,
+          code: ErrorCodes.UNREACHABLE_CODE,
+          source: 'fhirpath',
+          range: trueBranch.range || { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        });
+      }
+      
+      if (args.length === 3 && args[2]) {
+        const falseBranchResult = await context.analyzeNode(args[2]);
+        diagnostics.push(...falseBranchResult.diagnostics);
+        falseBranchType = falseBranchResult.type;
+        return { type: falseBranchType, diagnostics };
+      } else {
+        // No else branch, return empty
+        return { type: { type: 'Any', singleton: false }, diagnostics };
+      }
+    } else {
+      // Dynamic condition: analyze both branches
+      const trueBranch = args[1];
+      if (trueBranch) {
+        const trueBranchResult = await context.analyzeNode(trueBranch);
+        diagnostics.push(...trueBranchResult.diagnostics);
+        trueBranchType = trueBranchResult.type;
+      }
+      
+      if (args.length === 3 && args[2]) {
+        const falseBranchResult = await context.analyzeNode(args[2]);
+        diagnostics.push(...falseBranchResult.diagnostics);
+        falseBranchType = falseBranchResult.type;
+        
+        // Result type is the union of both branches
+        // For now, if they differ, return Any
+        if (trueBranchType.type === falseBranchType.type && 
+            trueBranchType.singleton === falseBranchType.singleton) {
+          return { type: trueBranchType, diagnostics };
+        } else if (trueBranchType.type === falseBranchType.type) {
+          // Same type but different singleton - result is collection
+          return { type: { type: trueBranchType.type, singleton: false }, diagnostics };
+        }
+      }
+      
+      return { type: { type: 'Any', singleton: false }, diagnostics };
+    }
+  },
+  
+  async inferResultType(analyzer, node, inputType) {
+    // iif returns the common type of the true and false branches
+    if (node.arguments.length >= 2) {
+      const trueBranchType = await (analyzer as any).inferType(node.arguments[1]!, inputType);
+      if (node.arguments.length >= 3) {
+        const falseBranchType = await (analyzer as any).inferType(node.arguments[2]!, inputType);
+        // If both branches have the same type, use that
+        if (trueBranchType.type === falseBranchType.type && 
+            trueBranchType.singleton === falseBranchType.singleton) {
+          return trueBranchType;
+        }
+        // If types are the same but singleton differs, return as collection
+        if (trueBranchType.type === falseBranchType.type) {
+          // One is singleton, one is collection - result must be collection
+          return { type: trueBranchType.type, singleton: false };
+        }
+        // Otherwise, check if one is a subtype of the other
+        if ((analyzer as any).isTypeCompatible(trueBranchType, falseBranchType)) {
+          return falseBranchType;
+        }
+        if ((analyzer as any).isTypeCompatible(falseBranchType, trueBranchType)) {
+          return trueBranchType;
+        }
+      } else {
+        // Only true branch, result can be that type or empty
+        return { ...trueBranchType, singleton: false };
+      }
+    }
+    return { type: 'Any', singleton: false };
+  }
+};

package/src/operations/implies-operator.ts

@@ -1,7 +1,7 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   // Three-valued logic for implies per spec truth table
@@ -50,6 +50,7 @@ export const impliesOperator: OperatorDefinition & { evaluate: OperationEvaluato
   category: ['logical'],
   precedence: PRECEDENCE.IMPLIES,
   associativity: 'right',
+  doesNotPropagateEmpty: true,  // Implies has special empty handling rules
   description: 'If the left operand evaluates to true, returns the boolean evaluation of the right operand. If the left operand evaluates to false, returns true. Otherwise, returns true if the right operand evaluates to true, and empty ({ }) otherwise',
   examples: [
     'Patient.name.given.exists() implies Patient.name.family.exists()',

package/src/operations/in-operator.ts

@@ -2,7 +2,7 @@ import type { OperatorDefinition } from '../types';
 import { Errors } from '../errors';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   // If left is empty, result is empty
@@ -45,6 +45,7 @@ export const inOperator: OperatorDefinition & { evaluate: OperationEvaluator } =
   category: ['membership'],
   precedence: PRECEDENCE.IN_CONTAINS,
   associativity: 'left',
+  doesNotPropagateEmpty: true,  // Has custom empty handling per spec
   description: 'If the left operand is a collection with a single item, returns true if the item is in the right operand using equality semantics. If the left is empty, the result is empty. If the right is empty, the result is false.',
   examples: ['\'Joe\' in Patient.name.given', '5 in (1 | 2 | 3 | 4 | 5)', 'code in terminologyServer.valueset(\'my-valueset\').code'],
   signatures: [

package/src/operations/index.ts

@@ -34,6 +34,8 @@ export { containsOperator } from './contains-operator';
 export { isOperator } from './is-operator';
 export { asOperator } from './as-operator';
 export { ofTypeFunction } from './ofType-function';
+export { isFunction } from './is-function';
+export { asFunction } from './as-function';
 
 // Other operators
 export { unionOperator } from './union-operator';
@@ -43,10 +45,12 @@ export { dotOperator } from './dot-operator';
 // Functions
 export { whereFunction } from './where-function';
 export { selectFunction } from './select-function';
+export { repeatFunction } from './repeat-function';
 export { firstFunction } from './first-function';
 export { lastFunction } from './last-function';
 export { childrenFunction } from './children-function';
 export { descendantsFunction } from './descendants-function';
+export { extensionFunction } from './extension-function';
 export { skipFunction } from './skip-function';
 export { takeFunction } from './take-function';
 export { tailFunction } from './tail-function';
@@ -60,6 +64,19 @@ export { distinctFunction } from './distinct-function';
 export { isDistinctFunction } from './isDistinct-function';
 export { iifFunction } from './iif-function';
 export { defineVariableFunction } from './defineVariable-function';
+
+// Temporal functions
+export { 
+  nowFunction, 
+  todayFunction, 
+  timeOfDayFunction,
+  toDateFunction,
+  toDateTimeFunction,
+  toTimeFunction,
+  convertsToDateFunction,
+  convertsToDateTimeFunction,
+  convertsToTimeFunction
+} from './temporal-functions';
 export { joinFunction } from './join-function';
 export { replaceFunction } from './replace-function';
 export { unionFunction } from './union-function';
@@ -67,7 +84,12 @@ export { combineFunction } from './combine-function';
 export { intersectFunction } from './intersect-function';
 export { excludeFunction } from './exclude-function';
 export { indexOfFunction } from './indexOf-function';
+export { lastIndexOfFunction } from './lastIndexOf-function';
 export { substringFunction } from './substring-function';
+export { matchesFunction } from './matches-function';
+export { matchesFullFunction } from './matchesFull-function';
+export { replaceMatchesFunction } from './replaceMatches-function';
+export { toCharsFunction } from './toChars-function';
 export { containsFunction } from './contains-function';
 export { startsWithFunction } from './startsWith-function';
 export { endsWithFunction } from './endsWith-function';
@@ -88,9 +110,30 @@ export { toIntegerFunction } from './toInteger-function';
 export { toDecimalFunction } from './toDecimal-function';
 export { toStringFunction } from './toString-function';
 export { toBooleanFunction } from './toBoolean-function';
+export { toQuantityFunction } from './toQuantity-function';
+export { toLongFunction } from './toLong-function';
+export { convertsToBooleanFunction } from './convertsToBoolean-function';
+export { convertsToIntegerFunction } from './convertsToInteger-function';
+export { convertsToDecimalFunction } from './convertsToDecimal-function';
+export { convertsToStringFunction } from './convertsToString-function';
+export { convertsToQuantityFunction } from './convertsToQuantity-function';
+export { convertsToLongFunction } from './convertsToLong-function';
 
 // Utility functions
 export { traceFunction } from './trace-function';
+export { precisionFunction } from './precision-function';
+export { dateOfFunction } from './dateOf-function';
+export { timeOfFunction } from './timeOf-function';
+export { yearOfFunction } from './yearOf-function';
+export { monthOfFunction } from './monthOf-function';
+export { dayOfFunction } from './dayOf-function';
+export { hourOfFunction } from './hourOf-function';
+export { minuteOfFunction } from './minuteOf-function';
+export { secondOfFunction } from './secondOf-function';
+export { millisecondOfFunction } from './millisecondOf-function';
+export { timezoneOffsetOfFunction } from './timezoneOffsetOf-function';
+export { lowBoundaryFunction } from './lowBoundary-function';
+export { highBoundaryFunction } from './highBoundary-function';
 
 // Aggregate functions
 export { aggregateFunction } from './aggregate-function';

package/src/operations/indexOf-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator, LiteralNode } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // Check single item in input

package/src/operations/intersect-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (args.length !== 1) {

package/src/operations/is-function.ts

@@ -0,0 +1,70 @@
+import type { FunctionDefinition, FunctionEvaluator, ASTNode, RuntimeContext, NodeEvaluator } from '../types';
+import type { FHIRPathValue } from '../interpreter/boxing';
+import { NodeType, isIdentifierNode } from '../types';
+import { box } from '../interpreter/boxing';
+import { evaluate as isOperatorEvaluate } from './is-operator';
+
+const isEvaluator: FunctionEvaluator = async (
+  input: FHIRPathValue[], 
+  context: RuntimeContext, 
+  args: ASTNode[],
+  evaluator: NodeEvaluator
+) => {
+  // is() function takes one argument - the type name
+  if (args.length !== 1) {
+    return { value: [], context };
+  }
+  
+  const typeArg = args[0];
+  if (!typeArg) {
+    return { value: [], context };
+  }
+  
+  // Extract type name from the argument AST node
+  let typeName: string;
+  
+  if (isIdentifierNode(typeArg)) {
+    typeName = typeArg.name;
+  } else if (typeArg.type === NodeType.Binary && typeArg.operator === '.') {
+    // Handle namespaced types like System.Boolean or FHIR.Patient
+    // Reconstruct the full type name from the binary expression
+    const leftPart = typeArg.left;
+    const rightPart = typeArg.right;
+    
+    if (isIdentifierNode(leftPart) && isIdentifierNode(rightPart)) {
+      typeName = `${leftPart.name}.${rightPart.name}`;
+    } else {
+      throw new Error(`is() requires a type name as argument, got complex expression`);
+    }
+  } else {
+    // For other node types, try to get the name
+    throw new Error(`is() requires a type name as argument, got ${typeArg.type}`);
+  }
+  
+  // Use the is operator implementation with the type name
+  return isOperatorEvaluate(input, context, input, [typeName]);
+};
+
+export { isEvaluator };
+
+export const isFunction: FunctionDefinition & { evaluate: typeof isEvaluator } = {
+  name: 'is',
+  category: ['type'],
+  description: 'Tests if the input is of the specified type',
+  examples: ['Patient.name.is(HumanName)', '"hello".is(String)', '5.is(Integer)'],
+  signatures: [
+    {
+      name: 'is-type-check', 
+      parameters: [{ 
+        name: 'type', 
+        type: { type: 'Any', singleton: true },
+        expression: true,
+        typeReference: true 
+      }],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  doesNotPropagateEmpty: false,
+  evaluate: isEvaluator
+};