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

package/src/parser/diagnostics.ts

@@ -0,0 +1,85 @@
+import type { ParseDiagnostic, DiagnosticSeverity, TextRange } from './types';
+import type { ErrorCode } from '../api/errors';
+
+export class DiagnosticCollector {
+  private diagnostics: ParseDiagnostic[] = [];
+  private errorCount = 0;
+  private warningCount = 0;
+  private maxErrors: number;
+  
+  constructor(maxErrors: number = Number.MAX_SAFE_INTEGER) {
+    this.maxErrors = maxErrors;
+  }
+  
+  addError(range: TextRange, message: string, code: ErrorCode): void {
+    if (this.errorCount >= this.maxErrors) {
+      return;
+    }
+    
+    this.diagnostics.push({
+      range,
+      severity: 1 as DiagnosticSeverity.Error,
+      code,
+      message,
+      source: 'fhirpath-parser'
+    });
+    this.errorCount++;
+  }
+  
+  addWarning(range: TextRange, message: string, code: ErrorCode): void {
+    this.diagnostics.push({
+      range,
+      severity: 2 as DiagnosticSeverity.Warning,
+      code,
+      message,
+      source: 'fhirpath-parser'
+    });
+    this.warningCount++;
+  }
+  
+  addInfo(range: TextRange, message: string, code: ErrorCode): void {
+    this.diagnostics.push({
+      range,
+      severity: 3 as DiagnosticSeverity.Information,
+      code,
+      message,
+      source: 'fhirpath-parser'
+    });
+  }
+  
+  addHint(range: TextRange, message: string, code: ErrorCode): void {
+    this.diagnostics.push({
+      range,
+      severity: 4 as DiagnosticSeverity.Hint,
+      code,
+      message,
+      source: 'fhirpath-parser'
+    });
+  }
+  
+  getDiagnostics(): ParseDiagnostic[] {
+    return [...this.diagnostics];
+  }
+  
+  hasErrors(): boolean {
+    return this.errorCount > 0;
+  }
+  
+  hasWarnings(): boolean {
+    return this.warningCount > 0;
+  }
+  
+  getErrorCount(): number {
+    return this.errorCount;
+  }
+  
+  getWarningCount(): number {
+    return this.warningCount;
+  }
+  
+  clear(): void {
+    this.diagnostics = [];
+    this.errorCount = 0;
+    this.warningCount = 0;
+  }
+}

package/src/parser/error-reporter.ts

@@ -0,0 +1,230 @@
+import { TokenType, type Token } from '../lexer/token';
+import type { SourceMapper } from './source-mapper';
+import type { DiagnosticCollector } from './diagnostics';
+import { ErrorCode } from '../api/errors';
+
+export enum ParseContext {
+  Expression = 'Expression',
+  FunctionCall = 'FunctionCall',
+  IndexExpression = 'IndexExpression',
+  BinaryExpression = 'BinaryExpression',
+  UnaryExpression = 'UnaryExpression',
+  CollectionLiteral = 'CollectionLiteral',
+  TypeCast = 'TypeCast',
+  MembershipTest = 'MembershipTest'
+}
+
+export class ContextualErrorReporter {
+  constructor(
+    private sourceMapper: SourceMapper,
+    private collector: DiagnosticCollector
+  ) {}
+  
+  reportExpectedToken(
+    expected: TokenType[],
+    actual: Token,
+    context: ParseContext
+  ): void {
+    const message = this.buildContextualMessage(expected, actual, context);
+    const range = this.sourceMapper.tokenToRange(actual);
+    
+    this.collector.addError(range, message, ErrorCode.UNEXPECTED_TOKEN);
+  }
+  
+  reportUnclosedDelimiter(openToken: Token, expectedClose: string): void {
+    const range = this.sourceMapper.tokenToRange(openToken);
+    let message: string;
+    let code: ErrorCode;
+    
+    switch (expectedClose) {
+      case ')':
+        code = ErrorCode.UNCLOSED_PARENTHESIS;
+        message = "Unclosed parenthesis - missing ')' to close function call";
+        break;
+      case ']':
+        code = ErrorCode.UNCLOSED_BRACKET;
+        message = "Expected ']' after index expression";
+        break;
+      case '}':
+        code = ErrorCode.UNCLOSED_BRACE;
+        message = "Expected '}' to close collection literal";
+        break;
+      default:
+        code = ErrorCode.SYNTAX_ERROR;
+        message = `Unclosed delimiter - missing '${expectedClose}' to close '${openToken.value}'`;
+    }
+    
+    this.collector.addError(range, message, code);
+  }
+  
+  reportInvalidOperator(operator: Token, message: string): void {
+    const range = this.sourceMapper.tokenToRange(operator);
+    this.collector.addError(range, message, ErrorCode.INVALID_OPERATOR);
+  }
+  
+  reportMissingExpression(token: Token, context: ParseContext): void {
+    const range = this.sourceMapper.tokenToRange(token);
+    const contextDesc = this.getContextDescription(context);
+    const message = `Expected expression ${contextDesc}`;
+    
+    this.collector.addError(range, message, ErrorCode.EXPECTED_EXPRESSION);
+  }
+  
+  reportMissingIdentifier(token: Token, context: string): void {
+    const range = this.sourceMapper.tokenToRange(token);
+    const message = `Expected identifier ${context}`;
+    
+    this.collector.addError(range, message, ErrorCode.EXPECTED_IDENTIFIER);
+  }
+  
+  reportMissingArguments(functionName: string, token: Token): void {
+    const range = this.sourceMapper.tokenToRange(token);
+    const message = `Function '${functionName}' requires arguments`;
+    
+    this.collector.addError(range, message, ErrorCode.MISSING_ARGUMENTS);
+  }
+  
+  private buildContextualMessage(
+    expected: TokenType[],
+    actual: Token,
+    context: ParseContext
+  ): string {
+    const expectedDesc = this.describeTokens(expected);
+    const actualDesc = this.describeToken(actual);
+    
+    switch (context) {
+      case ParseContext.FunctionCall:
+        return `Expected ${expectedDesc} in function call, found ${actualDesc}`;
+      case ParseContext.IndexExpression:
+        return `Expected ${expectedDesc} in index expression, found ${actualDesc}`;
+      case ParseContext.BinaryExpression:
+        return `Expected ${expectedDesc} after operator, found ${actualDesc}`;
+      case ParseContext.CollectionLiteral:
+        return `Expected ${expectedDesc} in collection literal, found ${actualDesc}`;
+      case ParseContext.TypeCast:
+        return `Expected ${expectedDesc} after 'as', found ${actualDesc}`;
+      case ParseContext.MembershipTest:
+        return `Expected ${expectedDesc} after 'is', found ${actualDesc}`;
+      default:
+        return `Expected ${expectedDesc}, found ${actualDesc}`;
+    }
+  }
+  
+  private getContextDescription(context: ParseContext): string {
+    switch (context) {
+      case ParseContext.FunctionCall:
+        return "in function call";
+      case ParseContext.IndexExpression:
+        return "in index expression";
+      case ParseContext.BinaryExpression:
+        return "after operator";
+      case ParseContext.CollectionLiteral:
+        return "in collection literal";
+      case ParseContext.TypeCast:
+        return "after 'as'";
+      case ParseContext.MembershipTest:
+        return "after 'is'";
+      default:
+        return "";
+    }
+  }
+  
+  private describeTokens(tokens: TokenType[]): string {
+    if (tokens.length === 0) return "token";
+    if (tokens.length === 1) return this.getTokenDescription(tokens[0]!);
+    
+    const descriptions = tokens.map(t => this.getTokenDescription(t));
+    const last = descriptions.pop();
+    return descriptions.join(', ') + ' or ' + last;
+  }
+  
+  private describeToken(token: Token): string {
+    if (token.type === TokenType.IDENTIFIER) {
+      return `identifier '${token.value}'`;
+    }
+    if (token.type === TokenType.NUMBER || token.type === TokenType.STRING) {
+      return `${this.getTokenDescription(token.type)} '${token.value}'`;
+    }
+    if (token.type === TokenType.EOF) {
+      return "end of expression";
+    }
+    return `'${token.value}'`;
+  }
+  
+  private getTokenDescription(tokenType: TokenType): string {
+    switch (tokenType) {
+      case TokenType.IDENTIFIER:
+        return "identifier";
+      case TokenType.NUMBER:
+        return "number";
+      case TokenType.STRING:
+        return "string";
+      case TokenType.LPAREN:
+        return "'('";
+      case TokenType.RPAREN:
+        return "')'";
+      case TokenType.LBRACKET:
+        return "'['";
+      case TokenType.RBRACKET:
+        return "']'";
+      case TokenType.LBRACE:
+        return "'{'";
+      case TokenType.RBRACE:
+        return "'}'";
+      case TokenType.COMMA:
+        return "','";
+      case TokenType.DOT:
+        return "'.'";
+      case TokenType.PLUS:
+        return "'+'";
+      case TokenType.MINUS:
+        return "'-'";
+      case TokenType.STAR:
+        return "'*'";
+      case TokenType.SLASH:
+        return "'/'";
+      case TokenType.MOD:
+        return "'mod'";
+      case TokenType.EQ:
+        return "'='";
+      case TokenType.NEQ:
+        return "'!='";
+      case TokenType.LT:
+        return "'<'";
+      case TokenType.GT:
+        return "'>'";
+      case TokenType.LTE:
+        return "'<='";
+      case TokenType.GTE:
+        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.IS:
+        return "'is'";
+      case TokenType.AS:
+        return "'as'";
+      case TokenType.IN:
+        return "'in'";
+      case TokenType.CONTAINS:
+        return "'contains'";
+      case TokenType.TRUE:
+        return "'true'";
+      case TokenType.FALSE:
+        return "'false'";
+      case TokenType.NULL:
+        return "'null'";
+      case TokenType.EOF:
+        return "end of expression";
+      default:
+        return "token";
+    }
+  }
+}

package/src/parser/index.ts

@@ -0,0 +1,3 @@
+export { FHIRPathParser, ParseError } from './parser';
+export * from './ast';
+export { pprint } from './pprint';

package/src/parser/literal-parser.ts

@@ -0,0 +1,103 @@
+import type { Token } from '../lexer/token';
+import { TokenType } from '../lexer/token';
+import type { ASTNode, LiteralNode, VariableNode } from './ast';
+import { ASTFactory } from './ast-factory';
+import type { TokenNavigator } from './token-navigator';
+
+/**
+ * Handles parsing of literals and variables
+ */
+export class LiteralParser {
+  /**
+   * Parse all types of literals
+   */
+  static parseLiteral(navigator: TokenNavigator): ASTNode | null {
+    // Handle registry-based literals
+    if (navigator.match(TokenType.LITERAL)) {
+      const token = navigator.previous();
+      return ASTFactory.createLiteral(
+        token.literalValue ?? token.value,
+        ASTFactory.inferLiteralType(token.literalValue ?? token.value),
+        token.position,
+        token.value,
+        token.operation
+      );
+    }
+    
+    // Handle legacy literals
+    if (navigator.match(TokenType.NUMBER)) {
+      const token = navigator.previous();
+      return ASTFactory.createLiteral(
+        parseFloat(token.value),
+        'number',
+        token.position
+      );
+    }
+    
+    if (navigator.match(TokenType.STRING)) {
+      const token = navigator.previous();
+      return ASTFactory.createLiteral(
+        token.value,
+        'string',
+        token.position
+      );
+    }
+    
+    if (navigator.match(TokenType.TRUE, TokenType.FALSE)) {
+      const token = navigator.previous();
+      return ASTFactory.createLiteral(
+        token.type === TokenType.TRUE,
+        'boolean',
+        token.position
+      );
+    }
+    
+    if (navigator.match(TokenType.NULL)) {
+      const token = navigator.previous();
+      return ASTFactory.createLiteral(
+        null,
+        'null',
+        token.position
+      );
+    }
+    
+    // Date/time literals
+    if (navigator.match(TokenType.DATE, TokenType.TIME, TokenType.DATETIME)) {
+      const token = navigator.previous();
+      return ASTFactory.createLiteral(
+        token.value,
+        token.type === TokenType.DATE ? 'date' : 
+        token.type === TokenType.TIME ? 'time' : 'datetime',
+        token.position
+      );
+    }
+    
+    return null;
+  }
+  
+  /**
+   * Parse special variables
+   */
+  static parseVariable(navigator: TokenNavigator): ASTNode | null {
+    if (navigator.match(TokenType.THIS)) {
+      return ASTFactory.createVariable('$this', true, navigator.previous().position);
+    }
+    
+    if (navigator.match(TokenType.INDEX)) {
+      return ASTFactory.createVariable('$index', true, navigator.previous().position);
+    }
+    
+    if (navigator.match(TokenType.TOTAL)) {
+      return ASTFactory.createVariable('$total', true, navigator.previous().position);
+    }
+    
+    if (navigator.match(TokenType.ENV_VAR)) {
+      const token = navigator.previous();
+      return ASTFactory.createVariable(token.value, false, token.position);
+    }
+    
+    // Variables starting with $ or % are handled by ENV_VAR token type
+    
+    return null;
+  }
+}

package/src/parser/parse-error.ts

@@ -0,0 +1,16 @@
+import type { Token } from '../lexer/token';
+import type { Position } from './ast';
+
+/**
+ * Error thrown during parsing
+ */
+export class ParseError extends Error {
+  constructor(
+    message: string,
+    public position: Position,
+    public token: Token
+  ) {
+    super(message);
+    this.name = 'ParseError';
+  }
+}

package/src/parser/parser-error-factory.ts

@@ -0,0 +1,141 @@
+import type { Token } from '../lexer/token';
+import type { Position } from './ast';
+import { ParseError } from './parser';
+import { ErrorCode } from '../api/errors';
+import type { DiagnosticCollector } from './diagnostics';
+import type { SourceMapper } from './source-mapper';
+
+/**
+ * Factory for creating parser errors with consistent formatting
+ */
+export class ParserErrorFactory {
+  constructor(
+    private throwOnError: boolean,
+    private diagnostics?: DiagnosticCollector,
+    private sourceMapper?: SourceMapper
+  ) {}
+
+  /**
+   * Create a parse error with proper formatting
+   */
+  createError(message: string, token: Token, code: ErrorCode = ErrorCode.PARSE_ERROR): ParseError {
+    if (this.diagnostics && this.sourceMapper && !this.throwOnError) {
+      // In diagnostic mode, add to diagnostics and return error
+      const range = this.sourceMapper.tokenToRange(token);
+      this.diagnostics.addError(range, message, code);
+    }
+    
+    const pos = token.position;
+    const fullMessage = `${message} at line ${pos.line}, column ${pos.column}`;
+    return new ParseError(fullMessage, pos, token);
+  }
+
+  /**
+   * Create error for unexpected token
+   */
+  unexpectedToken(token: Token, expected?: string): ParseError {
+    const message = expected 
+      ? `Expected ${expected}, found '${token.value}'`
+      : `Unexpected token '${token.value}'`;
+    return this.createError(message, token, ErrorCode.UNEXPECTED_TOKEN);
+  }
+
+  /**
+   * Create error for missing token
+   */
+  missingToken(expected: string, token: Token, code: ErrorCode = ErrorCode.UNEXPECTED_TOKEN): ParseError {
+    return this.createError(`Expected ${expected}`, token, code);
+  }
+
+  /**
+   * Create error for unclosed delimiter
+   */
+  unclosedDelimiter(openToken: Token, expected: string): ParseError {
+    const code = expected === ')' ? ErrorCode.UNCLOSED_PARENTHESIS :
+                 expected === ']' ? ErrorCode.UNCLOSED_BRACKET :
+                 expected === '}' ? ErrorCode.UNCLOSED_BRACE :
+                 ErrorCode.SYNTAX_ERROR;
+    
+    return this.createError(
+      `Unclosed ${this.getDelimiterName(expected)} - missing '${expected}'`,
+      openToken,
+      code
+    );
+  }
+
+  /**
+   * Create error for invalid operator
+   */
+  invalidOperator(token: Token): ParseError {
+    return this.createError(`Unknown operator: ${token.value}`, token, ErrorCode.INVALID_OPERATOR);
+  }
+
+  /**
+   * Create error for missing arguments
+   */
+  missingArguments(functionName: string, token: Token): ParseError {
+    return this.createError(
+      `Function '${functionName}' requires arguments`,
+      token,
+      ErrorCode.MISSING_ARGUMENTS
+    );
+  }
+
+  /**
+   * Create error for expected identifier
+   */
+  expectedIdentifier(token: Token, context?: string): ParseError {
+    const message = context 
+      ? `Expected identifier ${context}`
+      : `Expected identifier`;
+    return this.createError(message, token, ErrorCode.EXPECTED_IDENTIFIER);
+  }
+
+  /**
+   * Create error for expected expression
+   */
+  expectedExpression(token: Token, context?: string): ParseError {
+    const message = context 
+      ? `Expected expression ${context}`
+      : `Expected expression`;
+    return this.createError(message, token, ErrorCode.EXPECTED_EXPRESSION);
+  }
+
+  /**
+   * Create error for double dot operator
+   */
+  doubleDotOperator(firstDot: Token, secondDot: Token): ParseError {
+    const message = `Invalid '..' operator - use a single '.' for navigation`;
+    if (this.diagnostics && this.sourceMapper) {
+      const range = this.sourceMapper.mergeRanges(
+        this.sourceMapper.tokenToRange(firstDot),
+        this.sourceMapper.tokenToRange(secondDot)
+      );
+      this.diagnostics.addError(range, message, ErrorCode.INVALID_OPERATOR);
+    }
+    return this.createError(message, firstDot, ErrorCode.INVALID_OPERATOR);
+  }
+
+  /**
+   * Create error for invalid escape sequence
+   */
+  invalidEscape(token: Token, sequence: string): ParseError {
+    return this.createError(
+      `Invalid escape sequence: ${sequence}`,
+      token,
+      ErrorCode.INVALID_ESCAPE
+    );
+  }
+
+  /**
+   * Get human-readable name for delimiter
+   */
+  private getDelimiterName(delimiter: string): string {
+    switch (delimiter) {
+      case ')': return 'parenthesis';
+      case ']': return 'bracket';
+      case '}': return 'brace';
+      default: return 'delimiter';
+    }
+  }
+}