@jbrowse/jexl 5.0.1 → 6.0.0

package/src/evaluator/compile.ts

@@ -3,16 +3,12 @@
  * Copyright 2020 Tom Shawver
  */
 
+import { LAMBDA } from '../collections.ts'
+import { unknownNode } from '../errors.ts'
 import { and, nullish, or } from '../grammar.ts'
 
 import type { Grammar } from '../grammar.ts'
-import type {
-  AstNode,
-  AstNodeUnion,
-  JexlFunction,
-  JexlValue,
-  Literal
-} from '../types.ts'
+import type { AstNode, JexlFunction, JexlValue } from '../types.ts'
 
 /** The variables an expression is evaluated against. */
 export type Context = Record<string, JexlValue>
@@ -44,6 +40,16 @@ function assignOwn(target: Context, key: string, value: JexlValue) {
   target[key] = value
 }
 
+// inherited, these lead from any value to `Function` and `Object.prototype`
+const isUnsafeKey = (key: string | number) =>
+  key === 'constructor' || key === '__proto__'
+
+function member(target: Context, key: string | number) {
+  return isUnsafeKey(key) && !Object.hasOwn(target, key)
+    ? undefined
+    : target[key]
+}
+
 /** The key `subject[index]` reads under, or undefined when it reads nothing. */
 function memberKey(index: JexlValue) {
   return typeof index === 'string' || typeof index === 'number'
@@ -90,23 +96,27 @@ function isKeyPart(
  * serves every evaluation.
  */
 function literalTable(node: AstNode) {
-  const literal = node as AstNodeUnion
-  if (literal.type === 'ArrayLiteral') {
-    return literal.value.every((item) => item.type === 'Literal')
-      ? Object.freeze(literal.value.map((item) => (item as Literal).value))
+  if (node.type === 'ArrayLiteral') {
+    return node.value.every((item) => item.type === 'Literal')
+      ? Object.freeze(node.value.map((item) => item.value))
       : undefined
   }
-  if (literal.type === 'ObjectLiteral') {
-    const entries = Object.entries(literal.value)
-    if (entries.every(([, value]) => value.type === 'Literal')) {
-      const table: Context = {}
-      for (const [key, value] of entries) {
-        defineOwn(table, key, (value as Literal).value)
-      }
-      return Object.freeze(table)
+  if (node.type !== 'ObjectLiteral') {
+    return undefined
+  }
+  const table: Context = {}
+  for (const [key, value] of Object.entries(node.value)) {
+    if (value.type !== 'Literal') {
+      return undefined
     }
+    defineOwn(table, key, value.value)
   }
-  return undefined
+  return Object.freeze(table)
+}
+
+function lambda(fn: JexlFunction & { [LAMBDA]?: true }) {
+  fn[LAMBDA] = true
+  return fn
 }
 
 const unassigned = Symbol('unassigned')
@@ -208,8 +218,7 @@ function climb(hops: number, index: number): CompiledNode {
   }
 }
 
-function assignedNames(ast: AstNode | undefined, names = new Set<string>()) {
-  const node = ast as AstNodeUnion | undefined
+function assignedNames(node: AstNode | undefined, names = new Set<string>()) {
   switch (node?.type) {
     case 'AssignmentExpression': {
       names.add(node.left.value)
@@ -335,15 +344,11 @@ function stringify(value: JexlValue) {
 }
 
 function compileNode(
-  ast: AstNode,
+  node: AstNode,
   grammar: Grammar,
   scope: Scope
 ): CompiledNode {
   const compile = (child: AstNode) => compileNode(child, grammar, scope)
-  // AstNode types its `type` as a plain string so the Parser can build the tree
-  // loosely; narrowing to the union once, here, lets every case below see its
-  // own node type instead of repeating the same cast in each branch
-  const node = ast as AstNodeUnion
   switch (node.type) {
     case 'Literal': {
       const { value } = node
@@ -365,6 +370,12 @@ function compileNode(
             : (getMember(target, name) as JexlValue)
         }
       }
+      if (isUnsafeKey(name)) {
+        return (ctx) => {
+          const target = from(ctx)
+          return target == null ? undefined : member(target as Context, name)
+        }
+      }
       return (ctx) => {
         const target = from(ctx)
         return target == null ? undefined : (target as Context)[name]
@@ -374,7 +385,7 @@ function compileNode(
     case 'BinaryExpression': {
       const op = grammar.elements[node.operator]
       const left = compile(node.left)
-      const right = compile(node.right!)
+      const right = compile(node.right)
       if (op?.type === 'binaryOp' && op.evalOnDemand) {
         const { evalOnDemand } = op
         if (evalOnDemand === and) {
@@ -405,7 +416,7 @@ function compileNode(
     }
 
     case 'UnaryExpression': {
-      const right = compile(node.right!)
+      const right = compile(node.right)
       const elem = grammar.elements[node.operator]
       const fn =
         elem?.type === 'unaryOp'
@@ -452,7 +463,7 @@ function compileNode(
         const key = memberKey(index(ctx))
         return subjectVal == null || key === undefined
           ? undefined
-          : (subjectVal as Record<string | number, JexlValue>)[key]
+          : member(subjectVal as Context, key)
       }
     }
 
@@ -568,7 +579,7 @@ function compileNode(
       if (scope.params) {
         throw new Error('Assignment is not supported in a lambda')
       }
-      const right = compile(node.right!)
+      const right = compile(node.right)
       const { slots, frame } = scope.locals!
       const slot = slots.get(node.left.value)!
       return (ctx) => (frame.locals[slot] = right(ctx))
@@ -581,23 +592,25 @@ function compileNode(
       })
       if (!scope.params) {
         const frame = scope.locals?.frame
-        return (ctx): JexlFunction => {
+        return (ctx) => {
           const locals = frame?.locals
-          return (...args) =>
+          return lambda((...args) =>
             body(asContext(new LambdaFrame(args, undefined, ctx, locals)))
+          )
         }
       }
-      return (env): JexlFunction => {
+      return (env) => {
         const outer = asFrame(env)
-        return (...args) =>
+        return lambda((...args) =>
           body(
             asContext(new LambdaFrame(args, outer, outer.context, outer.locals))
           )
+        )
       }
     }
 
     default: {
-      throw new Error(`Corrupt AST: unknown node type '${ast.type}'`)
+      return unknownNode(node)
     }
   }
 }

package/src/grammar.ts

@@ -56,9 +56,9 @@ export interface BinaryOp {
 
 export type UnaryOpEval = (right: JexlValue) => JexlValue
 
+/** A prefix operator, which binds tighter than any binary one. */
 export interface UnaryOp {
   type: 'unaryOp'
-  precedence: number
   eval: UnaryOpEval
 }
 
@@ -82,6 +82,7 @@ export interface SimpleElement {
     | 'question'
     | 'semicolon'
     | 'arrow'
+    | 'assign'
 }
 
 export type GrammarElement = BinaryOp | UnaryOp | SimpleElement
@@ -174,6 +175,7 @@ export const getGrammar = (): Grammar => ({
     '?': { type: 'question' },
     ';': { type: 'semicolon' },
     '=>': { type: 'arrow' },
+    '=': { type: 'assign' },
     '+': {
       type: 'binaryOp',
       precedence: 30,
@@ -299,15 +301,7 @@ export const getGrammar = (): Grammar => ({
     },
     '!': {
       type: 'unaryOp',
-      precedence: Infinity,
       eval: (right) => !right
-    },
-    '=': {
-      type: 'binaryOp',
-      precedence: 2,
-      eval: (_left, _right) => {
-        throw new Error('Assignment handled specially')
-      }
     }
   },
 

package/src/index.ts

@@ -8,7 +8,8 @@ export type { JexlOptions } from './Jexl.ts'
 export type { GetMember, VariableReader } from './grammar.ts'
 export { default as Expression } from './Expression.ts'
 export { analyze } from './analyze.ts'
-export { check, print, recordOf, union } from './check.ts'
+export { check, recordOf, union } from './check.ts'
+export { print } from './print.ts'
 export {
   callSubject,
   conditions,

package/src/operators.ts

@@ -74,20 +74,24 @@ export function pairwise(
   return out
 }
 
-const patterns = new Map<string, RegExp>()
-const MAX_PATTERNS = 1000
-
 /**
  * The regular expression a pattern string stands for. A leading `(?i)`, the
  * inline flag PCRE, Python and Go read, makes it case-insensitive.
  */
+export function toRegExp(pattern: string) {
+  return pattern.startsWith('(?i)')
+    ? new RegExp(pattern.slice(4), 'i')
+    : new RegExp(pattern)
+}
+
+const patterns = new Map<string, RegExp>()
+const MAX_PATTERNS = 1000
+
 function regex(pattern: string) {
   let re = patterns.get(pattern)
   if (!re) {
     try {
-      re = pattern.startsWith('(?i)')
-        ? new RegExp(pattern.slice(4), 'i')
-        : new RegExp(pattern)
+      re = toRegExp(pattern)
     } catch {
       throw new Error(`Invalid regular expression: ${pattern}`)
     }

package/src/parser/Parser.ts

@@ -9,7 +9,6 @@ import type Lexer from '../Lexer.ts'
 import type { Grammar } from '../grammar.ts'
 import type {
   AstNode,
-  AstNodeUnion,
   ConditionalExpression,
   Lambda,
   Literal,
@@ -29,8 +28,6 @@ const omittedAlternateBefore = new Set([
   'semicolon'
 ])
 
-export { JexlSyntaxError } from '../errors.ts'
-
 /**
  * Converts the tokens from the {@link Lexer} into an Abstract Syntax Tree, for
  * {@link compileAst} to lower to closures. A Pratt parser: each level of the
@@ -79,7 +76,7 @@ class Parser {
    * @returns the expression tree, or null for an expression with no tokens
    * @throws {JexlSyntaxError} if the tokens do not form exactly one expression
    */
-  complete(): AstNodeUnion | null {
+  complete(): AstNode | null {
     if (this._tokens.length === 0) {
       return null
     }
@@ -90,7 +87,7 @@ class Parser {
     return ast
   }
 
-  _sequence(): AstNodeUnion {
+  _sequence(): AstNode {
     const first = this._assignment()
     if (this._peek()?.type !== 'semicolon') {
       return first
@@ -106,13 +103,12 @@ class Parser {
     return { type: 'SequenceExpression', expressions }
   }
 
-  _assignment(): AstNodeUnion {
+  _assignment(): AstNode {
     if (this._atLambda()) {
       return this._lambda()
     }
     const left = this._ternary()
-    const token = this._peek()
-    if (token?.type !== 'binaryOp' || token.value !== '=') {
+    if (this._peek()?.type !== 'assign') {
       return left
     }
     if (left.type !== 'Identifier' || left.from) {
@@ -176,7 +172,7 @@ class Parser {
     return { type: 'Lambda', params, body }
   }
 
-  _ternary(): AstNodeUnion {
+  _ternary(): AstNode {
     const test = this._binary(-Infinity)
     if (!this._eat('question')) {
       return test
@@ -198,11 +194,11 @@ class Parser {
    * One exactly at `floor` binds only when it continues a right-associative
    * chain, which is how `a ^ b ^ c` groups from the right.
    */
-  _binary(floor: number, rightAssociative = false): AstNodeUnion {
+  _binary(floor: number, rightAssociative = false): AstNode {
     let left = this._unary()
     for (;;) {
       const token = this._peek()
-      if (token?.type !== 'binaryOp' || token.value === '=') {
+      if (token?.type !== 'binaryOp') {
         return left
       }
       const operator = token.value as string
@@ -224,7 +220,7 @@ class Parser {
   }
 
   /** `a ?? b || c` has no grouping a reader can guess; JS refuses it too. */
-  _mixesNullish(operator: string, ...operands: AstNodeUnion[]) {
+  _mixesNullish(operator: string, ...operands: AstNode[]) {
     return operands.some(
       (operand) =>
         operand.type === 'BinaryExpression' &&
@@ -235,22 +231,20 @@ class Parser {
     )
   }
 
-  _unary(): AstNodeUnion {
+  _unary(): AstNode {
     const token = this._peek()
     if (token?.type !== 'unaryOp') {
       return this._postfix(this._primary())
     }
     this._pos++
-    const operator = token.value as string
-    const op = this._grammar.elements[operator]
     return {
       type: 'UnaryExpression',
-      operator,
-      right: this._binary(op?.type === 'unaryOp' ? op.precedence : Infinity)
+      operator: token.value as string,
+      right: this._unary()
     }
   }
 
-  _postfix(subject: AstNodeUnion): AstNodeUnion {
+  _postfix(subject: AstNode): AstNode {
     let node = subject
     for (;;) {
       switch (this._peek()?.type) {
@@ -294,7 +288,7 @@ class Parser {
     }
   }
 
-  _primary(): AstNodeUnion {
+  _primary(): AstNode {
     const token = this._next()
     switch (token.type) {
       case 'literal': {

package/src/print.ts

@@ -0,0 +1,203 @@
+/*
+ * Jexl
+ * Copyright 2020 Tom Shawver
+ */
+
+import { identRegex } from './Lexer.ts'
+import { getGrammar } from './grammar.ts'
+
+import type { AstNode, BinaryExpression } from './types.ts'
+
+const { elements } = getGrammar()
+
+// print knows where only the built-in operators bind, so a host's own ones
+// print with their operands parenthesized
+function builtIn(operator: string) {
+  const element = elements[operator]
+  return element?.type === 'binaryOp' ? element : undefined
+}
+
+const LOGICAL = new Set(['||', '&&'])
+
+// how tightly each form binds, mirroring the Parser's levels: `;`, then `=`
+// and lambdas, then `?:`, then binary operators, then prefix operators
+const SEQUENCE = 0
+const ASSIGNMENT = 1
+const CONDITIONAL = 2
+const CUSTOM_BINARY = 3
+const UNARY = 100
+
+const WORDS = new Set([
+  'true',
+  'false',
+  'null',
+  ...Object.keys(elements).filter((word) => identRegex.test(word))
+])
+
+export function isName(text: string) {
+  return identRegex.test(text) && !WORDS.has(text)
+}
+
+export function key(name: string) {
+  return isName(name) ? `.${name}` : `[${quote(name)}]`
+}
+
+export function quote(text: string) {
+  return `'${text.replaceAll('\\', '\\\\').replaceAll("'", String.raw`\'`)}'`
+}
+
+function precedenceOf(node: AstNode) {
+  switch (node.type) {
+    case 'SequenceExpression': {
+      return SEQUENCE
+    }
+    case 'AssignmentExpression':
+    case 'Lambda': {
+      return ASSIGNMENT
+    }
+    case 'ConditionalExpression': {
+      // with no alternate, it ends only before `)`, `]`, `}`, `,`, `;` or the end
+      return node.alternate ? CONDITIONAL : SEQUENCE
+    }
+    case 'BinaryExpression': {
+      return builtIn(node.operator)?.precedence ?? CUSTOM_BINARY
+    }
+    case 'UnaryExpression': {
+      return UNARY
+    }
+    default: {
+      return Infinity
+    }
+  }
+}
+
+function within(node: AstNode, least: number) {
+  const text = print(node)
+  return precedenceOf(node) < least ? `(${text})` : text
+}
+
+function binaryOperand(
+  parent: BinaryExpression,
+  child: AstNode,
+  left: boolean
+) {
+  const op = builtIn(parent.operator)
+  if (!op) {
+    return within(child, UNARY)
+  }
+  const own = op.precedence
+  const theirs = precedenceOf(child)
+  const chained =
+    child.type === 'BinaryExpression' &&
+    !!op.rightAssociative &&
+    !!builtIn(child.operator)?.rightAssociative
+  const mixesNullish =
+    child.type === 'BinaryExpression' &&
+    ((parent.operator === '??' && LOGICAL.has(child.operator)) ||
+      (child.operator === '??' && LOGICAL.has(parent.operator)))
+  const text = print(child)
+  return theirs < own || (theirs === own && left === chained) || mixesNullish
+    ? `(${text})`
+    : text
+}
+
+/**
+ * Renders a tree back to expression text, for messages and suggestions. The
+ * text parses back to the same tree.
+ */
+export function print(node: AstNode): string {
+  switch (node.type) {
+    case 'Literal': {
+      const { value } = node
+      if (typeof value === 'string') {
+        return quote(value)
+      }
+      // a number too large for a double reads as Infinity, which is a name
+      return Object.is(value, -0)
+        ? '-0'
+        : value === Infinity
+          ? '1e999'
+          : value === -Infinity
+            ? '-1e999'
+            : String(value)
+    }
+    case 'Identifier': {
+      return node.from
+        ? within(node.from, Infinity) + key(node.value)
+        : node.value
+    }
+    case 'FilterExpression': {
+      return `${within(node.subject, Infinity)}[${within(node.expr, ASSIGNMENT)}]`
+    }
+    case 'BinaryExpression': {
+      return `${binaryOperand(node, node.left, true)} ${node.operator} ${binaryOperand(node, node.right, false)}`
+    }
+    case 'UnaryExpression': {
+      const { operator } = node
+      const right = within(node.right, UNARY)
+      // the Lexer folds a minus before a digit into the number
+      if (operator === '-' && /^\d/.test(right)) {
+        return `-(${right})`
+      }
+      return identRegex.test(operator)
+        ? `${operator} ${right}`
+        : operator + right
+    }
+    case 'ConditionalExpression': {
+      const test = within(node.test, CUSTOM_BINARY)
+      const consequent = node.consequent
+        ? ` ${within(node.consequent, ASSIGNMENT)} `
+        : ''
+      const alternate = node.alternate
+        ? ` ${within(node.alternate, ASSIGNMENT)}`
+        : ''
+      return `${test} ?${consequent}:${alternate}`
+    }
+    case 'FunctionCall': {
+      const args = node.args.map((arg) => within(arg, ASSIGNMENT))
+      return `${node.name}(${args.join(', ')})`
+    }
+    case 'ArrayLiteral': {
+      const items = node.value.map((item) => within(item, ASSIGNMENT))
+      return `[${items.join(', ')}]`
+    }
+    case 'ObjectLiteral': {
+      const entries = Object.entries(node.value).map(
+        ([name, value]) =>
+          `${isName(name) ? name : quote(name)}: ${within(value, ASSIGNMENT)}`
+      )
+      return `{${entries.join(', ')}}`
+    }
+    case 'TemplateLiteral': {
+      const parts = node.parts.map((part) =>
+        part.type === 'static'
+          ? part.value
+              .replaceAll('\\', '\\\\')
+              .replaceAll('`', '\\`')
+              .replaceAll('${', '\\${')
+          : `\${${print(part.value)}}`
+      )
+      return `\`${parts.join('')}\``
+    }
+    case 'SequenceExpression': {
+      const { expressions } = node
+      const text = expressions
+        .map((expr) => within(expr, ASSIGNMENT))
+        .join('; ')
+      return expressions.length === 1 ? `${text};` : text
+    }
+    case 'AssignmentExpression': {
+      return `${node.left.value} = ${within(node.right, ASSIGNMENT)}`
+    }
+    case 'Lambda': {
+      const params =
+        node.params.length === 1
+          ? node.params[0]
+          : `(${node.params.join(', ')})`
+      return `${params} => ${within(node.body, ASSIGNMENT)}`
+    }
+    default: {
+      return '?'
+    }
+  }
+}