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

package/src/analyzer.ts

@@ -3,6 +3,7 @@ import type {
   BinaryNode, 
   IdentifierNode, 
   LiteralNode, 
+  TemporalLiteralNode,
   FunctionNode, 
   Diagnostic, 
   AnalysisResult, 
@@ -15,15 +16,20 @@ import type {
   ModelProvider,
   VariableNode,
   TypeName,
-  TypeOrIdentifierNode,
-  ErrorNode
+  ErrorNode,
+  InternalAnalysisResult,
+  QuantityNode
 } from './types';
-import { NodeType, DiagnosticSeverity } from './types';
+import { NodeType, DiagnosticSeverity, AnalysisContext } from './types';
+import type { OperatorSignature, FunctionSignature } from './types';
+import type { FunctionDefinition } from './types';
 import { registry } from './registry';
-import { Errors, toDiagnostic } from './errors';
-import { isCursorNode, CursorContext } from './cursor-nodes';
-import type { AnyCursorNode } from './cursor-nodes';
-
+import { matchOperatorSignature, matchFunctionSignature, resolveResultType } from './analyzer/type-compat';
+import { checkParamTypes, formatType, isEmptyCollection, isUnionType, getUnionChoices, validateUnionChoice } from './analyzer/utils';
+import { Errors, toDiagnostic, ErrorCodes } from './errors';
+import { isCursorNode, CursorContext } from './parser/cursor-nodes';
+import type { AnyCursorNode } from './parser/cursor-nodes';
+import { Parser, type ParserOptions } from './parser';
 
 export interface AnalyzerOptions {
   cursorMode?: boolean;
@@ -35,992 +41,1023 @@ export interface AnalysisResultWithCursor extends AnalysisResult {
     typeBeforeCursor?: TypeInfo;
     expectedType?: TypeInfo;
     cursorNode?: AnyCursorNode;
+    functionCall?: {
+      definition: import('./types').FunctionDefinition;
+      argumentIndex: number;
+    };
   };
 }
 
 export class Analyzer {
-  private diagnostics: Diagnostic[] = [];
-  private variables: Set<string> = new Set(['$this', '$index', '$total', 'context', 'resource', 'rootResource']);
   private modelProvider?: ModelProvider;
-  private userVariableTypes: Map<string, TypeInfo> = new Map();
-  private systemVariableTypes: Map<string, TypeInfo> = new Map();
   private cursorMode: boolean = false;
   private stoppedAtCursor: boolean = false;
   private cursorContext?: {
     typeBeforeCursor?: TypeInfo;
     expectedType?: TypeInfo;
     cursorNode?: AnyCursorNode;
+    functionCall?: {
+      definition: import('./types').FunctionDefinition;
+      argumentIndex: number;
+    };
   };
 
   constructor(modelProvider?: ModelProvider) {
     this.modelProvider = modelProvider;
   }
 
-  async analyze(
-    ast: ASTNode, 
-    userVariables?: Record<string, any>, 
-    inputType?: TypeInfo,
-    options?: AnalyzerOptions
+  /**
+   * Parse and analyze a FHIRPath expression end-to-end, returning an AnalysisResult
+   * and structured diagnostics. Supports optional error recovery (LSP mode).
+   */
+  static async analyzeExpression(
+    expression: string,
+    options: {
+      variables?: Record<string, unknown>;
+      modelProvider?: ModelProvider;
+      inputType?: TypeInfo;
+      errorRecovery?: boolean;
+      parserOptions?: ParserOptions;
+    } = {}
   ): Promise<AnalysisResultWithCursor> {
-    this.diagnostics = [];
-    this.userVariableTypes.clear();
-    this.cursorMode = options?.cursorMode ?? false;
-    this.stoppedAtCursor = false;
-    this.cursorContext = undefined;
-    
-    if (userVariables) {
-      Object.keys(userVariables).forEach(name => {
-        this.variables.add(name);
-        // Try to infer types from values
-        const value = userVariables[name];
-        if (value !== undefined && value !== null) {
-          this.userVariableTypes.set(name, this.inferValueType(value));
-        }
-      });
-    }
-    
-    // Annotate AST with type information
-    await this.annotateAST(ast, inputType);
-    
-    // Perform validation with type checking (if not stopped at cursor)
-    if (!this.stoppedAtCursor) {
-      this.visitNode(ast);
+    const parserOptions: ParserOptions | undefined = options.errorRecovery
+      ? { mode: 'lsp', errorRecovery: true, ...(options.parserOptions || {}) }
+      : options.parserOptions;
+
+    const parser = new Parser(expression, parserOptions);
+    const parseResult = parser.parse();
+
+    // If error recovery is not enabled and there are parse errors, surface the first one.
+    if (!options.errorRecovery && parseResult.errors.length > 0) {
+      // Preserve backward compatibility; analyzer doesn't throw custom mapping here.
+      throw Errors.invalidSyntax(parseResult.errors[0]!.message);
     }
-    
-    return {
-      diagnostics: this.diagnostics,
-      ast,
-      stoppedAtCursor: this.cursorMode ? this.stoppedAtCursor : undefined,
-      cursorContext: this.cursorMode ? this.cursorContext : undefined
-    };
+
+    const analyzer = new Analyzer(options.modelProvider);
+    const result = await analyzer.analyze(
+      parseResult.ast,
+      options.variables,
+      options.inputType,
+      { cursorMode: !!parserOptions?.mode && parserOptions.mode === 'lsp' }
+    );
+
+    return result;
   }
 
-  private visitNode(node: ASTNode): void {
-    // Check for cursor node in cursor mode
-    if (this.cursorMode && isCursorNode(node)) {
-      this.stoppedAtCursor = true;
-      this.cursorContext = {
-        cursorNode: node as AnyCursorNode,
-        typeBeforeCursor: (node as any).typeInfo
-      };
-      return; // Short-circuit
-    }
-    
-    // Handle error nodes - process them for diagnostics but don't traverse
-    if (node.type === 'Error') {
-      // Diagnostics already added in annotateAST
-      return;
-    }
-    
-    // If we've already stopped at cursor, don't continue
-    if (this.stoppedAtCursor) {
-      return;
+  /**
+   * Main entry point for context-flow analysis.
+   * Analyzes a node with the given context.
+   */
+  private async analyzeNode(node: ASTNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    // Handle cursor nodes for completion
+    if (isCursorNode(node)) {
+      return this.analyzeCursorNode(node as AnyCursorNode, context);
     }
+
+    let result: InternalAnalysisResult;
     
     switch (node.type) {
       case NodeType.Binary:
-        this.visitBinaryOperator(node as BinaryNode);
+        result = await this.analyzeBinary(node as BinaryNode, context);
         break;
-      case NodeType.Identifier:
-        this.visitIdentifier(node as IdentifierNode);
+      case NodeType.Unary:
+        result = await this.analyzeUnary(node as UnaryNode, context);
         break;
       case NodeType.Function:
-        this.visitFunctionCall(node as FunctionNode);
+        result = await this.analyzeFunction(node as FunctionNode, context);
+        break;
+      case NodeType.Variable:
+        result = this.analyzeVariable(node as VariableNode, context);
+        break;
+      case NodeType.Identifier:
+        result = await this.analyzeIdentifier(node as IdentifierNode, context);
+        break;
+      case NodeType.Literal:
+        result = this.analyzeLiteral(node as LiteralNode, context);
+        break;
+      case NodeType.TemporalLiteral:
+        result = this.analyzeTemporalLiteral(node as TemporalLiteralNode, context);
         break;
       case NodeType.Index:
-        const indexNode = node as IndexNode;
-        this.visitNode(indexNode.expression);
-        this.visitNode(indexNode.index);
+        result = await this.analyzeIndex(node as IndexNode, context);
         break;
       case NodeType.Collection:
-        (node as CollectionNode).elements.forEach(el => this.visitNode(el));
-        break;
-      case NodeType.Unary:
-        this.visitNode((node as UnaryNode).operand);
+        result = await this.analyzeCollection(node as CollectionNode, context);
         break;
       case NodeType.MembershipTest:
-        this.visitMembershipTest(node as MembershipTestNode);
+        result = await this.analyzeMembershipTest(node as MembershipTestNode, context);
         break;
       case NodeType.TypeCast:
-        this.visitTypeCast(node as TypeCastNode);
+        result = await this.analyzeTypeCast(node as TypeCastNode, context);
         break;
-      case NodeType.Variable:
-        this.validateVariable((node as VariableNode).name, node);
+      case NodeType.Quantity:
+        result = this.analyzeQuantity(node as QuantityNode, context);
         break;
-      case NodeType.Literal:
-      case NodeType.TypeOrIdentifier:
-      case NodeType.TypeReference:
-        // These are always valid
+      case 'Error':
+        result = this.analyzeError(node as ErrorNode, context);
         break;
+      default:
+        result = {
+          type: { type: 'Any', singleton: false },
+          diagnostics: [toDiagnostic(Errors.unknownNodeType(String((node as any)?.type), (node as any)?.range))]
+        };
     }
+    
+    // Annotate the node with type information
+    node.typeInfo = result.type;
+    
+    return result;
   }
 
-  private visitBinaryOperator(node: BinaryNode): void {
-    this.visitNode(node.left);
-    
-    // Track defineVariable for validation - collect all variables defined in the chain
-    if (node.operator === '.') {
-      const definedVars = this.collectDefinedVariables(node.left);
-      if (definedVars.size > 0) {
-        // Track which variables were already known
-        const previouslyKnown = new Set<string>();
-        definedVars.forEach(varName => {
-          if (this.variables.has(varName)) {
-            previouslyKnown.add(varName);
-          }
-          this.variables.add(varName);
-        });
-        
-        // Visit right side with new variables in scope
-        this.visitNode(node.right);
-        
-        // Restore previous state
-        definedVars.forEach(varName => {
-          if (!previouslyKnown.has(varName)) {
-            this.variables.delete(varName);
-          }
-        });
-        return;
+  /**
+   * Analyzes binary operators with special handling for union and dot.
+   */
+  private async analyzeBinary(node: BinaryNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const diagnostics: Diagnostic[] = [];
+
+    // Special handling for union operator - fork context for each branch
+    if (node.operator === '|') {
+      const leftResult = await this.analyzeNode(node.left, context.fork());
+      if (this.stoppedAtCursor) {
+        return { type: { type: 'Any', singleton: false }, diagnostics: leftResult.diagnostics };
       }
+      
+      const rightResult = await this.analyzeNode(node.right, context.fork());
+      
+      diagnostics.push(...leftResult.diagnostics, ...rightResult.diagnostics);
+      
+      // Preserve left operand type per operator signature (leftType)
+      const type = { ...leftResult.type, singleton: false };
+      
+      return {
+        type,
+        diagnostics,
+        context // Return original context unchanged - no variable leakage
+      };
     }
-    
-    // Special handling for dot operator with function on right side
-    if (node.operator === '.' && node.right.type === NodeType.Function) {
-      const funcNode = node.right as FunctionNode;
-      if (funcNode.name.type === NodeType.Identifier) {
-        const funcName = (funcNode.name as IdentifierNode).name;
-        const func = registry.getFunction(funcName);
-        if (func && func.signatures && func.signatures.length > 0 && node.left.typeInfo) {
-          // Check if any signature matches the input type
-          let matchFound = false;
-          let expectedTypes: string[] = [];
-          
-          for (const signature of func.signatures) {
-            if (signature.input) {
-              if (this.isTypeCompatible(node.left.typeInfo, signature.input)) {
-                matchFound = true;
-                break;
-              }
-              expectedTypes.push(this.typeToString(signature.input));
-            } else {
-              // If any signature has no input constraint, it matches
-              matchFound = true;
-              break;
-            }
-          }
-          
-          if (!matchFound) {
-            const inputTypeStr = this.typeToString(node.left.typeInfo);
-            const firstSignature = func.signatures[0];
-            
-            if (!firstSignature) return;
-            
-            // Check if this is specifically a singleton/collection mismatch
-            const inputIsCollection = !node.left.typeInfo.singleton;
-            const expectedIsSingleton = firstSignature.input?.singleton;
-            
-            // Check if the base types are compatible (same type or subtype)
-            const typesCompatible = firstSignature.input && (
-              node.left.typeInfo.type === firstSignature.input.type ||
-              this.isSubtypeOf(node.left.typeInfo.type, firstSignature.input.type)
-            );
-            
-            if (inputIsCollection && expectedIsSingleton && typesCompatible) {
-              // Compatible base types but collection vs singleton mismatch
-              this.diagnostics.push(
-                toDiagnostic(Errors.singletonTypeRequired(funcName, inputTypeStr, funcNode.range))
-              );
-            } else {
-              // Function received invalid operand type - report as runtime error
-              this.diagnostics.push(
-                toDiagnostic(Errors.invalidOperandType(funcName + '()', inputTypeStr, funcNode.range))
-              );
-            }
-          }
-        }
+
+    // Special handling for dot operator - flow context through
+    if (node.operator === '.') {
+      // Check if this is actually a namespaced type in an 'is' expression
+      // Parser incorrectly creates: (true is System).Boolean instead of: true is System.Boolean
+      if (node.left.type === NodeType.MembershipTest && node.right.type === NodeType.Identifier) {
+        const membershipTest = node.left as MembershipTestNode;
+        const rightIdent = node.right as IdentifierNode;
+        // Reconstruct the correct MembershipTest with full type name
+        const correctedNode: MembershipTestNode = {
+          ...membershipTest,
+          targetType: `${membershipTest.targetType}.${rightIdent.name}`
+        };
+        return await this.analyzeMembershipTest(correctedNode, context);
       }
+      
+      const leftResult = await this.analyzeNode(node.left, context);
+      if (this.stoppedAtCursor) {
+        return { type: { type: 'Any', singleton: false }, diagnostics: leftResult.diagnostics };
+      }
+      
+      // Right side gets left's output as input, with any context changes
+      const rightContext = (leftResult.context || context).withInputType(leftResult.type);
+      const rightResult = await this.analyzeNode(node.right, rightContext);
+      
+      diagnostics.push(...leftResult.diagnostics, ...rightResult.diagnostics);
+      
+      return {
+        type: rightResult.type,
+        diagnostics,
+        context: rightResult.context // Propagate context changes (for defineVariable)
+      };
     }
-    
-    this.visitNode(node.right);
-    
-    // For dot operator, we don't need to check operator types
-    if (node.operator === '.') {
-      return;
+
+    // Handle other binary operators
+    const leftResult = await this.analyzeNode(node.left, context);
+    if (this.stoppedAtCursor) {
+      return { type: { type: 'Any', singleton: false }, diagnostics: leftResult.diagnostics };
     }
     
-    const op = registry.getOperatorDefinition(node.operator);
-    if (!op) {
-      this.diagnostics.push(
-        toDiagnostic(Errors.unknownOperator(node.operator, node.range))
-      );
-      return;
+    // Check if right side is a cursor node - if so, set proper context
+    if (this.cursorMode && isCursorNode(node.right)) {
+      this.stoppedAtCursor = true;
+      this.cursorContext = {
+        cursorNode: node.right as AnyCursorNode,
+        typeBeforeCursor: leftResult.type,
+        expectedType: undefined
+      };
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: leftResult.diagnostics
+      };
     }
     
-    // Type check if we have type information
-    if (node.left.typeInfo && node.right.typeInfo) {
-      this.checkBinaryOperatorTypes(node, op);
+    // For most operators, right side evaluates with original context (not left's output)
+    const rightResult = await this.analyzeNode(node.right, context);
+    
+    diagnostics.push(...leftResult.diagnostics, ...rightResult.diagnostics);
+
+    // Get operator definition for type checking
+    const operatorDef = registry.getOperatorDefinition(node.operator);
+    if (!operatorDef) {
+      diagnostics.push(toDiagnostic(Errors.unknownOperator(node.operator, node.range)));
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics
+      };
+    }
+
+    // Check operator signatures for type compatibility
+    if (operatorDef.signatures && operatorDef.signatures.length > 0) {
+      const matchingSignature = matchOperatorSignature(leftResult.type, rightResult.type, operatorDef) || null;
+      if (!matchingSignature) {
+        // No matching signature found - report type error
+        // But don't report if either side is Any (could be from an error)
+        if (leftResult.type.type !== 'Any' && rightResult.type.type !== 'Any') {
+          const leftTypeStr = leftResult.type.singleton ? leftResult.type.type : `${leftResult.type.type}[]`;
+          const rightTypeStr = rightResult.type.singleton ? rightResult.type.type : `${rightResult.type.type}[]`;
+          diagnostics.push(this.createError(
+            node,
+            `Operator '${node.operator}' cannot be applied to types ${leftTypeStr} and ${rightTypeStr}`,
+            ErrorCodes.OPERATOR_TYPE_MISMATCH
+          ));
+        }
+        return {
+          type: { type: 'Any', singleton: false },
+          diagnostics
+        };
+      }
+      
+      // Determine result type from matching signature
+      const resultType = resolveResultType(matchingSignature.result as any, {
+        input: context.inputType,
+        left: leftResult.type,
+        right: rightResult.type,
+      });
+      
+      return {
+        type: resultType,
+        diagnostics
+      };
     }
+
+    // If no signatures defined, return Any type
+    return {
+      type: { type: 'Any', singleton: false },
+      diagnostics
+    };
   }
 
-  private visitIdentifier(node: IdentifierNode): void {
-    this.validateVariable(node.name, node);
+  /**
+   * Analyzes function calls, delegating to function's analyze method if available.
+  */
+  private async analyzeFunction(node: FunctionNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const diagnostics: Diagnostic[] = [];
+
+    const functionName = this.getFunctionName(node);
+    if (!functionName) {
+      diagnostics.push(this.createError(node.name, 'Invalid function name', ErrorCodes.INVALID_SYNTAX));
+      return { type: { type: 'Any', singleton: false }, diagnostics };
+    }
+
+    const funcDef = registry.getFunction(functionName);
+    if (!funcDef) {
+      diagnostics.push(toDiagnostic(Errors.unknownFunction(functionName, node.range)));
+      return { type: { type: 'Any', singleton: false }, diagnostics };
+    }
+
+    const arity = this.validateArity(funcDef, node, functionName);
+    diagnostics.push(...arity.diagnostics);
+
+    // Early union rules for ofType/is/as
+    diagnostics.push(...this.validateUnionTypeFilters(functionName, node, context));
+
+    // Custom analyze
+    if (funcDef.analyze) {
+      const result = funcDef.analyze(context, node.arguments);
+      const analysisResult = result instanceof Promise ? await result : result;
+      return {
+        ...analysisResult,
+        diagnostics: [...diagnostics, ...analysisResult.diagnostics]
+      };
+    }
+
+    // Default path: analyze args
+    const argAnalysis = await this.analyzeArguments(funcDef, node, context, functionName);
+    diagnostics.push(...argAnalysis.diagnostics);
+    if (this.stoppedAtCursor) {
+      return { type: { type: 'Any', singleton: false }, diagnostics };
+    }
+
+    // Signature matching and diagnostics
+    const signatureResult = this.matchAndDiagnoseSignature(
+      funcDef,
+      context.inputType,
+      argAnalysis.argTypes,
+      node,
+      functionName,
+      arity.hasError
+    );
+    diagnostics.push(...signatureResult.diagnostics);
+    if (signatureResult.earlyReturn) {
+      return { type: signatureResult.earlyReturn, diagnostics };
+    }
+
+    // Empty propagation
+    if (this.propagatesEmpty(funcDef, context.inputType, argAnalysis.argTypes)) {
+      return {
+        type: { type: 'Any', singleton: false, isEmpty: true },
+        diagnostics,
+        context
+      };
+    }
+
+    // Result inference
+    let resultType = await this.inferFunctionResultType(
+      funcDef,
+      node,
+      context,
+      argAnalysis.argTypes,
+      signatureResult.match
+    );
+
+    if (functionName === 'where') {
+      resultType = { ...resultType, singleton: false };
+    }
+
+    return { type: resultType, diagnostics, context };
   }
 
-  private visitFunctionCall(node: FunctionNode): void {
+  private getFunctionName(node: FunctionNode): string | null {
     if (node.name.type === NodeType.Identifier) {
-      const funcName = (node.name as IdentifierNode).name;
-      
-      // Check if this is a type operation that requires ModelProvider
-      if (funcName === 'ofType' && !this.modelProvider) {
-        // Check if the type argument is a primitive type
-        const primitiveTypes = ['String', 'Integer', 'Decimal', 'Boolean', 'Date', 'DateTime', 'Time', 'Quantity'];
-        let isPrimitive = false;
-        
-        if (node.arguments.length > 0) {
-          const typeArg = node.arguments[0]!;
-          if (typeArg.type === NodeType.Identifier) {
-            isPrimitive = primitiveTypes.includes((typeArg as IdentifierNode).name);
-          } else if ((typeArg as any).type === NodeType.TypeOrIdentifier || (typeArg as any).type === NodeType.TypeReference) {
-            isPrimitive = primitiveTypes.includes((typeArg as any).name);
-          }
-        }
-        
-        if (!isPrimitive) {
-          this.diagnostics.push(
-            toDiagnostic(Errors.modelProviderRequired('ofType', node.range))
+      return (node.name as IdentifierNode).name;
+    }
+    return null;
+  }
+
+  private validateArity(
+    funcDef: FunctionDefinition,
+    node: FunctionNode,
+    functionName: string
+  ): { diagnostics: Diagnostic[]; hasError: boolean } {
+    const diagnostics: Diagnostic[] = [];
+    let hasError = false;
+    if (funcDef.signatures && funcDef.signatures.length > 0) {
+      const signature = funcDef.signatures[0];
+      if (signature) {
+        const params = signature.parameters || [];
+        const requiredCount = params.filter(p => !p.optional).length;
+        const maxCount = params.length;
+        const actualCount = node.arguments.length;
+
+        if (actualCount < requiredCount) {
+          diagnostics.push(
+            this.createError(
+              node,
+              `${functionName} expects at least ${requiredCount} argument${requiredCount !== 1 ? 's' : ''}, got ${actualCount}`,
+              ErrorCodes.WRONG_ARGUMENT_COUNT
+            )
+          );
+          hasError = true;
+        } else if (actualCount > maxCount) {
+          diagnostics.push(
+            this.createError(
+              node,
+              `${functionName} expects at most ${maxCount} argument${maxCount !== 1 ? 's' : ''}, got ${actualCount}`,
+              ErrorCodes.WRONG_ARGUMENT_COUNT
+            )
           );
+          hasError = true;
         }
       }
-      
-      // Check ofType with union types
-      if (funcName === 'ofType' && node.typeInfo) {
-        const inputType = node.typeInfo;
-        if (node.arguments.length > 0 && inputType.modelContext && 
-            typeof inputType.modelContext === 'object' &&
-            'isUnion' in inputType.modelContext && 
-            inputType.modelContext.isUnion &&
-            'choices' in inputType.modelContext &&
-            Array.isArray(inputType.modelContext.choices)) {
-          
-          // Extract target type from argument
-          let targetType: string | undefined;
-          const typeArg = node.arguments[0]!;
-          if (typeArg.type === NodeType.Identifier) {
-            targetType = (typeArg as IdentifierNode).name;
-          } else if ((typeArg as any).type === NodeType.TypeOrIdentifier || (typeArg as any).type === NodeType.TypeReference) {
-            targetType = (typeArg as any).name;
+    }
+    return { diagnostics, hasError };
+  }
+
+  private validateUnionTypeFilters(
+    functionName: string,
+    node: FunctionNode,
+    context: AnalysisContext
+  ): Diagnostic[] {
+    const diagnostics: Diagnostic[] = [];
+    if (!['ofType', 'is', 'as'].includes(functionName) || node.arguments.length === 0) {
+      return diagnostics;
+    }
+    const inputType = context.inputType;
+    if (!isUnionType(inputType)) {
+      return diagnostics;
+    }
+    const typeArg = node.arguments[0]!;
+    let targetType: string | undefined;
+    if (typeArg.type === NodeType.Identifier) {
+      targetType = (typeArg as IdentifierNode).name;
+    }
+    if (!targetType) {
+      return diagnostics;
+    }
+    const diag = validateUnionChoice(inputType, targetType, typeArg.range || node.range, 'invalid-type-filter', 'Type');
+    if (diag && functionName === 'ofType') diagnostics.push(diag);
+    return diagnostics;
+  }
+
+  private async analyzeArguments(
+    funcDef: FunctionDefinition,
+    node: FunctionNode,
+    context: AnalysisContext,
+    functionName: string
+  ): Promise<{ argTypes: TypeInfo[]; diagnostics: Diagnostic[] }> {
+    const diagnostics: Diagnostic[] = [];
+    const argTypes: TypeInfo[] = [];
+    const signature = funcDef.signatures?.[0];
+    const params = signature?.parameters || [];
+
+    for (let i = 0; i < node.arguments.length; i++) {
+      const arg = node.arguments[i]!;
+      const param = params[i];
+      const isTypeParameter = !!param?.typeReference;
+
+      if (isTypeParameter) {
+        argTypes.push({ type: 'TypeReference' as TypeName, singleton: true });
+        continue;
+      }
+
+      if (param?.expression) {
+        const itemType = { ...context.inputType, singleton: true };
+        const exprContext = context
+          .withSystemVariable('$this', itemType)
+          .withSystemVariable('$index', { type: 'Integer', singleton: true });
+        const argResult = await this.analyzeNode(arg, exprContext);
+        diagnostics.push(...argResult.diagnostics);
+        argTypes.push(argResult.type);
+        if (this.stoppedAtCursor) {
+          break;
+        }
+        continue;
+      }
+
+      const thisType = context.systemVariables.get('$this') || context.inputType;
+      const argContext = context.withInputType(thisType);
+      const argResult = await this.analyzeNode(arg, argContext);
+      diagnostics.push(...argResult.diagnostics);
+      argTypes.push(argResult.type);
+      if (this.stoppedAtCursor) {
+        break;
+      }
+    }
+
+    return { argTypes, diagnostics };
+  }
+
+  private matchAndDiagnoseSignature(
+    funcDef: FunctionDefinition,
+    actualInput: TypeInfo,
+    argTypes: TypeInfo[],
+    node: FunctionNode,
+    functionName: string,
+    hasArityError: boolean
+  ): { match: FunctionSignature | null; diagnostics: Diagnostic[]; earlyReturn?: TypeInfo } {
+    const diagnostics: Diagnostic[] = [];
+    let match: FunctionSignature | null = null;
+
+    if (!hasArityError && funcDef.signatures && funcDef.signatures.length > 0) {
+      match = matchFunctionSignature(actualInput, argTypes, funcDef) || null;
+
+      if (!match) {
+        const inputIsEmpty = isEmptyCollection(actualInput);
+        if (inputIsEmpty && !funcDef.doesNotPropagateEmpty) {
+          const sig = funcDef.signatures[0];
+          if (sig) {
+            diagnostics.push(
+              ...checkParamTypes(sig, argTypes, node.arguments, {
+                warnOnSingletonOnly: false,
+                doesNotPropagateEmpty: !!funcDef.doesNotPropagateEmpty,
+                treatEmptyAsWarning: true,
+                errorCode: ErrorCodes.ARGUMENT_TYPE_MISMATCH,
+              })
+            );
+          }
+        } else {
+          let inputMatchingSignature: FunctionSignature | null = null;
+          for (const sig of funcDef.signatures) {
+            let inputMatches = true;
+            if (sig.input) {
+              const expectedInput = sig.input;
+              const singletonMatch = !expectedInput.singleton || actualInput.singleton === true;
+              const typeMatch =
+                expectedInput.type === 'Any' ||
+                actualInput.type === 'Any' ||
+                expectedInput.type === actualInput.type ||
+                (expectedInput.type === 'Decimal' && actualInput.type === 'Integer');
+              inputMatches = singletonMatch && typeMatch;
+            }
+            if (inputMatches) {
+              inputMatchingSignature = sig;
+              break;
+            }
           }
-          
-          if (targetType) {
-            const validChoice = inputType.modelContext.choices.find((choice: any) => 
-              choice.type === targetType || choice.code === targetType
+
+          if (inputMatchingSignature && inputMatchingSignature.parameters) {
+            diagnostics.push(
+              ...checkParamTypes(inputMatchingSignature, argTypes, node.arguments, {
+                warnOnSingletonOnly: true,
+                doesNotPropagateEmpty: !!funcDef.doesNotPropagateEmpty,
+                errorCode: ErrorCodes.ARGUMENT_TYPE_MISMATCH,
+              })
             );
-            
-            if (!validChoice) {
-              this.diagnostics.push({
-                severity: DiagnosticSeverity.Warning,
-                code: 'invalid-type-filter',
-                message: `Type '${targetType}' is not present in the union type. Available types: ${
-                  inputType.modelContext.choices.map((c: any) => c.type || c.code).join(', ')
-                }`,
-                range: node.range
-              });
+          } else {
+            const actualTypeStr = actualInput.singleton ? actualInput.type : `${actualInput.type}[]`;
+            const hasSingletonSignature = funcDef.signatures.some(sig => sig.input?.singleton && sig.input.type === actualInput.type);
+            const permissive = ['anyFalse', 'anyTrue'];
+            if (hasSingletonSignature && !actualInput.singleton) {
+              diagnostics.push(
+                this.createError(
+                  node,
+                  `${functionName} expects a singleton value, but received collection type ${actualTypeStr}`,
+                  ErrorCodes.SINGLETON_REQUIRED
+                )
+              );
+            } else if (!permissive.includes(functionName)) {
+              const expectedTypes = funcDef.signatures
+                .map(sig => (sig.input ? (sig.input.singleton ? sig.input.type : `${sig.input.type}[]`) : 'Any'))
+                .filter((v, i, a) => a.indexOf(v) === i)
+                .join(' or ');
+              diagnostics.push(
+                this.createError(
+                  node,
+                  `Cannot apply ${functionName}() to ${actualTypeStr}. Function expects ${expectedTypes}.`,
+                  ErrorCodes.INVALID_OPERAND_TYPE
+                )
+              );
             }
           }
         }
-      }
-      
-      const func = registry.getFunction(funcName);
-      
-      if (!func) {
-        this.diagnostics.push(
-          toDiagnostic(Errors.unknownFunction(funcName, node.range))
-        );
       } else {
-        // Check argument count based on signature
-        const params = func.signatures?.[0]?.parameters || [];
-        const requiredParams = params.filter(p => !p.optional).length;
-        const maxParams = params.length;
-        
-        if (node.arguments.length < requiredParams) {
-          this.diagnostics.push(
-            toDiagnostic(Errors.wrongArgumentCount(funcName, requiredParams, node.arguments.length, node.range))
-          );
-        } else if (node.arguments.length > maxParams) {
-          this.diagnostics.push(
-            toDiagnostic(Errors.wrongArgumentCount(funcName, maxParams, node.arguments.length, node.range))
+        if (match.parameters) {
+          diagnostics.push(
+            ...checkParamTypes(match, argTypes, node.arguments, {
+              warnOnSingletonOnly: true,
+              doesNotPropagateEmpty: !!funcDef.doesNotPropagateEmpty,
+              errorCode: ErrorCodes.ARGUMENT_TYPE_MISMATCH,
+            })
           );
-        }
-        
-        // Type check arguments if we have type information
-        if (node.typeInfo || node.arguments.some(arg => arg.typeInfo)) {
-          this.checkFunctionArgumentTypes(node, func);
+        } else {
+          const permissive = ['anyFalse', 'anyTrue'];
+          if (permissive.includes(functionName)) {
+            return { match, diagnostics, earlyReturn: { type: 'Boolean', singleton: true } };
+          }
         }
       }
     }
-    
-    node.arguments.forEach(arg => this.visitNode(arg));
+
+    return { match, diagnostics };
   }
 
-  private visitMembershipTest(node: MembershipTestNode): void {
-    // Check if ModelProvider is required
-    // Basic primitive types can be checked without ModelProvider
-    const primitiveTypes = ['String', 'Integer', 'Decimal', 'Boolean', 'Date', 'DateTime', 'Time', 'Quantity'];
-    if (!this.modelProvider && !primitiveTypes.includes(node.targetType)) {
-      this.diagnostics.push(
-        toDiagnostic(Errors.modelProviderRequired('is', node.range))
-      );
-    }
-    
-    // Check 'is' with union types
-    if (node.expression.typeInfo) {
-      const leftType = node.expression.typeInfo;
-      if (leftType.modelContext && 
-          typeof leftType.modelContext === 'object' &&
-          'isUnion' in leftType.modelContext && 
-          leftType.modelContext.isUnion &&
-          'choices' in leftType.modelContext &&
-          Array.isArray(leftType.modelContext.choices)) {
-        
-        const targetTypeName = node.targetType;
-        const validChoice = leftType.modelContext.choices.find((choice: any) =>
-          choice.type === targetTypeName || choice.code === targetTypeName
-        );
-        
-        if (!validChoice) {
-          this.diagnostics.push({
-            severity: DiagnosticSeverity.Warning,
-            code: 'invalid-type-test',
-            message: `Type test 'is ${targetTypeName}' will always be false. Type '${targetTypeName}' is not in the union. Available types: ${
-              leftType.modelContext.choices.map((c: any) => c.type || c.code).join(', ')
-            }`,
-            range: node.range
-          });
-        }
-      }
-    }
-    
-    this.visitNode(node.expression);
+  private propagatesEmpty(
+    funcDef: FunctionDefinition,
+    inputType: TypeInfo,
+    argTypes: TypeInfo[]
+  ): boolean {
+    if (funcDef.doesNotPropagateEmpty) {
+      return false;
+    }
+    const inputIsEmpty = isEmptyCollection(inputType);
+    const hasEmptyArgument = argTypes.some(argType => isEmptyCollection(argType));
+    return inputIsEmpty || hasEmptyArgument;
   }
 
-  private visitTypeCast(node: TypeCastNode): void {
-    // Check if ModelProvider is required
-    // Basic primitive types can be checked without ModelProvider
-    const primitiveTypes = ['String', 'Integer', 'Decimal', 'Boolean', 'Date', 'DateTime', 'Time', 'Quantity'];
-    if (!this.modelProvider && !primitiveTypes.includes(node.targetType)) {
-      this.diagnostics.push(
-        toDiagnostic(Errors.modelProviderRequired('as', node.range))
-      );
-    }
-    
-    // Check 'as' with union types
-    if (node.expression.typeInfo) {
-      const leftType = node.expression.typeInfo;
-      if (leftType.modelContext && 
-          typeof leftType.modelContext === 'object' &&
-          'isUnion' in leftType.modelContext && 
-          leftType.modelContext.isUnion &&
-          'choices' in leftType.modelContext &&
-          Array.isArray(leftType.modelContext.choices)) {
-        
-        const targetTypeName = node.targetType;
-        const validChoice = leftType.modelContext.choices.find((choice: any) =>
-          choice.type === targetTypeName || choice.code === targetTypeName
-        );
-        
-        if (!validChoice) {
-          this.diagnostics.push({
-            severity: DiagnosticSeverity.Warning,
-            code: 'invalid-type-cast',
-            message: `Type cast 'as ${targetTypeName}' may fail. Type '${targetTypeName}' is not guaranteed in the union. Available types: ${
-              leftType.modelContext.choices.map((c: any) => c.type || c.code).join(', ')
-            }`,
-            range: node.range
-          });
-        }
-      }
+  private async inferFunctionResultType(
+    funcDef: FunctionDefinition,
+    node: FunctionNode,
+    context: AnalysisContext,
+    argTypes: TypeInfo[],
+    matchingSignature: FunctionSignature | null
+  ): Promise<TypeInfo> {
+    if (funcDef.inferResultType) {
+      return funcDef.inferResultType(this, node, context.inputType);
+    }
+    if (matchingSignature) {
+      return resolveResultType(matchingSignature.result as any, {
+        input: context.inputType,
+        firstParam: argTypes[0],
+      });
     }
-    
-    this.visitNode(node.expression);
+    return context.inputType;
   }
 
-  // Unified variable validation to eliminate duplication
-  private validateVariable(name: string, node: ASTNode): void {
-    if (name.startsWith('$')) {
-      if (!this.variables.has(name)) {
-        this.diagnostics.push(
-          toDiagnostic(Errors.unknownVariable(name, node.range))
-        );
-      }
-    } else if (name.startsWith('%')) {
-      const varName = name.substring(1);
-      if (!this.variables.has(varName)) {
-        this.diagnostics.push(
-          toDiagnostic(Errors.unknownUserVariable(name, node.range))
-        );
+  /**
+   * Analyzes variable references, checking against context.
+   */
+  private analyzeVariable(node: VariableNode, context: AnalysisContext): InternalAnalysisResult {
+    const varName = node.name;
+    const diagnostics: Diagnostic[] = [];
+
+    // Check if it's a user variable (starts with %)
+    if (varName.startsWith('%')) {
+      // Special handling for %context - it's a built-in environment variable
+      // that always returns the original input to the evaluation engine
+      if (varName === '%context') {
+        // %context returns the root input type (the original input to evaluate())
+        // In the analyzer, we track this as the initial input type
+        return { type: context.inputType, diagnostics, context };
       }
-    }
-  }
-  
-  private collectDefinedVariables(node: ASTNode): Set<string> {
-    const vars = new Set<string>();
-    
-    // If this is a defineVariable call, extract the variable name
-    if (node.type === NodeType.Function) {
-      const funcNode = node as FunctionNode;
-      if (funcNode.name.type === NodeType.Identifier && 
-          (funcNode.name as IdentifierNode).name === 'defineVariable' &&
-          funcNode.arguments.length >= 1) {
-        const nameArg = funcNode.arguments[0];
-        if (nameArg && nameArg.type === NodeType.Literal && nameArg.valueType === 'string') {
-          vars.add(nameArg.value as string);
+      
+      const name = varName.substring(1); // Remove % prefix
+      const varType = context.userVariables.get(name);
+      
+      if (!varType) {
+        // If we have dynamic variables in scope, we can't be sure this is an error
+        if (context.hasDynamicVariables) {
+          diagnostics.push(this.createWarning(node, `Variable '${varName}' may not be defined (dynamic variables in scope)`));
+          // Return Any type since we don't know the actual type
+          return { type: { type: 'Any', singleton: false }, diagnostics };
+        } else {
+          // No dynamic variables, so this is definitely an error
+          diagnostics.push(this.createError(node, Errors.unknownUserVariable(varName).message, ErrorCodes.UNKNOWN_USER_VARIABLE));
+          return { type: { type: 'Any', singleton: false }, diagnostics };
         }
       }
+      
+      // Attach type info to the node for backward compatibility
+      node.typeInfo = varType;
+      return { type: varType, diagnostics, context };
     }
-    
-    // If this is a binary dot operator, collect from left side recursively
-    if (node.type === NodeType.Binary) {
-      const binaryNode = node as BinaryNode;
-      if (binaryNode.operator === '.') {
-        // Collect from left side
-        const leftVars = this.collectDefinedVariables(binaryNode.left);
-        leftVars.forEach(v => vars.add(v));
-        
-        // Check if right side is also defineVariable
-        if (binaryNode.right.type === NodeType.Function) {
-          const rightFunc = binaryNode.right as FunctionNode;
-          if (rightFunc.name.type === NodeType.Identifier && 
-              (rightFunc.name as IdentifierNode).name === 'defineVariable' &&
-              rightFunc.arguments.length >= 1) {
-            const nameArg = rightFunc.arguments[0];
-            if (nameArg && nameArg.type === NodeType.Literal && nameArg.valueType === 'string') {
-              vars.add(nameArg.value as string);
-            }
-          }
-        }
-      }
+
+    // Check system variables
+    const sysVarType = context.systemVariables.get(varName);
+    if (sysVarType) {
+      // Attach type info to the node for backward compatibility
+      node.typeInfo = sysVarType;
+      return { type: sysVarType, diagnostics, context };
     }
-    
-    return vars;
+
+    // Unknown variable
+    diagnostics.push(this.createError(node, `Unknown variable: ${varName}`, ErrorCodes.UNKNOWN_VARIABLE));
+    return { type: { type: 'Any', singleton: false }, diagnostics };
   }
-  
-  private collectDefinedVariablesWithTypes(node: ASTNode): Map<string, TypeInfo> {
-    const varsWithTypes = new Map<string, TypeInfo>();
-    
-    // If this is a defineVariable call, extract the variable name and type
-    if (node.type === NodeType.Function) {
-      const funcNode = node as FunctionNode;
-      if (funcNode.name.type === NodeType.Identifier && 
-          (funcNode.name as IdentifierNode).name === 'defineVariable' &&
-          funcNode.arguments.length >= 1) {
-        const nameArg = funcNode.arguments[0];
-        if (nameArg && nameArg.type === NodeType.Literal && nameArg.valueType === 'string') {
-          const varName = nameArg.value as string;
-          let varType: TypeInfo;
-          
-          if (funcNode.arguments.length >= 2 && funcNode.arguments[1]!.typeInfo) {
-            // Has value expression - use its type
-            varType = funcNode.arguments[1]!.typeInfo;
-          } else if (node.typeInfo) {
-            // No value expression - uses input as value (defineVariable returns input)
-            varType = node.typeInfo;
-          } else {
-            varType = { type: 'Any', singleton: false };
-          }
-          
-          varsWithTypes.set(varName, varType);
-        }
+
+  /**
+   * Analyzes identifier nodes (property access).
+   */
+  private async analyzeIdentifier(node: IdentifierNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const name = 'name' in node ? node.name : '';
+    const diagnostics: Diagnostic[] = [];
+    
+    // Try to use model provider for accurate type information
+    if (context.modelProvider) {
+      // First try to navigate from input type (property access)
+      const elementType = await context.modelProvider.getElementType(context.inputType, name);
+      if (elementType) {
+        return {
+          type: elementType,
+          diagnostics,
+          context
+        };
       }
-    }
-    
-    // If this is a binary dot operator, collect from entire chain
-    if (node.type === NodeType.Binary) {
-      const binaryNode = node as BinaryNode;
-      if (binaryNode.operator === '.') {
-        // Collect from left side recursively
-        const leftVars = this.collectDefinedVariablesWithTypes(binaryNode.left);
-        leftVars.forEach((type, name) => varsWithTypes.set(name, type));
-        
-        // Check if right side is also defineVariable
-        if (binaryNode.right.type === NodeType.Function) {
-          const rightFunc = binaryNode.right as FunctionNode;
-          if (rightFunc.name.type === NodeType.Identifier && 
-              (rightFunc.name as IdentifierNode).name === 'defineVariable' &&
-              rightFunc.arguments.length >= 1) {
-            const nameArg = rightFunc.arguments[0];
-            if (nameArg && nameArg.type === NodeType.Literal && nameArg.valueType === 'string') {
-              const varName = nameArg.value as string;
-              let varType: TypeInfo;
-              
-              if (rightFunc.arguments.length >= 2 && rightFunc.arguments[1]!.typeInfo) {
-                varType = rightFunc.arguments[1]!.typeInfo;
-              } else if (binaryNode.typeInfo) {
-                varType = binaryNode.typeInfo;
-              } else {
-                varType = { type: 'Any', singleton: false };
-              }
-              
-              varsWithTypes.set(varName, varType);
-            }
-          }
+      // Chain-head rule: at the head of a navigation chain, allow treating the
+      // identifier as a known type to seed the chain (e.g., Patient.name)
+      if ((context as any)._chainHead === true) {
+        const typeInfo = await context.modelProvider.getType(name);
+        if (typeInfo) {
+          return {
+            type: typeInfo,
+            diagnostics,
+            context
+          };
         }
       }
+      
+      // If property not found and we have a concrete non-union type, report warning
+      // FHIRPath returns empty for unknown properties, not an error
+      const mc: any = context.inputType.modelContext;
+      const isUnion = !!(mc && typeof mc === 'object' && 'isUnion' in mc && mc.isUnion);
+      if (context.inputType.namespace && context.inputType.name && context.inputType.modelContext && !isUnion) {
+        const typeStr = `${context.inputType.namespace}.${context.inputType.name}`;
+        diagnostics.push(toDiagnostic(Errors.unknownProperty(name, typeStr, node.range), DiagnosticSeverity.Warning));
+        return {
+          type: { type: 'Any', singleton: false },
+          diagnostics,
+          context
+        };
+      }
     }
     
-    return varsWithTypes;
+    // Without a model provider, we can't know the type
+    // Return Any type - don't make assumptions
+    return {
+      type: { type: 'Any', singleton: false },
+      diagnostics,
+      context
+    };
   }
 
-
-  // Type inference methods
-  private async inferType(node: ASTNode, inputType?: TypeInfo): Promise<TypeInfo> {
-    // Handle error nodes
-    if (node.type === 'Error') {
-      return this.inferErrorNodeType(node as ErrorNode, inputType);
-    }
+  /**
+   * Analyzes literal values.
+   */
+  private analyzeLiteral(node: LiteralNode, context: AnalysisContext): InternalAnalysisResult {
+    let type: TypeInfo;
     
-    switch (node.type) {
-      case NodeType.Literal:
-        return this.inferLiteralType(node as LiteralNode);
-        
-      case NodeType.Binary:
-        return await this.inferBinaryType(node as BinaryNode, inputType);
-        
-      case NodeType.Unary:
-        return this.inferUnaryType(node as UnaryNode);
-        
-      case NodeType.Function:
-        return await this.inferFunctionType(node as FunctionNode, inputType);
-        
-      case NodeType.Identifier:
-        return await this.inferIdentifierType(node as IdentifierNode, inputType);
-        
-      case NodeType.Variable:
-        return this.inferVariableType(node as VariableNode);
-        
-      case NodeType.Collection:
-        return await this.inferCollectionType(node as CollectionNode);
-        
-      case NodeType.TypeCast:
-        return await this.inferTypeCastType(node as TypeCastNode);
-        
-      case NodeType.MembershipTest:
-        return { type: 'Boolean', singleton: true };
-        
-      case NodeType.TypeOrIdentifier:
-        return await this.inferTypeOrIdentifierType(node as TypeOrIdentifierNode, inputType);
-        
-      default:
-        return { type: 'Any', singleton: false };
-    }
-  }
-  
-  private inferErrorNodeType(errorNode: ErrorNode, inputType?: TypeInfo): TypeInfo {
-    // For error nodes, return a generic type that allows partial analysis to continue
-    // This enables type checking for valid parts of broken expressions
-    return { type: 'Any', singleton: false };
-  }
-  
-  private inferLiteralType(node: LiteralNode): TypeInfo {
     switch (node.valueType) {
       case 'string':
-        return { type: 'String', singleton: true };
+        type = { type: 'String', singleton: true };
+        break;
       case 'number':
-        const num = node.value as number;
-        return { 
-          type: Number.isInteger(num) ? 'Integer' : 'Decimal', 
-          singleton: true 
-        };
+        // Number without decimal point is integer
+        type = { type: 'Integer', singleton: true };
+        break;
+      case 'decimal':
+        // Number with decimal point is decimal (even if value is whole)
+        type = { type: 'Decimal', singleton: true };
+        break;
       case 'boolean':
-        return { type: 'Boolean', singleton: true };
+        type = { type: 'Boolean', singleton: true };
+        break;
       case 'date':
-        return { type: 'Date', singleton: true };
-      case 'datetime':
-        return { type: 'DateTime', singleton: true };
+        type = { type: 'Date', singleton: true };
+        break;
       case 'time':
-        return { type: 'Time', singleton: true };
-      case 'null':
-        return { type: 'Any', singleton: false }; // Empty collection
+        type = { type: 'Time', singleton: true };
+        break;
+      case 'datetime':
+        type = { type: 'DateTime', singleton: true };
+        break;
       default:
-        return { type: 'Any', singleton: true };
-    }
-  }
-  
-  private async inferBinaryType(node: BinaryNode, inputType?: TypeInfo): Promise<TypeInfo> {
-    const operator = registry.getOperatorDefinition(node.operator);
-    if (!operator) {
-      return { type: 'Any', singleton: false };
-    }
-    
-    // For navigation (dot operator), we need special handling
-    if (node.operator === '.') {
-      return await this.inferNavigationType(node, inputType);
-    }
-    
-    // Infer types of operands
-    const leftType = await this.inferType(node.left, inputType);
-    const rightType = await this.inferType(node.right, inputType);
-    
-    // Find matching signature
-    for (const sig of operator.signatures) {
-      if (this.isTypeCompatible(leftType, sig.left) && 
-          this.isTypeCompatible(rightType, sig.right)) {
-        return this.resolveResultType(sig.result, inputType, leftType, rightType);
-      }
+        type = { type: 'Any', singleton: true };
     }
     
-    // Default to first signature's result type
-    const defaultResult = operator.signatures[0]?.result || { type: 'Any', singleton: false };
-    return this.resolveResultType(defaultResult, inputType, leftType, rightType);
+    return { type, diagnostics: [] };
   }
   
-  private async inferNavigationType(node: BinaryNode, inputType?: TypeInfo): Promise<TypeInfo> {
-    const leftType = await this.inferType(node.left, inputType);
-    
-    // If the right side is a function, return the function's type
-    if (node.right.type === NodeType.Function) {
-      return await this.inferType(node.right, leftType);
-    }
+  private analyzeTemporalLiteral(node: TemporalLiteralNode, context: AnalysisContext): InternalAnalysisResult {
+    let type: TypeInfo;
     
-    // If we have a model provider and the right side is an identifier
-    if (this.modelProvider && node.right.type === NodeType.Identifier) {
-      const propertyName = (node.right as IdentifierNode).name;
-      
-      // Use getElementType to navigate the property
-      const resultType = await this.modelProvider.getElementType(leftType, propertyName);
-      if (resultType) {
-        return resultType;
-      }
-      
-      // If property not found and we have a concrete type from model provider, report error
-      // Skip diagnostics for union types - they may have dynamic properties
-      if (leftType.namespace && leftType.name && leftType.modelContext && 
-          !(leftType.modelContext as any).isUnion) {
-        this.diagnostics.push(
-          toDiagnostic(Errors.unknownProperty(propertyName, `${leftType.namespace}.${leftType.name}`, node.right.range))
-        );
-      }
+    switch (node.valueType) {
+      case 'date':
+        type = { type: 'Date', singleton: true };
+        break;
+      case 'time':
+        type = { type: 'Time', singleton: true };
+        break;
+      case 'datetime':
+        type = { type: 'DateTime', singleton: true };
+        break;
+      default:
+        type = { type: 'Any', singleton: true };
     }
     
-    // Default navigation behavior
-    return { type: 'Any', singleton: false };
+    return { type, diagnostics: [] };
   }
-  
-  private inferUnaryType(node: UnaryNode): TypeInfo {
-    const operator = registry.getOperatorDefinition(node.operator);
-    if (!operator) {
-      return { type: 'Any', singleton: false };
-    }
-    
-    // Unary operators typically have one signature
-    const signature = operator.signatures[0];
-    if (signature && typeof signature.result === 'object') {
-      return signature.result;
+
+  /**
+   * Analyzes unary operators.
+   */
+  private async analyzeUnary(node: UnaryNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const operandResult = await this.analyzeNode(node.operand, context);
+    const diagnostics: Diagnostic[] = [...operandResult.diagnostics];
+    const opDef = registry.getOperatorDefinition(node.operator);
+
+    if (opDef && opDef.signatures && opDef.signatures.length > 0) {
+      // Use first signature's result if defined
+      const sig = opDef.signatures[0]!;
+      const resultType = typeof sig.result === 'object' ? sig.result : operandResult.type;
+      return { type: resultType, diagnostics };
     }
-    
-    return { type: 'Any', singleton: false };
+
+    // Fallback: preserve operand type
+    return { type: operandResult.type, diagnostics };
   }
-  
-  private async inferFunctionType(node: FunctionNode, inputType?: TypeInfo): Promise<TypeInfo> {
-    if (node.name.type !== NodeType.Identifier) {
-      return { type: 'Any', singleton: false };
-    }
-    
-    const funcName = (node.name as IdentifierNode).name;
-    const func = registry.getFunction(funcName);
-    
-    if (!func) {
-      return { type: 'Any', singleton: false };
-    }
-    
-    // Special handling for iif function
-    if (funcName === 'iif') {
-      // iif returns the common type of the true and false branches
-      if (node.arguments.length >= 2) {
-        const trueBranchType = await this.inferType(node.arguments[1]!, inputType);
-        if (node.arguments.length >= 3) {
-          const falseBranchType = await this.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 (this.isTypeCompatible(trueBranchType, falseBranchType)) {
-            return falseBranchType;
-          }
-          if (this.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 };
-    }
-    
-    // Special handling for defineVariable function
-    if (funcName === 'defineVariable') {
-      // defineVariable returns its input type unchanged
-      return inputType || { type: 'Any', singleton: false };
-    }
-    
-    // Special handling for aggregate function
-    if (funcName === 'aggregate') {
-      // If init parameter is provided, use its type to infer result type
-      if (node.arguments.length >= 2) {
-        const initType = await this.inferType(node.arguments[1]!, inputType);
-        // The result type is the same as init type
-        return initType;
-      }
-      // Without init, we can't fully infer the type without running annotation
-      // This is a limitation - the actual type will be set during annotateAST
-      if (node.arguments.length >= 1) {
-        // We could try to infer, but it would require setting up system variables
-        // For now, return Any and let annotateAST handle proper typing
-        return { type: 'Any', singleton: false };
-      }
-      // No arguments at all
-      return { type: 'Any', singleton: false };
-    }
-    
-    // Special handling for children function
-    if (funcName === 'children') {
-      if (inputType && this.modelProvider && 'getChildrenType' in this.modelProvider) {
-        const childrenType = await this.modelProvider.getChildrenType(inputType);
-        if (childrenType) {
-          return childrenType;
-        }
-      }
-      // Fallback to Any collection
-      return { type: 'Any', singleton: false };
-    }
-    
-    // Special handling for descendants function
-    // Returns Any type due to combinatorial explosion of possible types
-    if (funcName === 'descendants') {
-      return { type: 'Any', singleton: false };
-    }
-    
-    // Special handling for functions with dynamic result types
-    // Use first matching signature's result type
-    const matchingSignature = func.signatures?.find(sig => 
-      !sig.input || !inputType || this.isTypeCompatible(inputType, sig.input)
-    ) || func.signatures?.[0];
-    
-    if (!matchingSignature) {
-      return { type: 'Any', singleton: false };
-    }
-    
-    if (matchingSignature.result === 'inputType') {
-      // Functions like where() return the same type as input but always as collection
-      return inputType ? { ...inputType, singleton: false } : { type: 'Any', singleton: false };
-    } else if (matchingSignature.result === 'inputTypeSingleton') {
-      // Functions like first(), last() return the same type as input but as singleton
-      return inputType ? { ...inputType, singleton: true } : { type: 'Any', singleton: true };
-    } else if (matchingSignature.result === 'parameterType' && node.arguments.length > 0) {
-      // Functions like select() return the type of the first parameter expression as collection
-      const paramType = await this.inferType(node.arguments[0]!, inputType);
-      return { ...paramType, singleton: false };
-    } else if (typeof matchingSignature.result === 'object') {
-      return matchingSignature.result;
+
+  /**
+   * Analyzes index operations.
+   */
+  private async analyzeIndex(node: IndexNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const exprResult = await this.analyzeNode(node.expression, context);
+    const indexResult = await this.analyzeNode(node.index, context);
+    const diagnostics: Diagnostic[] = [...exprResult.diagnostics, ...indexResult.diagnostics];
+
+    // Index should be Integer singleton; if unknown, skip strict error
+    const idxType = indexResult.type;
+    const isIntegerSingleton = idxType.type === 'Integer' && idxType.singleton === true;
+    if (!isIntegerSingleton && idxType.type !== 'Any') {
+      diagnostics.push(this.createError(node.index, 'Index must be an Integer singleton', ErrorCodes.ARGUMENT_TYPE_MISMATCH));
     }
-    
-    return { type: 'Any', singleton: false };
+
+    // Result is the element type (singleton) of the expression collection
+    const exprType = exprResult.type;
+    const resultType = { ...exprType, singleton: true };
+    return { type: resultType, diagnostics };
   }
-  
-  private async inferIdentifierType(node: IdentifierNode, inputType?: TypeInfo): Promise<TypeInfo> {
-    // First, try to navigate from input type (most common case)
-    if (inputType && this.modelProvider) {
-      const elementType = await this.modelProvider.getElementType(inputType, node.name);
-      if (elementType) {
-        return elementType;
-      }
-    }
-    
-    // Only check if it's a type name if it starts with uppercase (FHIR convention)
-    // or if there's no input type context
-    // Skip common FHIRPath keywords and function names that aren't types
-    const fhirPathKeywords = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time', 'Quantity', 'ofType'];
-    if (this.modelProvider && (!inputType || /^[A-Z]/.test(node.name)) && !fhirPathKeywords.includes(node.name)) {
-      // Try to get type from model provider
-      const typeInfo = await this.modelProvider.getType(node.name);
-      if (typeInfo) {
-        return typeInfo;
-      }
-    }
-    
-    return { type: 'Any', singleton: false };
+
+  /**
+   * Analyzes quantity literals.
+   */
+  private analyzeQuantity(node: QuantityNode, context: AnalysisContext): InternalAnalysisResult {
+    return {
+      type: { type: 'Quantity', singleton: true },
+      diagnostics: [],
+      context
+    };
   }
-  
-  private async inferTypeOrIdentifierType(node: TypeOrIdentifierNode, inputType?: TypeInfo): Promise<TypeInfo> {
-    // TypeOrIdentifier can be either a type name or a property navigation
-    
-    // First, try navigation from input type (most common case)
-    if (inputType && this.modelProvider) {
-      const elementType = await this.modelProvider.getElementType(inputType, node.name);
-      if (elementType) {
-        return elementType;
+
+  /**
+   * Analyzes collection literals.
+   */
+  private async analyzeCollection(node: CollectionNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const diagnostics: Diagnostic[] = [];
+    const isEmpty = node.elements.length === 0;
+    const elementTypes: TypeInfo[] = [];
+
+    for (const element of node.elements) {
+      const elemResult = await this.analyzeNode(element, context);
+      diagnostics.push(...elemResult.diagnostics);
+      elementTypes.push(elemResult.type);
+      if (this.stoppedAtCursor) {
+        return { type: { type: 'Any', singleton: false }, diagnostics };
       }
     }
-    
-    // Then check if it's a type name (only for uppercase names or no input context)
-    // Skip common FHIRPath keywords and function names that aren't types
-    const fhirPathKeywords = ['Boolean', 'String', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time', 'Quantity', 'ofType'];
-    if (this.modelProvider && (!inputType || /^[A-Z]/.test(node.name)) && !fhirPathKeywords.includes(node.name)) {
-      // Try to get type from model provider
-      const typeInfo = await this.modelProvider.getType(node.name);
-      if (typeInfo) {
-        return typeInfo;
+
+    // Infer common element type
+    let elementType: TypeInfo = { type: 'Any', singleton: true };
+    if (!isEmpty) {
+      elementType = elementTypes[0]!;
+      for (let i = 1; i < elementTypes.length; i++) {
+        const t = elementTypes[i]!;
+        if (elementType.type === t.type) {
+          // keep; if any is non-singleton, result stays collection anyway
+          continue;
+        }
+        // Promote Integer to Decimal when mixed
+        if ((elementType.type === 'Integer' && t.type === 'Decimal') || (elementType.type === 'Decimal' && t.type === 'Integer')) {
+          elementType = { type: 'Decimal', singleton: true };
+          continue;
+        }
+        // Unknown/heterogeneous → Any
+        elementType = { type: 'Any', singleton: true };
+        break;
       }
     }
-    
-    return { type: 'Any', singleton: false };
+
+    return { type: { ...elementType, singleton: false, isEmpty }, diagnostics };
   }
-  
-  private inferVariableType(node: VariableNode): TypeInfo {
-    // System variables - check temporary context
-    if (node.name.startsWith('$')) {
-      const systemType = this.systemVariableTypes.get(node.name);
-      if (systemType) {
-        return systemType;
-      }
-      // Fallback defaults for system variables
-      switch (node.name) {
-        case '$this':
-          return { type: 'Any', singleton: false };
-        case '$index':
-          return { type: 'Integer', singleton: true };
-        case '$total':
-          return { type: 'Any', singleton: false };
-        default:
-          return { type: 'Any', singleton: false };
-      }
-    }
-    
-    // Special FHIRPath environment variables
-    if (node.name === '%context' || node.name === '%resource' || node.name === '%rootResource') {
-      return { type: 'Any', singleton: false }; // These return the original input
-    }
-    
-    // User-defined variables - check with or without % prefix
-    let varName = node.name;
-    if (varName.startsWith('%')) {
-      varName = varName.substring(1);
-    }
+
+  /**
+   * Analyzes membership test (is operator).
+   */
+  private async analyzeMembershipTest(node: MembershipTestNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const exprResult = await this.analyzeNode(node.expression, context);
+    const diagnostics = [...exprResult.diagnostics];
+
+    // ModelProvider requirement for non-primitive target types
+    const primitiveTypes = ['String', 'Integer', 'Decimal', 'Boolean', 'Date', 'DateTime', 'Time', 'Quantity'];
     
-    const userType = this.userVariableTypes.get(varName);
-    if (userType) {
-      return userType;
+    // Normalize System.X types to check if they're primitive
+    let targetType = node.targetType;
+    if (targetType.startsWith('System.')) {
+      targetType = targetType.substring(7); // Remove "System." prefix
     }
     
-    return { type: 'Any', singleton: true };
-  }
-  
-  private async inferCollectionType(node: CollectionNode): Promise<TypeInfo> {
-    if (node.elements.length === 0) {
-      return { type: 'Any', singleton: false };
+    if (!context.modelProvider && !primitiveTypes.includes(targetType)) {
+      diagnostics.push(toDiagnostic(Errors.modelProviderRequired('is', node.range)));
     }
     
-    // Infer types of all elements
-    const elementTypes = await Promise.all(node.elements.map(el => this.inferType(el)));
-    
-    // If all elements have the same type, use that
-    const firstType = elementTypes[0];
-    if (firstType) {
-      const allSameType = elementTypes.every(t => 
-        t.type === firstType.type && 
-        t.namespace === firstType.namespace && 
-        t.name === firstType.name
-      );
-      
-      if (allSameType) {
-        return { ...firstType, singleton: false };
+    // Check if testing against a union type
+    if (isUnionType(exprResult.type)) {
+      const targetType = node.targetType;
+      const choices = getUnionChoices(exprResult.type);
+      if (choices.length > 0 && !choices.includes(targetType)) {
+        diagnostics.push({
+          severity: DiagnosticSeverity.Warning,
+          code: 'invalid-type-test',
+          message: `Type test 'is ${targetType}' will always be false - type not present in union. Available types: ${choices.join(', ')}`,
+          range: node.range
+        });
       }
     }
     
-    // Otherwise, it's a heterogeneous collection
-    return { type: 'Any', singleton: false };
+    return {
+      type: { type: 'Boolean', singleton: true },
+      diagnostics
+    };
   }
-  
-  private async inferTypeCastType(node: TypeCastNode): Promise<TypeInfo> {
-    const targetType = node.targetType;
-    
-    // If we have a model provider, try to get the type
-    if (this.modelProvider) {
-      const typeInfo = await this.modelProvider.getType(targetType);
-      if (typeInfo) {
-        return typeInfo;
+
+  /**
+   * Analyzes type cast (as operator).
+   */
+  private async analyzeTypeCast(node: TypeCastNode, context: AnalysisContext): Promise<InternalAnalysisResult> {
+    const exprResult = await this.analyzeNode(node.expression, context);
+    const diagnostics = [...exprResult.diagnostics];
+
+    // ModelProvider requirement for non-primitive target types
+    const primitiveTypes = ['String', 'Integer', 'Decimal', 'Boolean', 'Date', 'DateTime', 'Time', 'Quantity'];
+    if (!context.modelProvider && !primitiveTypes.includes(node.targetType)) {
+      diagnostics.push(toDiagnostic(Errors.modelProviderRequired('as', node.range)));
+    }
+    
+    // Check if casting from a union type
+    if (isUnionType(exprResult.type)) {
+      const targetTypeName = node.targetType;
+      const choices = getUnionChoices(exprResult.type);
+      if (choices.length > 0 && !choices.includes(targetTypeName)) {
+        diagnostics.push({
+          severity: DiagnosticSeverity.Warning,
+          code: 'invalid-type-cast',
+          message: `Type cast 'as ${targetTypeName}' may fail - type not present in union. Available types: ${choices.join(', ')}`,
+          range: node.range
+        });
       }
     }
     
-    // Otherwise, check if it's a FHIRPath primitive type
-    const fhirPathTypes = ['String', 'Boolean', 'Integer', 'Decimal', 'Date', 'DateTime', 'Time', 'Quantity'];
-    if (fhirPathTypes.includes(targetType)) {
-      return { type: targetType as TypeName, singleton: true };
-    }
+    // Type cast changes the type
+    const targetType: TypeInfo = { 
+      type: node.targetType as TypeName, 
+      singleton: exprResult.type.singleton 
+    };
     
-    return { type: 'Any', singleton: true };
+    return {
+      type: targetType,
+      diagnostics
+    };
   }
-  
-  private isTypeCompatible(source: TypeInfo, target: TypeInfo): boolean {
-    // Exact match
-    if (source.type === target.type && source.singleton === target.singleton) {
-      return true;
-    }
-    
-    // Any is compatible with everything
-    if (source.type === 'Any' || target.type === 'Any') {
-      return true;
-    }
-    
-    // Singleton can be promoted to collection
-    if (source.singleton && !target.singleton && source.type === target.type) {
-      return true;
-    }
-    
-    // Type hierarchy compatibility
-    if (this.isSubtypeOf(source.type, target.type)) {
-      // Check singleton compatibility
-      if (source.singleton === target.singleton || (source.singleton && !target.singleton)) {
-        return true;
-      }
-    }
-    
-    // Numeric type compatibility
-    if (this.isNumericType(source.type) && this.isNumericType(target.type)) {
-      // Integer can be used where Decimal is expected
-      if (source.type === 'Integer' && target.type === 'Decimal') {
-        return source.singleton !== undefined && target.singleton !== undefined && 
-               (source.singleton === target.singleton || (source.singleton && !target.singleton));
+
+  /**
+   * Analyzes error nodes.
+   */
+  private analyzeError(node: ErrorNode, context: AnalysisContext): InternalAnalysisResult {
+    return {
+      type: { type: 'Any', singleton: false },
+      diagnostics: [this.createError(node, node.message, ErrorCodes.INVALID_SYNTAX)]
+    };
+  }
+
+  /**
+   * Analyzes cursor nodes for completion.
+   */
+  private analyzeCursorNode(node: AnyCursorNode, context: AnalysisContext): InternalAnalysisResult {
+    // Store cursor context for completion
+    if (this.cursorMode) {
+      this.stoppedAtCursor = true;
+      this.cursorContext = {
+        typeBeforeCursor: context.inputType,
+        cursorNode: node,
+        expectedType: undefined,
+        functionCall: undefined
+      };
+      
+      // Set expected type based on cursor context
+      if (node.context === CursorContext.Index) {
+        // Index expects an integer
+        this.cursorContext.expectedType = { type: 'Integer', singleton: true };
+      } else if (node.context === CursorContext.Argument) {
+        // Arguments context - check if we're in a function
+        const parent = (node as any).parent;
+        if (parent && parent.type === NodeType.Function) {
+          const funcNode = parent as FunctionNode;
+          if (funcNode.name.type === NodeType.Identifier) {
+            const funcName = (funcNode.name as IdentifierNode).name;
+            const funcDef = registry.getFunction(funcName);
+            if (funcDef) {
+              // Find argument index
+              const argIndex = funcNode.arguments.indexOf(node);
+              this.cursorContext.functionCall = {
+                definition: funcDef,
+                argumentIndex: argIndex >= 0 ? argIndex : 0
+              };
+            }
+          }
+        }
       }
     }
     
-    return false;
+    return {
+      type: { type: 'Any', singleton: false },
+      diagnostics: []
+    };
   }
-  
-  private isSubtypeOf(source: TypeName, target: TypeName): boolean {
-    // Basic subtyping rules
-    if (source === target) return true;
-    if (target === 'Any') return true;
-    
-    // Integer is a subtype of Decimal
-    if (source === 'Integer' && target === 'Decimal') return true;
-    
-    // Model-specific subtyping would be checked via ModelProvider
-    // For now, we don't have other subtyping rules
-    return false;
+
+  // Legacy union combiner removed; union handled in analyzeBinary
+
+  /**
+   * Helper to create diagnostic errors.
+   */
+  private createError(node: ASTNode, message: string, code?: string): Diagnostic {
+    return {
+      range: node.range,
+      message,
+      severity: DiagnosticSeverity.Error,
+      code,
+      source: 'fhirpath'
+    };
   }
   
-  private isNumericType(type: TypeName): boolean {
-    return type === 'Integer' || type === 'Decimal' || type === 'Quantity';
+  private createWarning(node: ASTNode, message: string, code?: string): Diagnostic {
+    return {
+      range: node.range,
+      message,
+      severity: DiagnosticSeverity.Warning,
+      code,
+      source: 'fhirpath'
+    };
   }
-  
+
+  /**
+   * Helper method to infer TypeInfo from runtime values (used for user variables).
+   */
   private inferValueType(value: any): TypeInfo {
     if (Array.isArray(value)) {
       if (value.length === 0) {
@@ -1034,7 +1071,9 @@ export class Analyzer {
     if (typeof value === 'string') {
       return { type: 'String', singleton: true };
     } else if (typeof value === 'number') {
-      return { type: Number.isInteger(value) ? 'Integer' : 'Decimal', singleton: true };
+      return Number.isInteger(value) 
+        ? { type: 'Integer', singleton: true }
+        : { type: 'Decimal', singleton: true };
     } else if (typeof value === 'boolean') {
       return { type: 'Boolean', singleton: true };
     } else if (value instanceof Date) {
@@ -1043,359 +1082,55 @@ export class Analyzer {
       return { type: 'Any', singleton: true };
     }
   }
-  
-  private resolveResultType(
-    resultSpec: TypeInfo | 'inputType' | 'leftType' | 'rightType',
+
+  async analyze(
+    ast: ASTNode, 
+    userVariables?: Record<string, any>, 
     inputType?: TypeInfo,
-    leftType?: TypeInfo,
-    rightType?: TypeInfo
-  ): TypeInfo {
-    if (typeof resultSpec !== 'string') {
-      return resultSpec;
-    }
-    
-    switch (resultSpec) {
-      case 'inputType':
-        return inputType || { type: 'Any', singleton: false };
-      case 'leftType':
-        // For union-like operators, result is always a collection
-        return leftType ? { ...leftType, singleton: false } : { type: 'Any', singleton: false };
-      case 'rightType':
-        return rightType ? { ...rightType, singleton: false } : { type: 'Any', singleton: false };
-      default:
-        return { type: 'Any', singleton: false };
-    }
-  }
-  
-  private checkBinaryOperatorTypes(node: BinaryNode, operator: import('./types').OperatorDefinition): void {
-    const leftType = node.left.typeInfo!;
-    const rightType = node.right.typeInfo!;
-    
-    // Find if any signature matches
-    let foundMatch = false;
-    for (const sig of operator.signatures) {
-      if (this.isTypeCompatible(leftType, sig.left) && 
-          this.isTypeCompatible(rightType, sig.right)) {
-        foundMatch = true;
-        break;
-      }
-    }
+    options?: AnalyzerOptions
+  ): Promise<AnalysisResultWithCursor> {
+    this.cursorMode = options?.cursorMode ?? false;
+    this.stoppedAtCursor = false;
+    this.cursorContext = undefined;
     
-    if (!foundMatch) {
-      const leftTypeStr = this.typeToString(leftType);
-      const rightTypeStr = this.typeToString(rightType);
-      this.diagnostics.push(
-        toDiagnostic(Errors.operatorTypeMismatch(node.operator, leftTypeStr, rightTypeStr, node.range))
-      );
-    }
-  }
-  
-  private checkFunctionArgumentTypes(node: FunctionNode, func: import('./types').FunctionDefinition): void {
-    const params = func.signatures?.[0]?.parameters || [];
+    // Create initial context with system and user variables
+    const systemVars = new Map<string, TypeInfo>();
+    // $this should be the input type (the root context), not Any
+    systemVars.set('$this', inputType || { type: 'Any', singleton: false });
+    systemVars.set('$index', { type: 'Integer', singleton: true });
+    systemVars.set('$total', { type: 'Any', singleton: false });
     
-    for (let i = 0; i < Math.min(node.arguments.length, params.length); i++) {
-      const arg = node.arguments[i]!;
-      const param = params[i]!;
-      
-      if (arg.typeInfo && !param.expression) {
-        // For non-expression parameters, check type compatibility
-        if (!this.isTypeCompatible(arg.typeInfo, param.type)) {
-          const argTypeStr = this.typeToString(arg.typeInfo);
-          const paramTypeStr = this.typeToString(param.type);
-          this.diagnostics.push(
-            toDiagnostic(Errors.argumentTypeMismatch(i + 1, func.name, paramTypeStr, argTypeStr, arg.range))
-          );
+    const userVars = new Map<string, TypeInfo>();
+    if (userVariables) {
+      Object.keys(userVariables).forEach(name => {
+        const value = userVariables[name];
+        if (value !== undefined && value !== null) {
+          userVars.set(name, this.inferValueType(value));
         }
-      }
-    }
-  }
-  
-  private typeToString(type: TypeInfo): string {
-    const singletonStr = type.singleton ? '' : '[]';
-    if (type.namespace && type.name) {
-      return `${type.namespace}.${type.name}${singletonStr}`;
+      });
     }
-    return `${type.type}${singletonStr}`;
-  }
-  
-  /**
-   * Infer the expected type at a cursor position based on context
-   */
-  private inferExpectedTypeForCursor(cursorNode: AnyCursorNode, inputType?: TypeInfo): TypeInfo | undefined {
-    const context = cursorNode.context;
     
-    switch (context) {
-      case CursorContext.Identifier:
-        // After dot, expecting a member of the input type
-        return inputType;
-        
-      case CursorContext.Type:
-        // After is/as/ofType, expecting a type name
-        return { type: 'System.String' as TypeName, singleton: true };
-        
-      case CursorContext.Argument:
-        // In function argument, would need to look up function signature
-        // For now, return Any
-        return { type: 'Any' as TypeName, singleton: false };
-        
-      case CursorContext.Index:
-        // In indexer, expecting Integer
-        return { type: 'Integer' as TypeName, singleton: true };
-        
-      case CursorContext.Operator:
-        // Between expressions, could be any operator
-        // Return the input type as context
-        return inputType;
-        
-      default:
-        return undefined;
-    }
-  }
-
-  /**
-   * Annotate AST with type information
-   */
-  private async annotateAST(node: ASTNode, inputType?: TypeInfo): Promise<void> {
-    // Check for cursor node in cursor mode
-    if (this.cursorMode && isCursorNode(node)) {
-      this.stoppedAtCursor = true;
-      this.cursorContext = {
-        cursorNode: node as AnyCursorNode,
-        typeBeforeCursor: inputType,
-        expectedType: this.inferExpectedTypeForCursor(node as AnyCursorNode, inputType)
-      };
-      // Still attach a type to the cursor node for consistency
-      (node as any).typeInfo = inputType || { type: 'Any', singleton: false };
-      return; // Short-circuit
-    }
+    // Create context with analyzeNode callback and model provider
+    const initialContext = new AnalysisContext(
+      inputType || { type: 'Any', singleton: false },
+      systemVars,
+      userVars,
+      (node, ctx) => this.analyzeNode(node, ctx),
+      this.modelProvider
+    );
     
-    // If we've already stopped at cursor, don't continue
-    if (this.stoppedAtCursor) {
-      return;
-    }
+    // Run context-flow analysis
+    const result = await this.analyzeNode(ast, initialContext);
     
-    // Handle error nodes
-    if (node.type === 'Error') {
-      const errorNode = node as ErrorNode;
-      // Infer a reasonable type for error nodes
-      node.typeInfo = this.inferErrorNodeType(errorNode, inputType);
-      // Add diagnostic for the error
-      this.diagnostics.push({
-        severity: errorNode.severity || DiagnosticSeverity.Error,
-        message: errorNode.message,
-        range: errorNode.range,
-        code: errorNode.code?.toString() || 'FP5003',
-        source: 'fhirpath'
-      });
-      return;
-    }
+    // Legacy annotateAST/visitor path removed from default analysis to avoid duplication.
     
-    // Infer and attach type info
-    node.typeInfo = await this.inferType(node, inputType);
-
-    // Recursively annotate children
-    switch (node.type) {
-      case NodeType.Binary:
-        const binaryNode = node as BinaryNode;
-        await this.annotateAST(binaryNode.left, inputType);
-        
-        // If we stopped at cursor, don't continue
-        if (this.stoppedAtCursor) {
-          break;
-        }
-        
-        // Check if right side is a cursor node - if so, set type from left
-        if (this.cursorMode && isCursorNode(binaryNode.right)) {
-          this.stoppedAtCursor = true;
-          this.cursorContext = {
-            cursorNode: binaryNode.right as AnyCursorNode,
-            typeBeforeCursor: binaryNode.left.typeInfo,
-            expectedType: this.inferExpectedTypeForCursor(binaryNode.right as AnyCursorNode, binaryNode.left.typeInfo)
-          };
-          // Still attach type to cursor node
-          (binaryNode.right as any).typeInfo = binaryNode.left.typeInfo || { type: 'Any', singleton: false };
-          break;
-        }
-        
-        // For navigation, pass the left's type as input to the right
-        if (binaryNode.operator === '.') {
-          // Collect all variables defined in the left side chain
-          const definedVarsWithTypes = this.collectDefinedVariablesWithTypes(binaryNode.left);
-          
-          if (definedVarsWithTypes.size > 0) {
-            // Save current variable types
-            const savedTypes = new Map<string, TypeInfo>();
-            definedVarsWithTypes.forEach((type, varName) => {
-              const currentType = this.userVariableTypes.get(varName);
-              if (currentType) {
-                savedTypes.set(varName, currentType);
-              }
-              this.userVariableTypes.set(varName, type);
-            });
-            
-            // Annotate right side with new variables in scope
-            await this.annotateAST(binaryNode.right, binaryNode.left.typeInfo);
-            
-            // Restore previous types
-            definedVarsWithTypes.forEach((_, varName) => {
-              const savedType = savedTypes.get(varName);
-              if (savedType) {
-                this.userVariableTypes.set(varName, savedType);
-              } else {
-                this.userVariableTypes.delete(varName);
-              }
-            });
-          } else {
-            // No defineVariable in chain, proceed normally
-            await this.annotateAST(binaryNode.right, binaryNode.left.typeInfo);
-          }
-        } else {
-          await this.annotateAST(binaryNode.right, inputType);
-        }
-        break;
-        
-      case NodeType.Unary:
-        const unaryNode = node as UnaryNode;
-        await this.annotateAST(unaryNode.operand, inputType);
-        break;
-        
-      case NodeType.Function:
-        const funcNode = node as FunctionNode;
-        await this.annotateAST(funcNode.name, inputType);
-        
-        // Special handling for aggregate function arguments
-        if (funcNode.name.type === NodeType.Identifier && 
-            (funcNode.name as IdentifierNode).name === 'aggregate') {
-          // Aggregate establishes both $this and $total
-          if (funcNode.arguments.length >= 1) {
-            const itemType = inputType ? { ...inputType, singleton: true } : { type: 'Any' as TypeName, singleton: true };
-            
-            // Save current system variable context
-            const savedThis = this.systemVariableTypes.get('$this');
-            const savedTotal = this.systemVariableTypes.get('$total');
-            
-            // Set $this for iteration
-            this.systemVariableTypes.set('$this', itemType);
-            
-            if (funcNode.arguments.length >= 2) {
-              // Has init parameter - evaluate it first
-              await this.annotateAST(funcNode.arguments[1]!, inputType);
-              const initType = funcNode.arguments[1]!.typeInfo;
-              
-              // Set $total to init type
-              if (initType) {
-                this.systemVariableTypes.set('$total', initType);
-              } else {
-                this.systemVariableTypes.set('$total', { type: 'Any', singleton: false });
-              }
-              
-              // Process aggregator with both variables set
-              await this.annotateAST(funcNode.arguments[0]!, inputType);
-              
-              // Process remaining arguments
-              for (const arg of funcNode.arguments.slice(2)) {
-                await this.annotateAST(arg, inputType);
-                if (this.stoppedAtCursor) break;
-              }
-            } else {
-              // No init - first pass to infer aggregator type
-              this.systemVariableTypes.set('$total', { type: 'Any', singleton: false });
-              await this.annotateAST(funcNode.arguments[0]!, inputType);
-              
-              // Second pass with inferred type
-              const aggregatorType = funcNode.arguments[0]!.typeInfo;
-              if (aggregatorType) {
-                this.systemVariableTypes.set('$total', aggregatorType);
-                // Re-annotate with proper $total type
-                await this.annotateAST(funcNode.arguments[0]!, inputType);
-              }
-            }
-            
-            // Restore previous context
-            if (savedThis) {
-              this.systemVariableTypes.set('$this', savedThis);
-            } else {
-              this.systemVariableTypes.delete('$this');
-            }
-            if (savedTotal) {
-              this.systemVariableTypes.set('$total', savedTotal);
-            } else {
-              this.systemVariableTypes.delete('$total');
-            }
-          }
-        } else {
-          // Special handling for functions that pass their input as context to arguments
-          const funcName = funcNode.name.type === NodeType.Identifier ? 
-            (funcNode.name as IdentifierNode).name : null;
-          
-          if (funcName && ['where', 'select', 'all', 'exists'].includes(funcName)) {
-            // These functions establish $this as each element of the input collection
-            const elementType = inputType ? { ...inputType, singleton: true } : { type: 'Any' as TypeName, singleton: true };
-            
-            // Save current system variable context
-            const savedThis = this.systemVariableTypes.get('$this');
-            const savedIndex = this.systemVariableTypes.get('$index');
-            
-            // Set system variables for expression evaluation
-            this.systemVariableTypes.set('$this', elementType);
-            this.systemVariableTypes.set('$index', { type: 'Integer', singleton: true });
-            
-            // Process arguments with system variables in scope
-            for (const arg of funcNode.arguments) {
-              await this.annotateAST(arg, inputType);
-              if (this.stoppedAtCursor) break;
-            }
-            
-            // Restore previous context
-            if (savedThis) {
-              this.systemVariableTypes.set('$this', savedThis);
-            } else {
-              this.systemVariableTypes.delete('$this');
-            }
-            if (savedIndex) {
-              this.systemVariableTypes.set('$index', savedIndex);
-            } else {
-              this.systemVariableTypes.delete('$index');
-            }
-          } else {
-            // Regular function argument annotation
-            for (const arg of funcNode.arguments) {
-              await this.annotateAST(arg, inputType);
-              if (this.stoppedAtCursor) break;
-            }
-          }
-        }
-        break;
-        
-      case NodeType.Collection:
-        const collNode = node as CollectionNode;
-        for (const el of collNode.elements) {
-          await this.annotateAST(el, inputType);
-          if (this.stoppedAtCursor) break;
-        }
-        break;
-        
-      case NodeType.TypeCast:
-        const castNode = node as TypeCastNode;
-        await this.annotateAST(castNode.expression, inputType);
-        break;
-        
-      case NodeType.MembershipTest:
-        const memberNode = node as MembershipTestNode;
-        await this.annotateAST(memberNode.expression, inputType);
-        break;
-        
-      case NodeType.Index:
-        const indexNode = node as IndexNode;
-        await this.annotateAST(indexNode.expression, inputType);
-        if (!this.stoppedAtCursor) {
-          await this.annotateAST(indexNode.index, inputType);
-        }
-        break;
-        
-      case NodeType.TypeOrIdentifier:
-        // TypeOrIdentifier doesn't have children to annotate
-        break;
-    }
+    return {
+      diagnostics: result.diagnostics,
+      ast,
+      type: result.type,
+      userVariables: new Map(result.context?.userVariables || initialContext.userVariables),
+      stoppedAtCursor: this.cursorMode ? this.stoppedAtCursor : undefined,
+      cursorContext: this.cursorMode ? this.cursorContext : undefined
+    };
   }
-}
+}