Provide more quick fixes

Author: Sander Toonen

README.md

@@ -81,6 +81,9 @@ const expr = parser.parse('2 * x + 1');
 expr.evaluate({ x: 3 });  // 7
 expr.evaluate({ x: 10 }); // 21
 
+// Or pass a resolver directly as the first argument
+expr.evaluate((name) => name === 'x' ? { value: 3 } : undefined); // 7
+
 // Rich expression language
 parser.evaluate('user.name ?? "Anonymous"', { user: {} }); // "Anonymous"
 parser.evaluate('CASE WHEN score >= 90 THEN "A" WHEN score >= 80 THEN "B" ELSE "C" END', { score: 85 }); // "B"

docs/expression.md

@@ -5,6 +5,7 @@
 `parser.parse(str)` returns an `Expression` object. `Expression`s are similar to JavaScript functions, i.e. they can be "called" with variables bound to passed-in values.
 
 ## evaluate(variables?: object, resolver?: VariableResolver)
+## evaluate(resolver: VariableResolver)
 
 Evaluate the expression, with variables bound to the values in `{variables}`. Each variable in the expression is bound to the corresponding member of the `variables` object. If there are unbound variables, `evaluate` will throw an exception.
 
@@ -18,13 +19,20 @@ console.log(expr.evaluate({ x: 3 })); // 8
 
 The optional `resolver` argument is a per-call variable resolver. It has the same shape as `parser.resolve` — `(name) => { alias } | { value } | undefined` — but applies only to the current `evaluate()` call, so a single parsed `Expression` can be evaluated multiple times against different data sources without mutating parser state. The per-call `resolver` is consulted before `parser.resolve`; the `variables` object still takes precedence over both.
 
+When no `variables` are needed, the resolver can be passed directly as the first argument — `evaluate` detects whether the first argument is an object or a function and dispatches accordingly.
+
 ```js
 const parser = new Parser();
 const expr = parser.parse('$user.name');
 
 const resolveAlice = (name) => name === '$user' ? { value: { name: 'Alice' } } : undefined;
 const resolveBob   = (name) => name === '$user' ? { value: { name: 'Bob'   } } : undefined;
 
+// Resolver as first argument
+expr.evaluate(resolveAlice); // 'Alice'
+expr.evaluate(resolveBob);   // 'Bob'
+
+// Equivalent, with an explicit empty values object
 expr.evaluate({}, resolveAlice); // 'Alice'
 expr.evaluate({}, resolveBob);   // 'Bob'
 ```

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pro-fa/expreszo",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Mathematical expression evaluator",
   "keywords": [
     "expression",

package.json

@@ -125,6 +125,10 @@ export class Expression {
   /**
    * Evaluates the expression with the given variable values.
    *
+   * Accepts either a `values` object, a `resolver` function, or both. When a
+   * function is passed as the first argument it is treated as the resolver and
+   * no `values` object is used.
+   *
    * @param values - Object containing variable values
    * @param resolver - Optional per-call variable resolver. Tried before the parser-level
    *   resolver (if any) when a variable is not present in `values`. Lets a single parsed
@@ -138,29 +142,47 @@ export class Expression {
    * const expr = parser.parse('2 + 3 * x');
    * const result = expr.evaluate({ x: 4 }); // Returns 14
    *
-   * // Per-call resolver
+   * // Per-call resolver only
    * const expr2 = parser.parse('$a + $b');
-   * const result2 = expr2.evaluate({}, (t) =>
+   * const result2 = expr2.evaluate((t) =>
+   *   t.startsWith('$') ? { value: lookup(t.substring(1)) } : undefined
+   * );
+   *
+   * // Values and resolver
+   * const result3 = expr2.evaluate({}, (t) =>
    *   t.startsWith('$') ? { value: lookup(t.substring(1)) } : undefined
    * );
    * ```
    */
-  evaluate(values?: ReadonlyValues, resolver?: VariableResolver): Value | Promise<Value> {
+  evaluate(resolver: VariableResolver): Value | Promise<Value>;
+  evaluate(values?: ReadonlyValues, resolver?: VariableResolver): Value | Promise<Value>;
+  evaluate(
+    valuesOrResolver?: ReadonlyValues | VariableResolver,
+    resolver?: VariableResolver
+  ): Value | Promise<Value> {
+    let values: ReadonlyValues | undefined;
+    let effectiveResolver: VariableResolver | undefined;
+    if (typeof valuesOrResolver === 'function') {
+      effectiveResolver = valuesOrResolver;
+    } else {
+      values = valuesOrResolver;
+      effectiveResolver = resolver;
+    }
     const safeValues = (values || {}) as Record<string, Value>;
 
     if (this.isAsync === undefined) {
       this.isAsync = containsAsyncCall(this.#root, { functions: this.functions });
     }
     if (this.isAsync) {
-      return evaluateAstAsync(this.#root, this, safeValues, resolver);
+      return evaluateAstAsync(this.#root, this, safeValues, effectiveResolver);
     }
 
     try {
-      return evaluateAstSync(this.#root, this, safeValues, resolver);
+      return evaluateAstSync(this.#root, this, safeValues, effectiveResolver);
     } catch (err) {
       if (err instanceof AsyncRequiredError) {
         this.isAsync = true;
-        return evaluateAstAsync(this.#root, this, safeValues, resolver);
+        return evaluateAstAsync(this.#root, this, safeValues, effectiveResolver);
       }
       throw err;
     }

src/core/expression.ts

@@ -76,59 +76,59 @@ export function fold(arg1: Function | any[] | undefined, arg2: any, arg3: Functi
   }, init);
 }
 
-export function indexOf(haystack: string | any[] | undefined, target: any): number | undefined {
-  if (haystack === undefined) {
+export function indexOf(arg1: any, arg2: any): number | undefined {
+  // Support both indexOf(arrayOrString, target) and indexOf(target, arrayOrString) for backwards compatibility
+  const arg1IsCollection = Array.isArray(arg1) || typeof arg1 === 'string';
+  const arg2IsCollection = Array.isArray(arg2) || typeof arg2 === 'string';
+
+  let haystack: string | any[];
+  let target: any;
+
+  if (arg1IsCollection) {
+    // collection-first (preferred): indexOf(haystack, target)
+    haystack = arg1;
+    target = arg2;
+  } else if (arg2IsCollection && arg1 !== undefined) {
+    // target-first (legacy): indexOf(target, haystack)
+    target = arg1;
+    haystack = arg2;
+  } else if (arg1 === undefined) {
     return undefined;
-  }
-  if (!(Array.isArray(haystack) || typeof haystack === 'string')) {
+  } else {
     throw new Error(
-      `indexOf(arrayOrString, target) expects a string or array as first argument, got ${getTypeName(haystack)}.\n` +
+      `indexOf(arrayOrString, target) expects a string or array as first argument, got ${getTypeName(arg1)}.\n` +
       'Example: indexOf(["a", "b", "c"], "b") or indexOf("hello", "o")'
     );
   }
 
   return haystack.indexOf(target);
 }
 
-export function indexOfLegacy(target: any, s: string | any[] | undefined): number | undefined {
-  if (s === undefined) {
-    return undefined;
-  }
-  if (!(Array.isArray(s) || typeof s === 'string')) {
-    throw new Error(
-      `indexOf(target, arrayOrString) expects a string or array as second argument, got ${getTypeName(s)}.\n` +
-      'Example: indexOf("b", ["a", "b", "c"]) or indexOf("o", "hello")'
-    );
-  }
-
-  return s.indexOf(target);
-}
+export function join(arg1: any, arg2: any): string | undefined {
+  // Support both join(array, separator) and join(separator, array) for backwards compatibility
+  let a: any[] | undefined;
+  let sep: string | undefined;
 
-export function join(a: any[] | undefined, sep: string | undefined): string | undefined {
-  if (a === undefined || sep === undefined) {
+  if (Array.isArray(arg1) && (typeof arg2 === 'string' || arg2 === undefined)) {
+    // array-first (preferred): join(array, separator)
+    a = arg1;
+    sep = arg2;
+  } else if (Array.isArray(arg2) && (typeof arg1 === 'string' || arg1 === undefined)) {
+    // separator-first (legacy): join(separator, array)
+    sep = arg1;
+    a = arg2;
+  } else if (arg1 === undefined || arg2 === undefined) {
     return undefined;
-  }
-  if (!Array.isArray(a)) {
+  } else {
     throw new Error(
-      `join(array, separator) expects an array as first argument, got ${getTypeName(a)}.\n` +
+      `join(array, separator) expects an array as first argument, got ${getTypeName(arg1)}.\n` +
       'Example: join(["a", "b", "c"], ", ")'
     );
   }
 
-  return a.join(sep);
-}
-
-export function joinLegacy(sep: string | undefined, a: any[] | undefined): string | undefined {
-  if (sep === undefined || a === undefined) {
+  if (a === undefined || sep === undefined) {
     return undefined;
   }
-  if (!Array.isArray(a)) {
-    throw new Error(
-      `join(separator, array) expects an array as second argument, got ${getTypeName(a)}.\n` +
-      'Example: join(", ", ["a", "b", "c"])'
-    );
-  }
-
   return a.join(sep);
 }
 

src/functions/array/operations.ts

@@ -1,11 +1,13 @@
 import type { TextDocument } from 'vscode-languageserver-textdocument';
-import type { CodeAction, Diagnostic } from 'vscode-languageserver-types';
+import type { CodeAction, Diagnostic, TextEdit } from 'vscode-languageserver-types';
 import { CodeActionKind } from 'vscode-languageserver-types';
 import type { Parser } from '../parsing/parser';
 import { closestMatch } from './shared/levenshtein.js';
 import { buildKnownNames } from './shared/known-names.js';
 import { FunctionDetails } from './language-service.models.js';
 import type { GetCodeActionsParams } from './language-service.types.js';
+import type { LegacyArgOrderFixData } from './legacy-arg-order.js';
+import { spanToRange } from './shared/positions.js';
 
 /**
  * Count the number of top-level comma-separated arguments in the raw text
@@ -126,6 +128,57 @@ function didYouMeanQuickFix(
   };
 }
 
+function isLegacyArgOrderFixData(data: unknown): data is LegacyArgOrderFixData {
+  if (typeof data !== 'object' || data === null) return false;
+  const d = data as Record<string, unknown>;
+  return (
+    d.kind === 'legacy-arg-order' &&
+    typeof d.functionName === 'string' &&
+    Array.isArray(d.argSpans) &&
+    Array.isArray(d.swapPairs)
+  );
+}
+
+function reorderArgsQuickFix(
+  doc: TextDocument,
+  diagnostic: Diagnostic
+): CodeAction | null {
+  const data = diagnostic.data;
+  if (!isLegacyArgOrderFixData(data)) return null;
+
+  const text = doc.getText();
+  const edits: TextEdit[] = [];
+  // Each swap pair substitutes the two argument slices at their own ranges.
+  // Emitting per-slot edits (rather than rewriting the whole call) keeps
+  // surrounding whitespace/comments intact.
+  for (const [i, j] of data.swapPairs) {
+    const a = data.argSpans[i];
+    const b = data.argSpans[j];
+    if (!a || !b) return null;
+    edits.push({
+      range: spanToRange(doc, a),
+      newText: text.slice(b.start, b.end)
+    });
+    edits.push({
+      range: spanToRange(doc, b),
+      newText: text.slice(a.start, a.end)
+    });
+  }
+  if (edits.length === 0) return null;
+
+  return {
+    title: `Reorder arguments of '${data.functionName}' to preferred order`,
+    kind: CodeActionKind.QuickFix,
+    diagnostics: [diagnostic],
+    isPreferred: true,
+    edit: {
+      changes: {
+        [doc.uri]: edits
+      }
+    }
+  };
+}
+
 export function getCodeActions(
   params: GetCodeActionsParams,
   parser: Parser,
@@ -141,6 +194,9 @@ export function getCodeActions(
     } else if (diagnostic.code === 'unknown-ident') {
       const action = didYouMeanQuickFix(params.textDocument, diagnostic, knownNames);
       if (action) out.push(action);
+    } else if (diagnostic.code === 'legacy-arg-order') {
+      const action = reorderArgsQuickFix(params.textDocument, diagnostic);
+      if (action) out.push(action);
     }
   }
 

src/language-service/code-actions.ts

@@ -77,6 +77,7 @@ import { getSignatureHelp as computeSignatureHelp } from './signature-help';
 import { encodeSemanticTokens } from './semantic-tokens';
 import { getUnknownIdentDiagnostics } from './unknown-ident';
 import { getTypeMismatchDiagnostics } from './type-check';
+import { getLegacyArgOrderDiagnostics } from './legacy-arg-order';
 import { getCodeActions as computeCodeActions } from './code-actions';
 import { format as computeFormat } from './formatter';
 
@@ -421,6 +422,10 @@ export function createLanguageService(options: LanguageServiceOptions | undefine
     // Type-mismatch diagnostics — literals-only, always on
     diagnostics.push(...getTypeMismatchDiagnostics(textDocument, parseCache));
 
+    // Legacy argument-order diagnostics — suggests reordering to the
+    // preferred (collection-first) form for dual-order built-ins
+    diagnostics.push(...getLegacyArgOrderDiagnostics(textDocument, parseCache));
+
     return diagnostics;
   }
 

src/language-service/language-service.ts

@@ -87,8 +87,10 @@ export interface LanguageServiceApi {
 
     /**
      * Returns LSP CodeAction quick fixes for the diagnostics in the supplied
-     * context. Currently handles `arity-too-few` (inserts placeholder args)
-     * and `unknown-ident` (Levenshtein "did you mean" suggestions).
+     * context. Currently handles `arity-too-few` (inserts placeholder args),
+     * `unknown-ident` (Levenshtein "did you mean" suggestions) and
+     * `legacy-arg-order` (reorders dual-order built-in calls to the preferred
+     * collection-first form).
      */
     getCodeActions(params: GetCodeActionsParams): CodeAction[];