simplex-lang 0.2.2 → 1.0.0

package/src/compiler.ts

@@ -2,179 +2,272 @@
 
 // eslint-disable-next-line n/no-missing-import
 import { parse } from '../parser/index.js'
-import { CompileError, ExpressionError, UnexpectedTypeError } from './errors.js'
+import { ExpressionError, UnexpectedTypeError } from './errors.js'
+import {
+  getActiveErrorMapper,
+  getExpressionErrorLocation
+} from './error-mapping.js'
+import type { ErrorMapper } from './error-mapping.js'
 import {
   BinaryExpression,
-  Expression,
-  ExpressionByType,
   ExpressionStatement,
-  Location,
   LogicalExpression,
   UnaryExpression
 } from './simplex-tree.js'
-import assert from 'node:assert'
-import { castToBoolean } from './tools/cast.js'
 import {
+  castToBoolean,
+  castToString,
   ensureFunction,
+  ensureNumber,
+  ensureArray,
+  ensureObject,
   ensureRelationalComparable,
-  ensureNumber
-} from './tools/ensure.js'
-import { isSimpleValue } from './tools/guards.js'
-import { castToString, typeOf } from './tools/index.js'
+  isSimpleValue,
+  objToStringAlias,
+  typeOf
+} from './tools/index.js'
+import { traverse } from './visitors.js'
+import type { SourceLocation, VisitResult } from './visitors.js'
+import { GEN, SCOPE_NAMES, SCOPE_VALUES, SCOPE_PARENT } from './constants.js'
+
+export type { SourceLocation, VisitResult, ErrorMapper }
+export { traverse, getExpressionErrorLocation }
 
-interface ContextHelpers<Data, Globals> {
+// --- Context Helpers ---
+
+export interface ContextHelpers<Data, Globals> {
   castToBoolean(this: void, val: unknown): boolean
+  castToString(this: void, val: unknown): string
   ensureFunction(this: void, val: unknown): Function
+  ensureObject(this: void, val: unknown): object
+  ensureArray(this: void, val: unknown): unknown[]
+  nonNullAssert(this: void, val: unknown): unknown
   getIdentifierValue(
     this: void,
     identifierName: string,
     globals: Globals,
     data: Data
   ): unknown
-  getProperty(this: void, obj: unknown, key: unknown): unknown
+  getProperty(
+    this: void,
+    obj: unknown,
+    key: unknown,
+    extension: boolean
+  ): unknown
   callFunction(this: void, fn: unknown, args: unknown[] | null): unknown
   pipe(
     this: void,
     head: unknown,
-    tail: { opt: boolean; next: (topic: unknown) => unknown }[]
+    tail: { opt: boolean; fwd: boolean; next: (topic: unknown) => unknown }[]
   ): unknown
 }
 
 var hasOwn = Object.hasOwn
-var ERROR_STACK_REGEX = /<anonymous>:(?<row>\d+):(?<col>\d+)/g
-var TOPIC_TOKEN = '%'
 
-const defaultContextHelpers: ContextHelpers<
-  Record<string, unknown>,
-  Record<string, unknown>
-> = {
-  castToBoolean,
+/** Look up an identifier in globals first, then data; throw on miss. */
+function defaultGetIdentifierValue(
+  identifierName: string,
+  globals: Record<string, unknown>,
+  data: Record<string, unknown>
+): unknown {
+  if (identifierName === 'undefined') return undefined
 
-  ensureFunction,
+  if (globals != null && Object.hasOwn(globals, identifierName)) {
+    return globals[identifierName]
+  }
 
-  getIdentifierValue: (identifierName, globals, data) => {
-    // TODO Should test on parse time?
-    if (identifierName === TOPIC_TOKEN) {
-      throw new Error(
-        `Topic reference "${TOPIC_TOKEN}" is unbound; it must be inside a pipe body.`
-      )
-    }
+  if (data != null && Object.hasOwn(data, identifierName)) {
+    return data[identifierName]
+  }
 
-    if (identifierName === 'undefined') return undefined
+  throw new Error(`Unknown identifier - ${identifierName}`)
+}
 
-    if (globals != null && Object.hasOwn(globals, identifierName)) {
-      return globals[identifierName]
+/** Look up an extension method for the given object type and bind obj as first argument. */
+function getExtensionMethod(
+  obj: unknown,
+  key: unknown,
+  extensionMap: Map<string | object | Function, Record<string, Function>>,
+  classesKeys: (object | Function)[],
+  classesValues: Record<string, Function>[]
+): Function {
+  var typeofObj = typeof obj
+  var methods: Record<string, Function> | undefined
+
+  if (typeofObj === 'object') {
+    for (var i = 0; i < classesKeys.length; i++) {
+      // @ts-expect-error supports objects with Symbol.hasInstance
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      if (obj instanceof classesKeys[i]!) {
+        methods = classesValues[i]
+        break
+      }
     }
+  } else {
+    methods = extensionMap.get(typeofObj)
+  }
 
-    if (data != null && Object.hasOwn(data, identifierName)) {
-      return data[identifierName]
-    }
+  if (methods === undefined) {
+    throw new TypeError(
+      `No extension methods defined for type "${typeofObj}"`
+    )
+  }
 
-    throw new Error(`Unknown identifier - ${identifierName}`)
-  },
+  var method = methods[key as string]
+  if (method === undefined) {
+    throw new TypeError(
+      `Extension method "${String(key)}" is not defined for type "${typeofObj}"`
+    )
+  }
 
-  getProperty(obj, key) {
-    if (obj == null) return obj
+  return method.bind(null, obj) as Function
+}
 
-    const typeofObj = typeof obj
+/** Resolve property access on an object, Map, or string (null-safe). */
+function defaultGetProperty(
+  obj: unknown,
+  key: unknown,
+  extension: boolean
+): unknown {
+  if (obj == null) return undefined
+
+  if (extension) {
+    throw new ExpressionError(
+      'Extension member expression (::) is reserved and not implemented',
+      '',
+      null
+    )
+  }
 
-    if (typeofObj === 'string' && typeof key === 'number') {
-      return (obj as string)[key]
-    }
+  var typeofObj = typeof obj
 
-    if (typeofObj !== 'object') {
-      throw new UnexpectedTypeError(['object'], obj)
-    }
+  if (typeofObj === 'string' && typeof key === 'number') {
+    return (obj as string)[key]
+  }
 
-    if (isSimpleValue(key) === false) {
-      throw new UnexpectedTypeError(['simple type object key'], key)
-    }
+  if (typeofObj !== 'object') {
+    throw new UnexpectedTypeError(['object'], obj)
+  }
 
-    if (hasOwn(obj, key as any)) {
-      // @ts-expect-error Type cannot be used as an index type
-      return obj[key] as unknown
-    }
+  if (isSimpleValue(key) === false) {
+    throw new UnexpectedTypeError(['simple type object key'], key)
+  }
 
-    return undefined
-  },
+  if (hasOwn(obj, key as any)) {
+    // @ts-expect-error Type cannot be used as an index type
+    return obj[key] as unknown
+  }
+
+  if (obj instanceof Map) {
+    return obj.get(key) as unknown
+  }
 
-  callFunction(fn, args) {
-    return (
-      args === null
+  return undefined
+}
+
+/** Call a function value; null/undefined silently returns undefined. */
+function defaultCallFunction(fn: unknown, args: unknown[] | null): unknown {
+  return fn == null
+    ? undefined
+    : ((args === null
         ? ensureFunction(fn)()
-        : ensureFunction(fn).apply(null, args)
-    ) as unknown
-  },
-
-  pipe(head, tail) {
-    var result = head
-    for (const it of tail) {
-      if (it.opt && result == null) return result
-      result = it.next(result)
+        : ensureFunction(fn).apply(null, args)) as unknown)
+}
+
+/** Assert that a value is not null or undefined; throw on null/undefined. */
+function defaultNonNullAssert(val: unknown): unknown {
+  if (val == null) {
+    throw new ExpressionError(
+      'Non-null assertion failed: value is ' +
+        (val === null ? 'null' : 'undefined'),
+      '',
+      null
+    )
+  }
+  return val
+}
+
+/** Execute a pipe sequence, threading each result through the next step. */
+function defaultPipe(
+  head: unknown,
+  tail: { opt: boolean; fwd: boolean; next: (topic: unknown) => unknown }[]
+): unknown {
+  var result = head
+  for (const it of tail) {
+    if (it.fwd) {
+      throw new ExpressionError(
+        'Pipe forward operator (|>) is reserved and not implemented',
+        '',
+        null
+      )
     }
-    return result
+    if (it.opt && result == null) return result
+    result = it.next(result)
   }
+  return result
 }
 
-type ExpressionUnaryOperators = Record<
+const defaultContextHelpers: ContextHelpers<
+  Record<string, unknown>,
+  Record<string, unknown>
+> = {
+  castToBoolean,
+  castToString,
+  ensureFunction,
+  ensureObject,
+  ensureArray,
+  nonNullAssert: defaultNonNullAssert,
+  getIdentifierValue: defaultGetIdentifierValue,
+  getProperty: defaultGetProperty,
+  callFunction: defaultCallFunction,
+  pipe: defaultPipe
+}
+
+// --- Operators ---
+
+export type ExpressionUnaryOperators = Record<
   UnaryExpression['operator'],
   (val: unknown) => unknown
 >
 
-export const defaultUnaryOperators: ExpressionUnaryOperators = {
-  '+': val => ensureNumber(val),
-  '-': val => -ensureNumber(val),
-  'not': val => !castToBoolean(val),
-  'typeof': val => typeof val
+/** Create the default unary operator map (+, -, not, typeof). */
+export function createDefaultUnaryOperators(
+  bool: (val: unknown) => boolean
+): ExpressionUnaryOperators {
+  return {
+    '+': val => ensureNumber(val),
+    '-': val => -ensureNumber(val),
+    'not': val => !bool(val),
+    'typeof': val => typeof val
+  }
 }
 
-type ExpressionBinaryOperators = Record<
+export const defaultUnaryOperators: ExpressionUnaryOperators =
+  createDefaultUnaryOperators(castToBoolean)
+
+export type ExpressionBinaryOperators = Record<
   BinaryExpression['operator'],
   (left: unknown, right: unknown) => unknown
 >
 
+const numericOp =
+  (
+    fn: (a: number, b: number) => number
+  ): ((a: unknown, b: unknown) => unknown) =>
+  (a, b) =>
+    fn(ensureNumber(a) as number, ensureNumber(b) as number)
+
 export const defaultBinaryOperators: ExpressionBinaryOperators = {
   '!=': (a, b) => a !== b,
 
   '==': (a, b) => a === b,
 
-  // TIPS give the opportunity to get a base js error
-
-  '*': (a, b) => {
-    // @ts-expect-error
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return ensureNumber(a) * ensureNumber(b)
-  },
-
-  '+': (a, b) => {
-    // @ts-expect-error
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/restrict-plus-operands
-    return ensureNumber(a) + ensureNumber(b)
-  },
-
-  '-': (a, b) => {
-    // @ts-expect-error
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return ensureNumber(a) - ensureNumber(b)
-  },
-
-  '/': (a, b) => {
-    // @ts-expect-error
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return ensureNumber(a) / ensureNumber(b)
-  },
-
-  'mod': (a, b) => {
-    // @ts-expect-error
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return ensureNumber(a) % ensureNumber(b)
-  },
-
-  '^': (a, b) => {
-    // @ts-expect-error
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return ensureNumber(a) ** ensureNumber(b)
-  },
+  '*': numericOp((a, b) => a * b),
+  '+': numericOp((a, b) => a + b),
+  '-': numericOp((a, b) => a - b),
+  '/': numericOp((a, b) => a / b),
+  'mod': numericOp((a, b) => a % b),
+  '^': numericOp((a, b) => a ** b),
 
   '&': (a, b) => castToString(a) + castToString(b),
 
@@ -188,42 +281,61 @@ export const defaultBinaryOperators: ExpressionBinaryOperators = {
   '>=': (a, b) =>
     ensureRelationalComparable(a) >= ensureRelationalComparable(b),
 
+  // Check if key exists in container (Object/Array/Map)
   'in': (a, b) => {
-    if (isSimpleValue(a) && b != null && typeof b === 'object') {
-      return Object.hasOwn(b, a as any)
-    } else {
-      throw new TypeError(
-        `Cannot use "in" operator to search for ${typeOf(a)} key in ${typeOf(b)}`
-      )
+    const bType = objToStringAlias.call(b)
+
+    switch (bType) {
+      case '[object Object]': {
+        return Object.hasOwn(b as object, a as any)
+      }
+
+      case '[object Array]': {
+        if (Number.isSafeInteger(a)) {
+          // @ts-ignore
+          return a in b
+        } else {
+          throw new TypeError(
+            `Wrong "in" operator usage - key value must be a safe integer`
+          )
+        }
+      }
+
+      case '[object Map]':
+        // @ts-ignore
+        return b.has(a) as boolean
+
+      default:
+        throw new TypeError(
+          `Cannot use "in" operator to ensure ${typeOf(a)} key in ${typeOf(b)}`
+        )
     }
   }
 }
 
-type LogicalOperatorFunction = (
+export type LogicalOperatorFunction = (
   left: () => unknown,
   right: () => unknown
 ) => unknown
 
-type ExpressionLogicalOperators = Record<
+export type ExpressionLogicalOperators = Record<
   LogicalExpression['operator'],
   LogicalOperatorFunction
 >
 
-const logicalAndOperatorFn: LogicalOperatorFunction = (a, b) =>
-  castToBoolean(a()) && castToBoolean(b())
-
-const logicalOrOperatorFn: LogicalOperatorFunction = (a, b) =>
-  castToBoolean(a()) || castToBoolean(b())
-
-export const defaultLogicalOperators: ExpressionLogicalOperators = {
-  // TODO Use castToBoolean from compile options?
-  'and': logicalAndOperatorFn,
-  '&&': logicalAndOperatorFn,
-  'or': logicalOrOperatorFn,
-  '||': logicalOrOperatorFn
+/** Create the default logical operator map (and/&&, or/||). */
+export function createDefaultLogicalOperators(
+  bool: (val: unknown) => boolean
+): ExpressionLogicalOperators {
+  const and: LogicalOperatorFunction = (a, b) => bool(a()) && bool(b())
+  const or: LogicalOperatorFunction = (a, b) => bool(a()) || bool(b())
+  return { 'and': and, '&&': and, 'or': or, '||': or }
 }
 
-interface ExpressionOperators {
+export const defaultLogicalOperators: ExpressionLogicalOperators =
+  createDefaultLogicalOperators(castToBoolean)
+
+export interface ExpressionOperators {
   unaryOperators: Record<UnaryExpression['operator'], (val: unknown) => unknown>
   binaryOperators: Record<
     BinaryExpression['operator'],
@@ -235,408 +347,55 @@ interface ExpressionOperators {
   >
 }
 
-export interface SourceLocation {
-  len: number
-  location: Location
-}
-
-export interface VisitResult {
-  code: string
-  offsets: SourceLocation[]
-}
-
-type Visit = (node: Expression) => VisitResult[]
-
-const codePart = (
-  codePart: string,
-  ownerNode: { location: Location }
-): VisitResult => ({
-  code: codePart,
-  offsets: [{ len: codePart.length, location: ownerNode.location }]
-})
-
-const combineVisitResults = (parts: VisitResult[]) => {
-  return parts.reduce((res, it) => {
-    return {
-      code: res.code + it.code,
-      offsets: res.offsets.concat(it.offsets)
-    } as VisitResult
-  })
-}
+// --- Bootstrap Code ---
 
-const visitors: {
-  [P in keyof ExpressionByType]: (
-    node: ExpressionByType[P],
-    visit: Visit
-  ) => VisitResult[]
-} = {
-  Literal: node => {
-    const parts: VisitResult[] = [codePart(JSON.stringify(node.value), node)]
-
-    return parts
-  },
-
-  Identifier: node => {
-    const parts: VisitResult[] = [
-      codePart(`get(scope,${JSON.stringify(node.name)})`, node)
-    ]
-
-    return parts
-  },
-
-  UnaryExpression: (node, visit) => {
-    const parts: VisitResult[] = [
-      codePart(`uop["${node.operator}"](`, node),
-      ...visit(node.argument),
-      codePart(')', node)
-    ]
-
-    return parts
-  },
-
-  BinaryExpression: (node, visit) => {
-    const parts: VisitResult[] = [
-      codePart(`bop["${node.operator}"](`, node),
-      ...visit(node.left),
-      codePart(',', node),
-      ...visit(node.right),
-      codePart(')', node)
-    ]
-
-    return parts
-  },
-
-  LogicalExpression: (node, visit) => {
-    const parts: VisitResult[] = [
-      codePart(`lop["${node.operator}"](()=>(`, node),
-      ...visit(node.left),
-      codePart('),()=>(', node),
-      ...visit(node.right),
-      codePart('))', node)
-    ]
-
-    return parts
-  },
-
-  ConditionalExpression: (node, visit) => {
-    const parts: VisitResult[] = [
-      codePart('(bool(', node),
-      ...visit(node.test),
-      codePart(')?', node),
-      ...visit(node.consequent),
-      codePart(':', node),
-      ...(node.alternate !== null
-        ? visit(node.alternate)
-        : [codePart('undefined', node)]),
-      codePart(')', node)
-    ]
-
-    return parts
-  },
-
-  ObjectExpression: (node, visit) => {
-    const innerObj = node.properties
-      .map((p): [VisitResult, VisitResult[]] => {
-        if (p.key.type === 'Identifier') {
-          return [codePart(p.key.name, p), visit(p.value)]
-        }
-        //
-        else if (p.key.type === 'Literal') {
-          // TODO look for ECMA spec
-          return [codePart(JSON.stringify(p.key.value), p), visit(p.value)]
-        }
-        //
-        else {
-          // TODO Restrict on parse step
-          // TODO Error with locations
-          throw new TypeError(`Incorrect object key type ${p.key.type}`)
-        }
-      })
-      .flatMap(([k, v]) => {
-        return [k, codePart(':', node), ...v, codePart(',', node)]
-      })
-
-    // remove last comma
-    if (innerObj.length > 1) {
-      innerObj.pop()
-    }
-
-    const parts: VisitResult[] = [
-      codePart('{', node),
-      ...innerObj,
-      codePart('}', node)
-    ]
-
-    return parts
-  },
-
-  ArrayExpression: (node, visit) => {
-    const innerArrParts = node.elements.flatMap(el => {
-      return el === null
-        ? [codePart(',', node)]
-        : [...visit(el), codePart(',', node)]
-    })
-
-    // remove last comma
-    if (innerArrParts.length > 1) {
-      innerArrParts.pop()
-    }
-
-    const parts: VisitResult[] = [
-      codePart('[', node),
-      ...innerArrParts,
-      codePart(']', node)
-    ]
-
-    return parts
-  },
-
-  MemberExpression: (node, visit) => {
-    const { computed, object, property } = node
-
-    // TODO Pass computed to prop?
-
-    const parts: VisitResult[] = [
-      codePart('prop(', node),
-      ...visit(object),
-      codePart(',', node),
-      ...(computed
-        ? visit(property)
-        : [codePart(JSON.stringify(property.name), property)]),
-      codePart(')', node)
-    ]
-
-    return parts
-  },
-
-  CallExpression: (node, visit) => {
-    if (node.arguments.length > 0) {
-      const innerArgs = node.arguments.flatMap((arg, index) => [
-        ...(arg.type === 'CurryPlaceholder'
-          ? [codePart(`a${index}`, arg)]
-          : visit(arg)),
-        codePart(',', node)
-      ])
-
-      const curriedArgs = node.arguments.flatMap((arg, index) =>
-        arg.type === 'CurryPlaceholder' ? [`a${index}`] : []
-      )
-
-      // remove last comma
-      innerArgs?.pop()
-
-      // call({{callee}},[{{arguments}}])
-      let parts: VisitResult[] = [
-        codePart('call(', node),
-        ...visit(node.callee),
-        codePart(',[', node),
-        ...innerArgs,
-        codePart('])', node)
-      ]
-
-      if (curriedArgs.length > 0) {
-        parts = [
-          codePart(`(scope=>(${curriedArgs.join()})=>`, node),
-          ...parts,
-          codePart(')(scope)', node)
-        ]
-      }
-
-      return parts
-    }
-
-    //
-    else {
-      const parts: VisitResult[] = [
-        codePart('call(', node),
-        ...visit(node.callee),
-        codePart(',null)', node)
-      ]
-
-      return parts
-    }
-  },
-
-  NullishCoalescingExpression: (node, visit) => {
-    const parts: VisitResult[] = [
-      codePart('(', node),
-      ...visit(node.left),
-      codePart('??', node),
-      ...visit(node.right),
-      codePart(')', node)
-    ]
-
-    return parts
-  },
-
-  PipeSequence: (node, visit) => {
-    const headCode = visit(node.head)
-
-    const tailsCodeArrInner = node.tail.flatMap(t => {
-      const opt = t.operator === '|?'
-
-      const tailParts: VisitResult[] = [
-        codePart(
-          `{opt:${opt},next:(scope=>topic=>{scope=[["%"],[topic],scope];return `,
-          t.expression
-        ),
-        ...visit(t.expression),
-        codePart(`})(scope)}`, t.expression),
-        codePart(`,`, t.expression)
-      ]
-
-      return tailParts
-    })
-
-    // remove last comma
-    tailsCodeArrInner.pop()
-
-    const parts: VisitResult[] = [
-      codePart('pipe(', node),
-      ...headCode,
-      codePart(',[', node),
-      ...tailsCodeArrInner,
-      codePart('])', node)
-    ]
-
-    return parts
-  },
-
-  TopicReference: node => {
-    const parts: VisitResult[] = [codePart(`get(scope,"${TOPIC_TOKEN}")`, node)]
-    return parts
-  },
-
-  LambdaExpression: (node, visit) => {
-    // Lambda with parameters
-    if (node.params.length > 0) {
-      const paramsNames = node.params.map(p => p.name)
-
-      const fnParams = Array.from(
-        { length: paramsNames.length },
-        (_, index) => `p${index}`
-      )
-
-      const fnParamsList = fnParams.join()
-      const fnParamsNamesList = paramsNames.map(p => JSON.stringify(p)).join()
-
-      // TODO Is "...args" more performant?
-      // (params => function (p0, p1) {
-      //   var scope = [params, [p0, p1], scope]
-      //   return {{code}}
-      // })(["a", "b"])
-      const parts: VisitResult[] = [
-        codePart(
-          `((scope,params)=>function(${fnParamsList}){scope=[params,[${fnParamsList}],scope];return `,
-          node
-        ),
-        ...visit(node.expression),
-        codePart(`})(scope,[${fnParamsNamesList}])`, node)
-      ]
-
-      return parts
-    }
-
-    // Lambda without parameters
-    else {
-      // (() => {{code}})
-      const parts: VisitResult[] = [
-        codePart(`(()=>`, node),
-        ...visit(node.expression),
-        codePart(`)`, node)
-      ]
-
-      return parts
-    }
-  },
-
-  LetExpression: (node, visit) => {
-    const declarationsNamesSet = new Set()
-
-    for (const d of node.declarations) {
-      if (declarationsNamesSet.has(d.id.name)) {
-        throw new CompileError(
-          `"${d.id.name}" name defined inside let expression was repeated`,
-          '',
-          d.id.location
-        )
-      }
-      declarationsNamesSet.add(d.id.name)
-    }
-
-    // (scope=> {
-    //   var _varNames = [];
-    //   var _varValues = [];
-    //   scope = [_varNames, _varValues, scope];
-
-    //   // a = {{init}}
-    //   _varNames.push("a");
-    //   _varValues.push({{init}});
-
-    //   // {{expression}}
-    //   return {{expression}}
-    // })(scope)
-
-    const parts: VisitResult[] = [
-      codePart(
-        `(scope=>{var _varNames=[];var _varValues=[];scope=[_varNames,_varValues,scope];`,
-        node
-      ),
-      ...node.declarations.flatMap(d => [
-        codePart(`_varValues.push(`, d),
-        ...visit(d.init),
-        codePart(`);`, d),
-        codePart(`_varNames.push(`, d),
-        codePart(JSON.stringify(d.id.name), d.id),
-        codePart(`);`, d)
-      ]),
-      codePart(`return `, node),
-      ...visit(node.expression),
-      codePart(`})(scope)`, node)
-    ]
-
-    return parts
-  }
-}
-
-const visit: (
-  node: Expression,
-  parentNode: Expression | null
-) => VisitResult[] = node => {
-  const nodeTypeVisitor = visitors[node.type]
-
-  if (nodeTypeVisitor === undefined) {
-    throw new Error(`No handler for node type - ${node.type}`)
-  }
-
-  const innerVisit: Visit = (childNode: Expression) => {
-    return visit(childNode, node)
-  }
+const bootstrapCodeHead =
+  `
+    var ${GEN.bool}=ctx.castToBoolean;
+    var ${GEN.str}=ctx.castToString;
+    var ${GEN.bop}=ctx.binaryOperators;
+    var ${GEN.lop}=ctx.logicalOperators;
+    var ${GEN.uop}=ctx.unaryOperators;
+    var ${GEN.call}=ctx.callFunction;
+    var ${GEN.ensObj}=ctx.ensureObject;
+    var ${GEN.ensArr}=ctx.ensureArray;
+    var ${GEN.getIdentifierValue}=ctx.getIdentifierValue;
+    var ${GEN.prop}=ctx.getProperty;
+    var ${GEN.pipe}=ctx.pipe;
+    var ${GEN.nna}=ctx.nonNullAssert;
+    var ${GEN.globals}=ctx.globals??null;
+
+    function ${GEN._get}(${GEN._scope},name){
+      if(${GEN._scope}===null)return ${GEN.getIdentifierValue}(name,${GEN.globals},this);
+      var paramIndex=${GEN._scope}[${SCOPE_NAMES}].findIndex(it=>it===name);
+      if(paramIndex===-1)return ${GEN._get}.call(this,${GEN._scope}[${SCOPE_PARENT}],name);
+      return ${GEN._scope}[${SCOPE_VALUES}][paramIndex]
+    };
 
-  // @ts-expect-error skip node is never
-  return nodeTypeVisitor(node, innerVisit)
-}
+    return data=>{
+      var ${GEN.scope}=null;
+      var ${GEN.get}=${GEN._get}.bind(data);
+      return
+  `
+    .split('\n')
+    .map(it => it.trim())
+    .filter(it => it !== '')
+    .join('') + ' '
 
-export function traverse(tree: ExpressionStatement): VisitResult {
-  return combineVisitResults(visit(tree.expression, null))
-}
+const bootstrapCodeHeadLen = bootstrapCodeHead.length
 
-function getExpressionErrorLocation(
-  colOffset: number,
-  locations: SourceLocation[]
-): Location | null {
-  var curCol = 0
-  for (const loc of locations) {
-    curCol += loc.len
-    if (curCol >= colOffset) return loc.location
-  }
-  return null
-}
+// --- Compile ---
 
 export type CompileOptions<Data, Globals> = Partial<
-  ContextHelpers<Data, Globals> & ExpressionOperators & { globals: Globals }
+  ContextHelpers<Data, Globals> &
+    ExpressionOperators & {
+      globals: Globals
+      extensions: Map<string | object | Function, Record<string, Function>>
+      errorMapper: ErrorMapper | null
+    }
 >
 
+/** Compile a SimplEx expression string into an executable function. */
 export function compile<
   Data = Record<string, unknown>,
   Globals = Record<string, unknown>
@@ -645,111 +404,75 @@ export function compile<
   options?: CompileOptions<Data, Globals>
 ): (data?: Data) => unknown {
   const tree = parse(expression) as ExpressionStatement
-  let traverseResult
-
-  try {
-    traverseResult = traverse(tree)
-  } catch (err) {
-    // TODO Use class to access expression from visitors?
-    if (err instanceof CompileError) {
-      err.expression = expression
-    }
-    throw err
-  }
+  const traverseResult = traverse(tree, expression)
 
   const { code: expressionCode, offsets } = traverseResult
 
-  const bootstrapCodeHead =
-    `
-    var bool=ctx.castToBoolean;
-    var bop=ctx.binaryOperators;
-    var lop=ctx.logicalOperators;
-    var uop=ctx.unaryOperators;
-    var call=ctx.callFunction;
-    var getIdentifierValue=ctx.getIdentifierValue;
-    var prop=ctx.getProperty;
-    var pipe=ctx.pipe;
-    var globals=ctx.globals??null;
-
-    function _get(_scope,name){
-      if(_scope===null)return getIdentifierValue(name,globals,this);
-      var paramIndex=_scope[0].findIndex(it=>it===name);
-      if(paramIndex===-1)return _get.call(this,_scope[2],name);
-      return _scope[1][paramIndex]
-    };
-
-    return data=>{
-      var scope=null;
-      var get=_get.bind(data);
-      return
-  `
-      .split('\n')
-      .map(it => it.trim())
-      .filter(it => it !== '')
-      .join('') + ' '
-
-  const bootstrapCodeHeadLen = bootstrapCodeHead.length
-
   const functionCode = bootstrapCodeHead + expressionCode + '}'
 
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const resolvedBool = options?.castToBoolean ?? castToBoolean
+
   const defaultOptions: CompileOptions<Data, Globals> = {
     ...defaultContextHelpers,
+    // Recreate operators with custom castToBoolean so compile options
+    // are honored by logical (and/or) and unary (not) operators
     ...{
-      unaryOperators: defaultUnaryOperators,
+      unaryOperators: options?.castToBoolean
+        ? createDefaultUnaryOperators(resolvedBool)
+        : defaultUnaryOperators,
       binaryOperators: defaultBinaryOperators,
-      logicalOperators: defaultLogicalOperators
+      logicalOperators: options?.castToBoolean
+        ? createDefaultLogicalOperators(resolvedBool)
+        : defaultLogicalOperators
     },
     ...(options as any)
   }
 
+  if (options?.extensions && options.extensions.size > 0 && !options.getProperty) {
+    const extensionMap = options.extensions
+    const classesKeys: (object | Function)[] = []
+    const classesValues: Record<string, Function>[] = []
+
+    for (const [key, methods] of extensionMap) {
+      if (typeof key !== 'string') {
+        classesKeys.push(key)
+        classesValues.push(methods)
+      }
+    }
+
+    defaultOptions.getProperty = (obj, key, extension) => {
+      if (obj == null) return undefined
+      if (extension)
+        return getExtensionMethod(
+          obj,
+          key,
+          extensionMap,
+          classesKeys,
+          classesValues
+        )
+      return defaultGetProperty(obj, key, false)
+    }
+  }
+
   const func = new Function('ctx', functionCode)(defaultOptions) as (
     data?: Data
   ) => unknown
 
+  const errorMapper =
+    options?.errorMapper !== undefined
+      ? options.errorMapper
+      : getActiveErrorMapper()
+
+  if (errorMapper === null) return func
+
   return function (data?: Data) {
     try {
       return func(data)
     } catch (err) {
-      if (err instanceof Error === false) throw err
-
-      const stackRows = err.stack?.split('\n').map(row => row.trim())
-
-      const evalRow = stackRows?.find(row => row.startsWith('at eval '))
-
-      if (evalRow === undefined) {
-        throw err
-      }
-
-      ERROR_STACK_REGEX.lastIndex = 0
-      const match = ERROR_STACK_REGEX.exec(evalRow)
-
-      if (match == null) {
-        throw err
-      }
-
-      const rowOffsetStr = match.groups?.['row']
-      const colOffsetStr = match.groups?.['col']
-
-      if (rowOffsetStr === undefined || colOffsetStr === undefined) {
-        throw err
-      }
-
-      const rowOffset = Number.parseInt(rowOffsetStr)
-      assert.equal(rowOffset, 3)
-
-      const colOffset = Number.parseInt(colOffsetStr)
-      const adjustedColOffset = colOffset - bootstrapCodeHeadLen
-      assert.ok(adjustedColOffset >= 0)
-
-      const errorLocation = getExpressionErrorLocation(
-        adjustedColOffset,
-        offsets
+      throw (
+        errorMapper.mapError(err, expression, offsets, bootstrapCodeHeadLen) ??
+        err
       )
-
-      throw new ExpressionError(err.message, expression, errorLocation, {
-        cause: err
-      })
     }
   }
 }