fix(formula): prescribe the bare call shape for a stdlib function written as a method

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }

.changeset/formula-receiver-call-prescription.md

@@ -0,0 +1,55 @@
+---
+"@objectstack/formula": patch
+---
+
+fix(formula): a stdlib function written as a method gets the bare call shape, not the dialect (#14203)
+
+`validateExpression` refused `record.name.upper()` correctly and then handed the
+author the generic dialect trailer — "`predicate`s are bare CEL (e.g.
+`record.rating >= 4`)" — advice that cannot succeed on a source that already IS
+bare CEL and parses fine. The third instance of the same defect family as the
+`bounds` class (#7073) and the unknown-name class (#13821), and the one neither
+of them could cover: #13821's arm fires only when the name is ABSENT from
+`CEL_STDLIB_FUNCTIONS`, and `upper` is present, so this class had no
+prescription at all. The name is right; the call SHAPE is wrong.
+
+It is a high-frequency AI-author mistake, not an exotic one: method-call syntax
+is what almost every other language uses for string operations, so a generator
+that knows `upper` exists reaches for `record.name.upper()` before
+`upper(record.name)`. The remedy is one sentence and it is mechanical — the
+correct spelling is derivable from the fault itself:
+
+```
+invalid CEL predicate: found no matching overload for 'dyn.upper()'
+
+> 1 | record.name.upper()
+ ^ — `upper` is callable bare, not as a method — a CALL-SHAPE fault, not
+a dialect mistake, so re-spelling the expression will not fix it. Write
+`upper(record.name)` instead. The callable names this platform advertises for
+authoring (the `functions` list `introspectScope` returns,
+`CEL_STDLIB_FUNCTIONS`) take their subject as an argument; only cel-js's own
+receiver methods (`record.name.split(',')`) are written after a dot.
+```
+
+The spelling is assembled from the SOURCE, because cel-js's message names the
+receiver's TYPE (`dyn.upper()`) and never the author's expression. When the
+receiver is not a plain dotted chain (`record.tags[0].upper()`,
+`(a + b).upper()`, `'lit'.upper()`) the message names the call shape —
+`upper(…)` with the receiver as its first argument — rather than inventing a
+spelling it cannot derive.
+
+The arm is keyed on membership of the bare-callable catalog plus the
+environment's own record of the receiver form, never on the call shape alone.
+Two classes therefore keep exactly the behaviour they had:
+
+- the 33 receiver-only names cel-js registers (`split`, `map`, `getFullYear`)
+ are correct ONLY after a dot — `record.name.split(',')` type-checks and never
+ reaches this arm;
+- the seven advertised names registered BOTH ways (`contains`, `endsWith`,
+ `matches`, `size`, `startsWith`, `string`, `trim`) keep the existing trailer
+ when a receiver call of them faults, because the fault there is the arguments
+ (`record.name.contains()`), and a bare rewrite would fault just as hard.
+
+No change to `CEL_STDLIB_FUNCTIONS`, to the registered environment, or to what
+`validateExpression` accepts: the receiver call was refused before this change
+and is refused after it. Only the sentence the author is told to act on changes.

packages/formula/src/unknown-function.test.ts

@@ -3,7 +3,12 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildEnv, celEngine } from './cel-engine';
-import { callNameFromNoOverload, firstUnknownFunctionCall } from './unknown-function';
+import {
+ callNameFromNoOverload,
+ firstUnknownFunctionCall,
+ isReceiverRegistered,
+ receiverCallNameFromNoOverload,
+} from './unknown-function';
 import { CEL_STDLIB_FUNCTIONS } from './validate';
 
 /**
@@ -224,3 +229,64 @@ describe('callNameFromNoOverload — the shared extraction (#13594)', () => {
  });
 });
 
+
+// #14203 — the second question about the same message: not "which token did
+// cel-js name?" but "was it written as a method?". A sibling reader rather than
+// a flag, so the extraction above keeps answering both call forms identically
+// for its two existing consumers.
+describe('receiverCallNameFromNoOverload — the call-FORM reading (#14203)', () => {
+ it.each([
+ ["found no matching overload for 'dyn.upper()'", 'upper'],
+ ["found no matching overload for 'string.upper()'", 'upper'],
+ ["found no matching overload for 'dyn.nosuchmethod(string)'", 'nosuchmethod'],
+ ["found no matching overload for 'list<dyn>.size()'", 'size'],
+ ])('%s → %s', (message, expected) => {
+ expect(receiverCallNameFromNoOverload(message)).toBe(expected);
+ });
+
+ it.each([
+ "found no matching overload for 'upper(int, int)'",
+ "found no matching overload for 'totallyBogusFn(int, int)'",
+ "found no matching overload for 'split(dyn, string)'",
+ 'no such overload: int + string',
+ ])('is undefined for a BARE call or a non-call verdict: %s', (message) => {
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+
+ it('does not reach past the closing quote into the source excerpt', () => {
+ // cel-js's `formatErrorWithHighlight` puts the author's own source on the
+ // following lines, dots and all — and a BARE call must stay undefined even
+ // when those lines are full of receiver-looking text.
+ const message =
+ "found no matching overload for 'split(dyn, string)'\n" +
+ " record.a.b.split(',')\n" +
+ ' ^';
+ expect(receiverCallNameFromNoOverload(message)).toBeUndefined();
+ });
+});
+
+describe('isReceiverRegistered — the second key a call-shape prescription needs (#14203)', () => {
+ it.each(['contains', 'endsWith', 'matches', 'size', 'startsWith', 'string', 'trim'])(
+ '`%s` is advertised bare AND registered as a receiver method — both forms are real',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ },
+ );
+
+ it.each(['upper', 'lower', 'isBlank', 'daysFromNow', 'abs', 'coalesce'])(
+ '`%s` is bare-only — a receiver call of it is a call-SHAPE fault',
+ (name) => {
+ expect(isReceiverRegistered(name)).toBe(false);
+ },
+ );
+
+ it.each(['split', 'map', 'getFullYear'])('`%s` is receiver-registered — the inverse class', (name) => {
+ expect(isReceiverRegistered(name)).toBe(true);
+ });
+
+ it('says nothing about existence — an unregistered name is simply not a receiver method', () => {
+ // The two questions stay separate: `firstUnknownFunctionCall` owns existence.
+ expect(isReceiverRegistered('totallyBogusFn')).toBe(false);
+ expect(firstUnknownFunctionCall('totallyBogusFn(1,2)')?.name).toBe('totallyBogusFn');
+ });
+});

packages/formula/src/unknown-function.ts

@@ -48,6 +48,9 @@
  * with one template family: a bare call (`'totallyBogusFn(int, int)'`) and a
  * receiver call (`'dyn.nosuchmethod(string)'`). {@link NO_OVERLOAD_RE} takes the
  * segment immediately before the argument list, after any receiver-type prefix.
+ * Which of the two forms was written is a separate question, asked separately by
+ * {@link receiverCallNameFromNoOverload} — the existence verdict below is
+ * deliberately blind to it.
  *
  * ## What this deliberately does NOT report
  *
@@ -107,6 +110,36 @@ export function callNameFromNoOverload(message: string): string | undefined {
  return NO_OVERLOAD_RE.exec(message)?.[1];
 }
 
+/**
+ * The RECEIVER spelling of {@link NO_OVERLOAD_RE}'s template family, with the
+ * receiver-type prefix REQUIRED instead of optional. Matches
+ * `found no matching overload for 'dyn.upper()'` and never the bare
+ * `…for 'upper(int, int)'`.
+ *
+ * The prefix class excludes the quote (and the newline) so it cannot reach past
+ * the closing `)'` — the same anchoring concern its sibling documents, since
+ * cel-js appends the author's own source, dots and all, on the following lines.
+ */
+const RECEIVER_NO_OVERLOAD_RE = /found no matching overload for '[^'\n]*[.]([A-Za-z_$][\w$]*)\(.*?\)'/;
+
+/**
+ * The METHOD name inside a receiver-form `found no matching overload for '…'`
+ * message (`'dyn.upper()'` → `upper`), or `undefined` when the message is any
+ * other shape — a bare call included.
+ *
+ * A sibling of {@link callNameFromNoOverload} rather than a flag on it: that
+ * function answers "which token did cel-js name?" for two consumers that must
+ * keep getting the same answer for both call forms, while this one answers a
+ * second, independent question — "was it written as a method?".
+ *
+ * The receiver segment cel-js prints is a TYPE (`dyn`, `string`,
+ * `list<dyn>`), never the author's own expression, so it is matched and
+ * discarded. A caller that wants to NAME the receiver has to read the source.
+ */
+export function receiverCallNameFromNoOverload(message: string): string | undefined {
+ return RECEIVER_NO_OVERLOAD_RE.exec(message)?.[1];
+}
+
 /**
  * Every function name the canonical evaluation environment registers — bare
  * callables (`upper(x)`) and receiver-only methods (`s.split(',')`) alike.
@@ -121,18 +154,48 @@ export function callNameFromNoOverload(message: string): string | undefined {
  * names exist. The clock passed here is the same fixed instant `compile` uses
  * for its own parse-time environment, and is never called.
  */
-let registeredNames: ReadonlySet<string> | undefined;
+interface RegisteredNames {
+ /** Every registered name, whichever call form(s) it occupies. */
+ all: ReadonlySet<string>;
+ /** The subset registered as a receiver method, `x.fn()`. */
+ receiver: ReadonlySet<string>;
+}
+
+let registeredNames: RegisteredNames | undefined;
 
-function registeredFunctionNames(): ReadonlySet<string> {
+function registeredFunctionNames(): RegisteredNames {
  if (!registeredNames) {
  const env = buildEnv(() => new Date(0)) as unknown as {
- getDefinitions(): { functions: Array<{ name: string }> };
+ getDefinitions(): { functions: Array<{ name: string; receiverType: string | null }> };
+ };
+ const functions = env.getDefinitions().functions;
+ registeredNames = {
+ all: new Set(functions.map((fn) => fn.name)),
+ // `receiverType` is cel-js's own record of which call form a definition
+ // occupies: `null` for `fn(x)`, the receiver's type for `x.fn()`. A name
+ // can hold definitions of both kinds.
+ receiver: new Set(functions.filter((fn) => fn.receiverType != null).map((fn) => fn.name)),
  };
- registeredNames = new Set(env.getDefinitions().functions.map((fn) => fn.name));
  }
  return registeredNames;
 }
 
+/**
+ * Whether the evaluation environment registers `name` as a receiver method
+ * (`x.fn()`) — in ADDITION to a bare call, or instead of one.
+ *
+ * Exported because "the name is in the bare-callable catalog" does not imply
+ * "writing it after a dot is wrong": seven advertised names hold definitions of
+ * both kinds (`contains`, `endsWith`, `matches`, `size`, `startsWith`,
+ * `string`, `trim`; `validate.test.ts` pins the set). A consumer that
+ * prescribes a call SHAPE needs this second answer, or it tells the author of
+ * `record.name.contains()` — an arity fault on a legitimate receiver call — to
+ * rewrite into a bare call that faults just as hard.
+ */
+export function isReceiverRegistered(name: string): boolean {
+ return registeredFunctionNames().receiver.has(name);
+}
+
 /** A call to a name the evaluation environment does not register. */
 export interface UnknownFunctionCall {
  /** The called name, e.g. `totallyBogusFn` — for a receiver call, the METHOD name. */
@@ -174,6 +237,6 @@ export function firstUnknownFunctionCall(source: string): UnknownFunctionCall |
  if (!name) return null;
  // Registered, so the fault is about the ARGUMENTS or the call position, not
  // about whether the name exists. Blind spot, deliberately (refinement 3).
- if (registeredFunctionNames().has(name)) return null;
+ if (registeredFunctionNames().all.has(name)) return null;
  return { name, detail: compiled.error.message.split('\n')[0].trim() };
 }