@atomic-ehr/fhirpath 0.0.1-canary.0c6931e.20250727185306

package/src/parser/pprint.ts

@@ -0,0 +1,169 @@
+import type { 
+  ASTNode, 
+  IdentifierNode, 
+  TypeOrIdentifierNode, 
+  VariableNode,
+  TypeReferenceNode,
+  BinaryNode,
+  UnaryNode,
+  UnionNode,
+  FunctionNode,
+  CollectionNode,
+  MembershipTestNode,
+  TypeCastNode,
+  IndexNode,
+  LiteralNode
+} from './ast';
+import { NodeType } from './ast';
+import { TokenType } from '../lexer/token';
+
+/**
+ * Pretty print an AST node as an S-expression (without position information)
+ */
+export function pprint(node: ASTNode, multiline: boolean = false, indent: number = 0): string {
+  const spaces = multiline ? ' '.repeat(indent) : '';
+  const nl = multiline ? '\n' : '';
+  const childIndent = indent + 2;
+  
+  switch (node.type) {
+    case NodeType.Literal:
+      const lit = node as LiteralNode;
+      return `${spaces}(${pprintLiteralValue(lit)}:${lit.valueType})`;
+    
+    case NodeType.Identifier:
+      return `${spaces}(${(node as IdentifierNode).name}:id)`;
+    
+    case NodeType.TypeOrIdentifier:
+      return `${spaces}(${(node as TypeOrIdentifierNode).name}:type-or-id)`;
+    
+    case NodeType.Variable:
+      const varNode = node as VariableNode;
+      const varName = varNode.name.startsWith('$') ? varNode.name : `%${varNode.name}`;
+      return `${spaces}(${varName}:var)`;
+    
+    case NodeType.TypeReference:
+      return `${spaces}(${(node as TypeReferenceNode).typeName}:type-ref)`;
+    
+    case NodeType.Binary:
+      const binary = node as BinaryNode;
+      const op = tokenToOp(binary.operator);
+      if (multiline) {
+        return `${spaces}(${op}${nl}${pprint(binary.left, multiline, childIndent)}${nl}${pprint(binary.right, multiline, childIndent)})`;
+      } else {
+        return `(${op} ${pprint(binary.left)} ${pprint(binary.right)})`;
+      }
+    
+    case NodeType.Unary:
+      const unary = node as UnaryNode;
+      const unaryOp = tokenToOp(unary.operator);
+      if (multiline) {
+        return `${spaces}(${unaryOp}:unary${nl}${pprint(unary.operand, multiline, childIndent)})`;
+      } else {
+        return `(${unaryOp}:unary ${pprint(unary.operand)})`;
+      }
+    
+    case NodeType.Union:
+      const union = node as UnionNode;
+      if (multiline) {
+        const operands = union.operands.map(op => pprint(op, multiline, childIndent)).join(nl);
+        return `${spaces}(|${nl}${operands})`;
+      } else {
+        return `(| ${union.operands.map(op => pprint(op)).join(' ')})`;
+      }
+    
+    case NodeType.Function:
+      const func = node as FunctionNode;
+      const funcName = (func.name as IdentifierNode).name;
+      if (multiline && func.arguments.length > 0) {
+        const args = func.arguments.map(arg => pprint(arg, multiline, childIndent)).join(nl);
+        return `${spaces}(${funcName}:fn${nl}${args})`;
+      } else {
+        const args = func.arguments.map(arg => pprint(arg)).join(' ');
+        return args ? `${spaces}(${funcName}:fn ${args})` : `${spaces}(${funcName}:fn)`;
+      }
+    
+    case NodeType.Collection:
+      const coll = node as CollectionNode;
+      if (multiline && coll.elements.length > 0) {
+        const elements = coll.elements.map(el => pprint(el, multiline, childIndent)).join(nl);
+        return `${spaces}({}:collection${nl}${elements})`;
+      } else {
+        const elements = coll.elements.map(el => pprint(el)).join(' ');
+        return elements ? `${spaces}({}:collection ${elements})` : `${spaces}({}:collection)`;
+      }
+    
+    case NodeType.MembershipTest:
+      const memberTest = node as MembershipTestNode;
+      if (multiline) {
+        return `${spaces}(is${nl}${pprint(memberTest.expression, multiline, childIndent)}${nl}${' '.repeat(childIndent)}${memberTest.targetType})`;
+      } else {
+        return `(is ${pprint(memberTest.expression)} ${memberTest.targetType})`;
+      }
+    
+    case NodeType.TypeCast:
+      const typeCast = node as TypeCastNode;
+      if (multiline) {
+        return `${spaces}(as${nl}${pprint(typeCast.expression, multiline, childIndent)}${nl}${' '.repeat(childIndent)}${typeCast.targetType})`;
+      } else {
+        return `(as ${pprint(typeCast.expression)} ${typeCast.targetType})`;
+      }
+    
+    case NodeType.Index:
+      const index = node as IndexNode;
+      if (multiline) {
+        return `${spaces}([]${nl}${pprint(index.expression, multiline, childIndent)}${nl}${pprint(index.index, multiline, childIndent)})`;
+      } else {
+        return `([] ${pprint(index.expression)} ${pprint(index.index)})`;
+      }
+    
+    default:
+      return `${spaces}(unknown:${node.type})`;
+  }
+}
+
+function pprintLiteralValue(node: LiteralNode): string {
+  const value = node.value;
+  const valueType = node.valueType;
+  
+  switch (valueType) {
+    case 'string':
+      return `'${value}'`;
+    case 'number':
+      return String(value);
+    case 'boolean':
+      return String(value);
+    case 'null':
+      return '{}';
+    case 'date':
+    case 'time':
+    case 'datetime':
+      return `@${value}`;
+    default:
+      return String(value);
+  }
+}
+
+function tokenToOp(token: TokenType): string {
+  switch (token) {
+    case TokenType.PLUS: return '+';
+    case TokenType.MINUS: return '-';
+    case TokenType.STAR: return '*';
+    case TokenType.DIV: return 'div';
+    case TokenType.MOD: return 'mod';
+    case TokenType.GT: return '>';
+    case TokenType.LT: return '<';
+    case TokenType.GTE: return '>=';
+    case TokenType.LTE: return '<=';
+    case TokenType.EQ: return '=';
+    case TokenType.NEQ: return '!=';
+    case TokenType.AND: return 'and';
+    case TokenType.OR: return 'or';
+    case TokenType.XOR: return 'xor';
+    case TokenType.IMPLIES: return 'implies';
+    case TokenType.NOT: return 'not';
+    case TokenType.DOT: return '.';
+    case TokenType.CONTAINS: return 'contains';
+    case TokenType.IN: return 'in';
+    default: return token;
+  }
+}

package/src/parser/precedence-manager.ts

@@ -0,0 +1,64 @@
+import type { Token } from '../lexer/token';
+import { TokenType } from '../lexer/token';
+import { Registry } from '../registry';
+
+/**
+ * Manages operator precedence for the parser
+ */
+export class PrecedenceManager {
+  /**
+   * Get precedence for a token
+   * Higher number = higher precedence
+   */
+  static getPrecedence(token: Token): number {
+    // Special case for DOT which might not be in registry yet
+    if (token.type === TokenType.DOT) return 13;
+    
+    // Use registry directly - both now use standard convention
+    return Registry.getPrecedence(token.type);
+  }
+
+  /**
+   * Check if an operator is right-associative
+   */
+  static isRightAssociative(op: Token): boolean {
+    // FHIRPath doesn't have right-associative operators
+    return false;
+  }
+
+  /**
+   * Get associativity adjustment for parsing
+   * For left-associative operators, we parse right side with precedence + 1
+   * For right-associative operators, we parse with same precedence
+   */
+  static getAssociativityAdjustment(op: Token): number {
+    return this.isRightAssociative(op) ? 0 : 1;
+  }
+
+  /**
+   * Check if precedence allows continuation of expression parsing
+   */
+  static shouldContinueParsing(tokenPrecedence: number, minPrecedence: number): boolean {
+    return tokenPrecedence !== 0 && tokenPrecedence >= minPrecedence;
+  }
+
+  /**
+   * Standard precedence levels for reference
+   */
+  static readonly PRECEDENCE_LEVELS = {
+    NONE: 0,
+    IMPLIES: 1,         // implies - lowest precedence
+    OR: 2,              // or, xor
+    AND: 3,             // and
+    MEMBERSHIP: 4,      // in, contains
+    EQUALITY: 5,        // =, ~, !=, !~
+    RELATIONAL: 6,      // <, >, <=, >=
+    UNION: 7,           // |
+    TYPE: 8,            // is, as
+    ADDITIVE: 9,        // +, -, &
+    MULTIPLICATIVE: 10, // *, /, div, mod
+    UNARY: 11,          // unary +, -, not
+    POSTFIX: 12,        // [] indexing
+    INVOCATION: 13      // . (dot), function calls - highest precedence
+  };
+}

package/src/parser/source-mapper.ts

@@ -0,0 +1,248 @@
+import type { Token } from '../lexer/token';
+import type { ASTNode } from './ast';
+import { NodeType } from './ast';
+import type { TextRange, Position } from './types';
+
+export class SourceMapper {
+  private source: string;
+  private lineOffsets: number[] = [];
+  
+  constructor(source: string) {
+    this.source = source;
+    this.calculateLineOffsets();
+  }
+  
+  private calculateLineOffsets(): void {
+    this.lineOffsets = [0];
+    for (let i = 0; i < this.source.length; i++) {
+      if (this.source[i] === '\n') {
+        this.lineOffsets.push(i + 1);
+      }
+    }
+  }
+  
+  tokenToRange(token: Token): TextRange {
+    const start = this.offsetToPosition(token.position.offset);
+    const end = this.offsetToPosition(token.position.offset + token.value.length);
+    
+    return {
+      start,
+      end
+    };
+  }
+  
+  offsetToPosition(offset: number): Position {
+    let line = 0;
+    
+    for (let i = 0; i < this.lineOffsets.length - 1; i++) {
+      if (offset >= this.lineOffsets[i]! && offset < this.lineOffsets[i + 1]!) {
+        line = i;
+        break;
+      }
+    }
+    
+    if (offset >= this.lineOffsets[this.lineOffsets.length - 1]!) {
+      line = this.lineOffsets.length - 1;
+    }
+    
+    const character = offset - this.lineOffsets[line]!;
+    
+    return {
+      line,
+      character,
+      offset
+    };
+  }
+  
+  positionToOffset(line: number, character: number): number {
+    if (line < 0 || line >= this.lineOffsets.length) {
+      return -1;
+    }
+    
+    return this.lineOffsets[line]! + character;
+  }
+  
+  nodeToRange(node: ASTNode): TextRange {
+    // If the node already has a range (from diagnostic mode), use it
+    if (node.range) {
+      return node.range;
+    }
+    
+    const start = this.offsetToPosition(node.position.offset);
+    const end = this.calculateNodeEnd(node);
+    
+    return {
+      start,
+      end
+    };
+  }
+  
+  private calculateNodeEnd(node: ASTNode): Position {
+    let endOffset = node.position.offset;
+    
+    switch (node.type) {
+      case NodeType.Literal: {
+        const literalNode = node as any;
+        if (literalNode.raw) {
+          endOffset += literalNode.raw.length;
+        } else if (typeof literalNode.value === 'string') {
+          endOffset += literalNode.value.length + 2; // +2 for quotes
+        } else if (typeof literalNode.value === 'number') {
+          endOffset += literalNode.value.toString().length;
+        } else if (typeof literalNode.value === 'boolean') {
+          endOffset += literalNode.value ? 4 : 5; // true/false
+        } else if (literalNode.value === null) {
+          endOffset += 4; // null
+        }
+        break;
+      }
+        
+      case NodeType.Identifier:
+      case NodeType.TypeOrIdentifier: {
+        const identifierNode = node as any;
+        endOffset += identifierNode.name.length;
+        break;
+      }
+        
+      case NodeType.Variable: {
+        const variableNode = node as any;
+        endOffset += variableNode.name.length + 1; // +1 for $ or %
+        break;
+      }
+      
+      case NodeType.Binary: {
+        const binaryNode = node as any;
+        if (binaryNode.right && binaryNode.right.range) {
+          return binaryNode.right.range.end;
+        } else if (binaryNode.right) {
+          return this.calculateNodeEnd(binaryNode.right);
+        }
+        break;
+      }
+      
+      case NodeType.Unary: {
+        const unaryNode = node as any;
+        if (unaryNode.operand && unaryNode.operand.range) {
+          return unaryNode.operand.range.end;
+        } else if (unaryNode.operand) {
+          return this.calculateNodeEnd(unaryNode.operand);
+        }
+        break;
+      }
+      
+      case NodeType.Function: {
+        const functionNode = node as any;
+        // Estimate end as after the closing parenthesis
+        // This is approximate - proper implementation would track tokens
+        if (functionNode.arguments && functionNode.arguments.length > 0) {
+          const lastArg = functionNode.arguments[functionNode.arguments.length - 1];
+          if (lastArg.range) {
+            endOffset = lastArg.range.end.offset + 1; // +1 for )
+          } else {
+            endOffset = this.calculateNodeEnd(lastArg).offset + 1;
+          }
+        } else {
+          // Empty function call - estimate
+          endOffset += 2; // ()
+        }
+        break;
+      }
+      
+      case NodeType.Index: {
+        const indexNode = node as any;
+        if (indexNode.index && indexNode.index.range) {
+          return this.offsetToPosition(indexNode.index.range.end.offset + 1); // +1 for ]
+        } else if (indexNode.index) {
+          const indexEnd = this.calculateNodeEnd(indexNode.index);
+          return this.offsetToPosition(indexEnd.offset + 1); // +1 for ]
+        }
+        break;
+      }
+      
+      case NodeType.Collection: {
+        const collectionNode = node as any;
+        if (collectionNode.elements && collectionNode.elements.length > 0) {
+          const lastElement = collectionNode.elements[collectionNode.elements.length - 1];
+          if (lastElement.range) {
+            endOffset = lastElement.range.end.offset + 1; // +1 for }
+          } else {
+            endOffset = this.calculateNodeEnd(lastElement).offset + 1;
+          }
+        } else {
+          endOffset += 2; // {}
+        }
+        break;
+      }
+      
+      case NodeType.Union: {
+        const unionNode = node as any;
+        if (unionNode.operands && unionNode.operands.length > 0) {
+          const lastOperand = unionNode.operands[unionNode.operands.length - 1];
+          if (lastOperand.range) {
+            return lastOperand.range.end;
+          } else {
+            return this.calculateNodeEnd(lastOperand);
+          }
+        }
+        break;
+      }
+      
+      case NodeType.TypeCast:
+      case NodeType.MembershipTest: {
+        const typedNode = node as any;
+        if (typedNode.targetType) {
+          endOffset += typedNode.targetType.length;
+        }
+        break;
+      }
+      
+      case NodeType.TypeReference: {
+        const typeRefNode = node as any;
+        endOffset += typeRefNode.typeName.length;
+        break;
+      }
+      
+      case NodeType.Error:
+      case NodeType.Incomplete: {
+        // Error nodes should have their range set during creation
+        const errorNode = node as any;
+        if (errorNode.actualToken) {
+          endOffset += errorNode.actualToken.value.length;
+        } else {
+          endOffset += 1; // Minimal range
+        }
+        break;
+      }
+        
+      default:
+        // For unknown nodes, minimal range
+        endOffset += 1;
+    }
+    
+    return this.offsetToPosition(endOffset);
+  }
+  
+  getRangeText(range: TextRange): string {
+    return this.source.substring(range.start.offset, range.end.offset);
+  }
+  
+  getLineText(line: number): string {
+    if (line < 0 || line >= this.lineOffsets.length) {
+      return '';
+    }
+    
+    const start = this.lineOffsets[line]!;
+    const end = line < this.lineOffsets.length - 1 
+      ? this.lineOffsets[line + 1]! - 1 
+      : this.source.length;
+    
+    return this.source.substring(start, end).replace(/[\r\n]+$/, '');
+  }
+  
+  mergeRanges(range1: TextRange, range2: TextRange): TextRange {
+    return {
+      start: range1.start.offset <= range2.start.offset ? range1.start : range2.start,
+      end: range1.end.offset >= range2.end.offset ? range1.end : range2.end
+    };
+  }
+}

package/src/parser/special-constructs.ts

@@ -0,0 +1,142 @@
+import type { Token } from '../lexer/token';
+import { TokenType } from '../lexer/token';
+import type { ASTNode, IdentifierNode, FunctionNode, TypeReferenceNode } from './ast';
+import { NodeType } from './ast';
+import { ASTFactory } from './ast-factory';
+import type { TokenNavigator } from './token-navigator';
+import { ErrorCode } from '../api/errors';
+
+/**
+ * Handles parsing of special FHIRPath constructs
+ */
+export class SpecialConstructs {
+  /**
+   * Parse special function syntax like ofType(Type)
+   */
+  static parseOfType(navigator: TokenNavigator, errorCallback: (msg: string) => Error): ASTNode {
+    const ofTypeToken = navigator.previous();
+    
+    // Expect (
+    navigator.consume(TokenType.LPAREN, () => 
+      errorCallback("Expected '(' after 'ofType'")
+    );
+    
+    // Expect type name
+    const typeToken = navigator.consume(TokenType.IDENTIFIER, () => 
+      errorCallback("Expected type name in ofType()")
+    );
+    
+    // Expect )
+    navigator.consume(TokenType.RPAREN, () => 
+      errorCallback("Expected ')' after type name")
+    );
+    
+    return ASTFactory.createFunction(
+      ASTFactory.createIdentifier('ofType', ofTypeToken.position),
+      [ASTFactory.createTypeReference(typeToken.value, typeToken.position)],
+      ofTypeToken.position
+    );
+  }
+
+  /**
+   * Parse type operators (is/as) with their special syntax
+   */
+  static parseTypeOperator(
+    navigator: TokenNavigator, 
+    left: ASTNode,
+    op: Token,
+    errorCallback: (msg: string, code?: ErrorCode) => Error
+  ): ASTNode {
+    // Type name can be either a simple identifier or in parentheses (for is() function syntax)
+    let typeName: string;
+    
+    if (navigator.check(TokenType.LPAREN)) {
+      // Handle is(TypeName) syntax
+      navigator.advance(); // consume (
+      const typeToken = navigator.consume(TokenType.IDENTIFIER, () => 
+        errorCallback("Expected type name", ErrorCode.EXPECTED_IDENTIFIER)
+      );
+      typeName = typeToken.value;
+      navigator.consume(TokenType.RPAREN, () => 
+        errorCallback("Expected ')' after type name", ErrorCode.UNCLOSED_PARENTHESIS)
+      );
+    } else {
+      // Regular is TypeName syntax
+      const typeToken = navigator.consume(TokenType.IDENTIFIER, () => 
+        errorCallback(`Expected type name after '${op.value}'`, ErrorCode.EXPECTED_IDENTIFIER)
+      );
+      typeName = typeToken.value;
+    }
+    
+    if (op.type === TokenType.IS) {
+      return ASTFactory.createMembershipTest(left, typeName, op.position);
+    } else {
+      return ASTFactory.createTypeCast(left, typeName, op.position);
+    }
+  }
+
+  /**
+   * Parse union operator which can chain multiple operands
+   */
+  static parseUnion(left: ASTNode, precedence: number, parseExpression: (p: number) => ASTNode): ASTNode {
+    const right = parseExpression(precedence + 1);
+    
+    // If left is already a union, add to it
+    if (left.type === NodeType.Union) {
+      (left as any).operands.push(right);
+      return left;
+    }
+    
+    // Create new union node
+    return ASTFactory.createUnion([left, right], (left as any).position);
+  }
+
+  /**
+   * Check for common mistakes like == instead of =
+   */
+  static checkDoubleEquals(
+    navigator: TokenNavigator,
+    op: Token,
+    diagnosticsCallback?: (start: Token, end: Token, message: string, code: ErrorCode) => void
+  ): void {
+    if (op.type === TokenType.EQ && navigator.check(TokenType.EQ)) {
+      const secondEq = navigator.peek();
+      if (diagnosticsCallback) {
+        diagnosticsCallback(
+          op,
+          secondEq,
+          "'==' is not valid in FHIRPath, use '=' for equality",
+          ErrorCode.INVALID_OPERATOR
+        );
+        // Skip the extra = to avoid cascading errors
+        navigator.advance();
+      }
+    }
+  }
+
+  /**
+   * Check for double dot error
+   */
+  static checkDoubleDot(
+    navigator: TokenNavigator,
+    firstDot: Token,
+    markPartial: () => void,
+    diagnosticsCallback?: (start: Token, end: Token, message: string, code: ErrorCode) => void
+  ): void {
+    if (navigator.check(TokenType.DOT)) {
+      const secondDot = navigator.peek();
+      if (diagnosticsCallback) {
+        diagnosticsCallback(
+          firstDot,
+          secondDot,
+          "Invalid '..' operator - use a single '.' for navigation",
+          ErrorCode.INVALID_OPERATOR
+        );
+      }
+      
+      // Skip the extra dot to avoid cascading errors
+      navigator.advance();
+      markPartial();
+    }
+  }
+}