wkhandClaude Sonnet 5
01ea18106c
Replaces the previous FOR-only, single-statement-body, static-unrolling design with genuine control flow: FOR var IN source DO <block> END loop bodies with any number of statements (including nested loops/IFs), IF cond THEN <block> [ELSE <block>] END branching (nestable in any block), and RETURN as an ordinary statement usable anywhere -- it aborts execution immediately with its value, including breaking out of a loop early. This required a real, if small, architecture change: an IF branch or an early RETURN depends on actual cell values, which the previous "unroll everything into one static formula at parse time" approach can't resolve (loop *counts* are knowable up front from a range's size; branch *outcomes* aren't). A kind: 'block' call is now inlined only as far as resolving nested function calls (expandBlock, parse-time, same inside-out principle as before) and wrapped in a new BlockCallNode; its own control flow is interpreted at evaluation time by a small tree-walking interpreter added to evaluator.ts (execBlock/execStatement, a thrown ReturnSignal for early exit), reusing userFunctions.ts's substitute() (now exported) to resolve parameter/local-variable names against the current environment. Dependency tracking stays fully correct and conservative: collectRefs() walks into a BlockCallNode's block (new collectRefsInBlock), so a cell referenced only in a branch that doesn't happen to run is still a tracked precedent -- same principle as an ordinary IF() in any spreadsheet. Also added: comparison operators (= <> > < >= <=, result 1/0) as a new, loosest-binding precedence level in the *general* expression grammar (not just inside a block's IF) -- needed for IF conditions to be useful at all. A definition-time static check (blockAlwaysReturns) rejects a function at save time when it's not obviously guaranteed to reach RETURN on every path (an IF without an ELSE, or one where only one branch returns); the interpreter's own runtime "ended without RETURN" -> #ERR remains the actual enforcement for cases the static check can't see (e.g. a loop over an empty range). Nested loops (FOR inside FOR) and nested IFs work as an emergent property of the recursive statement grammar -- verified with dedicated tests, not just assumed. 257 tests passing (30 net new/rewritten for this change), vue-tsc/ eslint/build clean. Verified live in the running app: a FIRSTOVER(range; threshold) function using a FOR loop with a nested IF and an early RETURN, confirmed it returns the first match, confirmed changing a cell *past* the match point doesn't affect the result while changing the match point itself does, and confirmed a function without a guaranteed RETURN is rejected inline at save time. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
92 lines
2.5 KiB
TypeScript
92 lines
2.5 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
import { tokenize } from '../lexer';
|
|
|
|
const types = (s: string) => tokenize(s).map((t) => t.type);
|
|
const values = (s: string) => tokenize(s).map((t) => t.value);
|
|
|
|
describe('lexer', () => {
|
|
it('tokenizes numbers incl. decimals and exponents', () => {
|
|
expect(values('1 2.5 .5 1e3 1.2E-3')).toEqual([
|
|
'1',
|
|
'2.5',
|
|
'.5',
|
|
'1e3',
|
|
'1.2E-3',
|
|
'',
|
|
]);
|
|
expect(types('42')).toEqual(['NUMBER', 'EOF']);
|
|
});
|
|
|
|
it('tokenizes operators and punctuation', () => {
|
|
expect(types('+-*/^():;!')).toEqual([
|
|
'PLUS',
|
|
'MINUS',
|
|
'STAR',
|
|
'SLASH',
|
|
'CARET',
|
|
'LPAREN',
|
|
'RPAREN',
|
|
'COLON',
|
|
'SEMICOLON',
|
|
'BANG',
|
|
'EOF',
|
|
]);
|
|
});
|
|
|
|
it('reads bare words as IDENT (cell refs, functions, sheet names alike)', () => {
|
|
expect(types('SUM(A1:B2)')).toEqual([
|
|
'IDENT',
|
|
'LPAREN',
|
|
'IDENT',
|
|
'COLON',
|
|
'IDENT',
|
|
'RPAREN',
|
|
'EOF',
|
|
]);
|
|
});
|
|
|
|
it('reads single-quoted sheet names with spaces', () => {
|
|
const t = tokenize("'Kosten Q3'!B2");
|
|
expect(t[0]).toMatchObject({ type: 'QUOTED', value: 'Kosten Q3' });
|
|
expect(t[1].type).toBe('BANG');
|
|
expect(t[2]).toMatchObject({ type: 'IDENT', value: 'B2' });
|
|
});
|
|
|
|
it('handles escaped double-quoted strings', () => {
|
|
expect(tokenize('"a\\"b"')[0]).toMatchObject({ type: 'STRING', value: 'a"b' });
|
|
});
|
|
|
|
it('reads $-locked cell references as one IDENT', () => {
|
|
expect(types('$A$1 A$1 $A1')).toEqual(['IDENT', 'IDENT', 'IDENT', 'EOF']);
|
|
expect(values('$A$1 A$1 $A1')).toEqual(['$A$1', 'A$1', '$A1', '']);
|
|
});
|
|
|
|
it('skips whitespace', () => {
|
|
expect(types(' A1\t+\n B2 ')).toEqual(['IDENT', 'PLUS', 'IDENT', 'EOF']);
|
|
});
|
|
|
|
it('throws on an unexpected character', () => {
|
|
expect(() => tokenize('A1 & B2')).toThrow();
|
|
});
|
|
|
|
it('tokenizes assignment/equality and comparison operators', () => {
|
|
expect(types('= < > <= >= <>')).toEqual([
|
|
'EQUALS',
|
|
'LT',
|
|
'GT',
|
|
'LTE',
|
|
'GTE',
|
|
'NEQ',
|
|
'EOF',
|
|
]);
|
|
});
|
|
|
|
it('prefers the two-character comparison operators over their single-character prefix', () => {
|
|
expect(types('A1<=B2')).toEqual(['IDENT', 'LTE', 'IDENT', 'EOF']);
|
|
expect(types('A1>=B2')).toEqual(['IDENT', 'GTE', 'IDENT', 'EOF']);
|
|
expect(types('A1<>B2')).toEqual(['IDENT', 'NEQ', 'IDENT', 'EOF']);
|
|
expect(types('A1<B2')).toEqual(['IDENT', 'LT', 'IDENT', 'EOF']);
|
|
expect(types('A1>B2')).toEqual(['IDENT', 'GT', 'IDENT', 'EOF']);
|
|
});
|
|
});
|