Class ParsingContext

constructor

• new ParsingContext(
      registry: ExpressionRegistry,
      isConstantFunc: (expression: Expression) => boolean,
      path?: number[],
      expectedType?: Type | null,
      scope?: Scope,
      errors?: ExpressionParsingError[],
  ): ParsingContext

  Parameters

  • registry: ExpressionRegistry
  • isConstantFunc: (expression: Expression) => boolean
  • Optionalpath: number[]
  • OptionalexpectedType: Type | null
  • Optionalscope: Scope
  • Optionalerrors: ExpressionParsingError[]

  Returns ParsingContext

errors

expectedType

key

path

registry

scope

checkSubtype

• checkSubtype(expected: Type, t: Type): string

  Returns null if t is a subtype of expected; otherwise returns an error message and also pushes it to this.errors.

  Parameters

  • expected: Type

    The expected type

  • t: Type

    The actual type

  Returns string

  null if t is a subtype of expected; otherwise returns an error message

concat

• concat(
      index: number,
      expectedType?: Type | null,
      bindings?: [string, Expression][],
  ): ParsingContext

  Returns a copy of this context suitable for parsing the subexpression at index index, optionally appending to 'let' binding map.

  Note that errors property, intended for collecting errors while parsing, is copied by reference rather than cloned.

  Parameters

  • index: number
  • OptionalexpectedType: Type | null
  • Optionalbindings: [string, Expression][]

  Returns ParsingContext

  Private

error

• error(error: string, ...keys: number[]): void

  Push a parsing (or type checking) error into the this.errors

  Parameters

  • error: string

    The message

  • ...keys: number[]

    Optionally specify the source of the error at a child of the current expression at this.key.

  Returns void

  Private

parse

• parse(
      expr: unknown,
      index?: number,
      expectedType?: Type | null,
      bindings?: [string, Expression][],
      options?: { typeAnnotation?: "assert" | "coerce" | "omit" },
  ): Expression

  Parameters

  • expr: unknown

    the JSON expression to parse

  • Optionalindex: number

    the optional argument index if this expression is an argument of a parent expression that's being parsed

  • OptionalexpectedType: Type | null
  • Optionalbindings: [string, Expression][]
  • Optionaloptions: { typeAnnotation?: "assert" | "coerce" | "omit" }

  Returns Expression

  Private