Extend the file scanning loop to also cover header and source files under the `include/` directory by using `itertools.chain` to combine both glob patterns, ensuring metrics are computed for all relevant source locations.
Add closure objects that wrap functions with captured upvalues, enabling
first-class closures that close over local variables from enclosing scopes.
Introduce new bytecode instructions (CODE_CLOSURE, CODE_LOAD_UPVALUE,
CODE_STORE_UPVALUE, CODE_CLOSE_UPVALUE, CODE_RETURN) and a CompilerUpvalue
tracking system with a MAX_UPVALUES limit of 256. Refactor the grammar to
strictly separate statements from expressions, fixing a bug where block
expressions incorrectly popped locals while temporaries remained on the
stack. Rename internal functions (wrenCallFunction, wrenDebugDumpInstruction,
wrenDebugDumpStack) and add Upvalue allocation, closure creation, and
debug dump support for the new instructions.
Change Token struct to store `const char* start` pointer and `int length` instead of integer start/end offsets. Update Lexer struct similarly, replacing `tokenStart` and `currentChar` offsets with direct pointers into the source string. Adjust Local struct's `length` field type from `size_t` to `int` for consistency. Simplify error reporting in `endCompiler` to use `printf` with `%.*s` format specifier and the new pointer/length fields, eliminating manual character-by-character printing loops.
Extract the common bytecode finalization logic into a dedicated endCompiler function that emits CODE_END and handles parent compiler function loading, replacing duplicated inline code. Update VM method definition opcodes to pop function from stack instead of reading from constants, enabling future closure support. Add TODO comments outlining planned closure capture mechanism and upvalue tracking requirements.
The `wrenNewVM` function now uses the provided `reallocateFn` for fiber allocation instead of calling `malloc` directly, and stores the allocator in `vm->reallocate` for later use. The `wrenReallocate` function delegates all memory operations (including freeing) to the stored allocator, removing the fallback to `realloc` and `free`. This ensures consistent memory management through the external allocator, enabling custom allocation strategies like memory pools or tracking.
Introduce a `.nav` sidebar with categorized links (Welcome, Language, Objects, Usage) alongside a `.content` area, replacing the old inline header list. Widen the page container from 640px to 840px, rename `.column` to `.page`, and update the header to show a subtitle instead of a small tagline. Adjust the GitHub ribbon z-index to prevent overlap with the new sidebar.
Extract identifier copying logic from subscript and call functions into a dedicated copyName helper function, reducing code duplication. Rename the method signature length constant to MAX_METHOD_SIGNATURE with updated documentation to clarify it includes arity spaces. Update subscript function to use the new constant name and remove stale TODO comment about handling >10 args.
Add a compile-time check in declareVariable() that emits an error when the number of simultaneous local variables reaches MAX_LOCALS (256), replacing the previous placeholder TODO. The limit is derived from the bytecode encoding constraint where CODE_LOAD_LOCAL and CODE_STORE_LOCAL use a single argument byte. Also move the MAX_LOCALS definition from a TODO comment to a proper #define, increasing the value from 255 to 256. Include four new test files: many_locals.wren (exactly 256 simultaneous locals), many_nonsimultaneous_locals.wren (more than 256 locals across nested scopes), too_many_locals.wren (257 simultaneous locals triggering the error), and too_many_locals_nested.wren (exceeding the limit across nested blocks).
Replace the linked-list Scope structure with a flat Local array indexed by depth, enabling proper shadowing semantics where inner declarations correctly hide outer ones. Remove the PUSH_SCOPE/POP_SCOPE macros and the SymbolTable-based locals tracking, replacing them with a MAX_LOCALS (255) fixed-size array that stores variable name, length, and depth. Add four new test cases covering local/parameter collision, nested block scoping, global shadowing, and local shadowing to validate the new behavior.
The .gitignore file now includes an entry for scratch.wren, a temporary Wren script left at the top level for quick testing purposes. This prevents accidental commits of ad-hoc experimentation files.
Add Lua, Python, Ruby, and Wren implementations of the binary_trees benchmark from the Computer Language Benchmarks Game. Update the benchmark runner to support multiple benchmarks with output validation, and fix the Wren compiler to handle the '\t' escape sequence in string literals.
The method function was incorrectly using the outer `compiler` pointer instead of the inner `methodCompiler` when emitting `CODE_LOAD_LOCAL` and its operand, causing incorrect bytecode generation for constructor receiver loading.
Move the dumpInstruction function and its associated opcode printing logic from wren_vm.c into a dedicated wren_debug.c source file with a corresponding wren_debug.h header. Add the new source file to the Xcode project build configuration.
Add test file for Foo class constructors covering zero, one, and two argument overloads by arity. Verify each overload produces correct output and that new instances return proper type and toString behavior.
Add MAX_PARAMETERS constant set to 16 and extend VM bytecode instructions CODE_CALL_11 through CODE_CALL_16 to support the new limit. Introduce compile-time error messages when parameter or argument count exceeds 16 in function definitions, method declarations, subscript calls, and regular method calls. Add new native fiber call stubs fn_call9 through fn_call16 and register them in the core initialization. Include comprehensive test coverage for 9-16 parameter functions and methods, plus error tests for exceeding the limit in all contexts.
Add a check in the `field()` function to detect when a field is referenced outside of a class context. When `compiler->fields` is NULL (indicating no enclosing class), emit a clear error message "Cannot reference a field outside of a class definition." and assign a dummy field index of 255 to allow continued parsing with minimal cascading errors.
Also includes minor cleanup: remove two stale TODO comments about EOF checking and better error messages in `nextToken()` and `consume()`, and add a new test file `test/field/outside_class.wren` that verifies the error is produced for top-level field assignment.
Replace the fixed-size `MAX_PINNED` array of `Obj*` pointers with a dynamically allocated linked list of `PinnedObj` nodes, removing the 16-object limit and eliminating the `numPinned` counter. Update `pinObj` to accept a caller-provided `PinnedObj` stack variable and link it at the head of the list, and simplify `unpinObj` to pop the head without requiring the object argument. Adjust `wrenNewVM` to initialize the new `pinned` pointer to NULL, and modify `collectGarbage` to iterate the linked list instead of the array.
Rename the `primitives.h` and `primitives.c` files to `wren_core.h` and `wren_core.c` respectively, reflecting the module's purpose of defining built-in classes and native methods. Update all includes, macro names (PRIMITIVE -> NATIVE, DEF_PRIMITIVE -> DEF_NATIVE, etc.), and function calls (wrenLoadCore -> wrenInitializeCore) across the codebase and Xcode project file to match the new naming convention.
Move `allocate`, `initObj`, `newClass`, and related static helpers from `vm.c` into `value.c` with consistent `wren` prefix, and update all call sites in `compiler.c`, `primitives.c`, and `vm.c` to use the new names (`wrenNewFunction`, `wrenNewString`, `wrenNewClass`, `wrenNewInstance`, `wrenNewList`). Remove the old declarations from `vm.h` and add comprehensive documentation comments to `value.h` explaining the NaN-tagging representation and type system.
Add DEF_PRIMITIVE(list_removeAt) to src/primitives.c that removes an element at a given index from an ObjList, shifts remaining elements up, shrinks capacity when excess is detected via LIST_GROW_FACTOR, and returns the removed Value. Register the primitive as "removeAt " on vm->listClass. Create test/list/remove_at.wren covering removal at positive indices 0,1,2, negative indices -1,-2,-3, out-of-bounds cases returning null, and verification that the removed value is returned.
Extract inline list growth logic into `ensureListCapacity` helper and add `validateIndex` function supporting negative indices. Implement `list_clear` primitive that resets count to zero without freeing memory, and `list_insert` primitive that shifts elements right and inserts at validated position. Add comprehensive test suites for both operations covering empty lists, normal/negative indices, and return values.
- Moved unit tests for user authentication into `tests/unit/auth/`
- Relocated integration tests for payment processing to `tests/integration/payments/`
- Grouped API endpoint tests under `tests/api/` with separate files for each resource
- Updated test runner configuration to discover tests in new directory structure
Add the `list_add` primitive to support appending elements to lists with automatic capacity management using `LIST_MIN_CAPACITY` and `LIST_GROW_FACTOR` constants. Rename internal `valuesEqual` and `reallocate` functions to `wrenValuesEqual` and `wrenReallocate` for consistent naming, and introduce `wrenPrintValue` to handle formatted output of all value types including lists. Add a test file `test/list_add.wren` verifying basic add operations and return value behavior.
Move equality and inequality primitives from Bool and Function to a single Object-level implementation using valuesEqual, and add wrenGetClass to return the runtime class of any value. Refactor newSingleClass to inherit methods from superclass and wire metaclass superclass to classClass. Add type-checking tests for all built-in types and class inheritance.
Add a new JavaScript benchmark file `benchmark/fib.js` that implements a recursive Fibonacci function and measures execution time using `process.hrtime()`. Register the JavaScript language entry in `benchmark/run_all` with the `node` interpreter and `.js` extension, enabling JS benchmarks to be included in the full benchmark suite alongside existing languages.
Replace separate allocation, deallocation, and reallocation logic with a single `reallocate` function that handles all memory operations (alloc, grow, shrink, free) and integrates garbage collection triggers based on total allocated memory thresholds. Add `allocate` and `deallocate` convenience wrappers that delegate to `reallocate`.
Introduce a `COMPUTED_GOTOS` preprocessor flag in `src/common.h` that, when defined, replaces the interpreter's traditional `for(;;) switch(instruction)` dispatch loop with a computed-goto dispatch table using GCC/LLVM labels-as-values extension. The new implementation defines a static `dispatchTable[]` array mapping opcodes to their corresponding `&&code_*` labels, and uses `DISPATCH()` macro to `goto` the next handler directly. When `COMPUTED_GOTOS` is not defined, the fallback retains the original `switch`-based loop. This change yields approximately a 5% performance improvement in benchmarks, though optimal GCC performance may require additional flags like `-fno-gcse`.
Add list_subscript primitive that supports integer indexing with negative indices counting from the end, returns null for out-of-bounds access, non-integer indices, and non-numeric argument types. Register the `[ ]` operator on the List class in loadCore and include comprehensive test coverage in test/list_subscript.wren.
Add support for list literals in the compiler with bracket-delimited syntax and comma-separated elements. Introduce the ObjList runtime type with a contiguous elements array, garbage collection marking, and proper memory deallocation. Expose a `List` class in the core library with a `count` method returning the number of elements. Update the grammar table to register `[` as a prefix token for list compilation instead of an infix subscript operator, and reorder opcode enum entries to place CODE_LIST before the load/store group.
Implement the `[]` subscript operator as an infix parser at `PREC_CALL` precedence, compiling to a method call on the receiver. Add a `string_subscript` primitive that handles integer indices (including negative for reverse indexing), returns `null` for out-of-bounds or non-integer arguments, and returns a one-character string. Register the `[ ]` method on the string class and include tests for basic indexing, negative indices, out-of-bounds, wrong types, and non-integer indices.
Add escape sequence handling to the string literal lexer in compiler.c, translating
common escape sequences (\", \\, \n) into their literal character equivalents during
tokenization. Introduce a fixed-size buffer (MAX_STRING 1024) in the Parser struct to
accumulate the unescaped string content, along with a helper function addStringChar()
to append characters. The readString() function now loops over input characters,
breaking on an unescaped double quote, and processing backslash-prefixed escapes via
a switch statement. Remove the previous TODO placeholder comment and the elapsed time
computation simplification in benchmark/fib.lua. Add a new test file
test/string_escapes.wren that verifies the three supported escape sequences, and
remove the now-obsolete TODO about escapes from test/string_literals.wren.
Add TOKEN_FIELD token type and '_' prefix handling in lexer to distinguish field identifiers from regular names. Extend Compiler struct with fields symbol table pointer for tracking enclosing class fields. Implement field() parse function and CODE_LOAD_FIELD/CODE_STORE_FIELD bytecodes in VM. Modify ObjClass to store numFields count and ObjInstance to use flexible array member for field storage. Update GC markInstance to trace all instance fields. Add newClass signature to accept numFields parameter. Include test cases for field default null, multiple fields, object references with GC, and use-before-set ordering.
Add full introductory content to the classes documentation page covering class definition, inheritance, and the Object superclass. Create a new usage documentation page with a TODO placeholder. Update the HTML page title format from "wren {title}" to "Wren - {title}" and add a navigation link to the new usage page.
Extract hardcoded trial count into NUM_TRIALS constant set to 7, collect all timing results into a list, and add graph_results function that prints a horizontal ASCII bar chart scaling each run's times relative to the global maximum across all benchmarks and languages.
Add a benchmark runner script (benchmark/run_all) that executes multiple
fibonacci implementations across languages (Lua, Python, Ruby, Wren) and
computes mean, median, and standard deviation from 7 runs. Update existing
fib benchmarks to loop 5 times at fib(30) with elapsed timing. Introduce
OS.clock primitive in C core and OS class to support timing in Wren.
Adjust number formatting to "%.14g" for consistent output precision.
This commit introduces a LICENSE file containing the full text of the MIT License, attributed to Robert Nystrom (2013), which governs the distribution and use of the Wren software.
Extract repeated two-character token matching logic into a dedicated
twoCharToken function, reducing code duplication in readRawToken.
Remove the unused skipWhitespace helper that only handled single spaces
and was replaced by more robust whitespace handling elsewhere.
Fix indentation in isKeyword and remove stale TODO comment in readName.
Add TOKEN_PIPEPIPE token for '||' syntax, implement or() parsing function with CODE_OR bytecode, and add VM interpreter logic that short-circuits on truthy left operand. Update .gitignore to exclude *.xccheckout files, extend test coverage for falsy behavior in and.wren and if.wren, and add comprehensive or.wren test suite verifying short-circuit semantics and truthiness rules.
The new IS_FALSE macro checks if a Value's type field equals VAL_FALSE,
complementing the existing IS_NULL and IS_NUM macros for type discrimination
without relying on NaN-boxing tag bits.
Add TOKEN_AMPAMP token to the lexer for parsing '&&' operator, introduce PREC_LOGIC precedence level for proper expression parsing, implement the `and()` compiler function that emits CODE_AND with a patchable jump offset, and add runtime support in the VM with IS_FALSE macro for truthiness checking. Include comprehensive test cases in test/and.wren verifying short-circuit behavior and return values.
Introduce Scope struct and PUSH_SCOPE/POP_SCOPE macros to manage nested variable scopes during compilation. Update declareVariable to distinguish global declarations from local ones based on scope presence rather than parent compiler. Add truncateSymbolTable helper to clean up local symbols when exiting a scope. Include new test files verifying scoped variable isolation in if, while, and block constructs.
Add TOKEN_WHILE to the token enum and keyword lookup in the compiler, enabling the parser to recognize 'while' statements. Introduce the CODE_LOOP opcode in the VM for backward jumps, and implement the patchJump helper to resolve forward jump offsets during compilation. Include comprehensive test cases for while loops covering single-expression bodies, block bodies, newline handling, and null result semantics.
Switch Value from a struct with type/num/obj fields to a NaN-tagged uint64_t/double union, enabling faster type checks and unboxed numbers. Refactor all macros and accessors (IS_OBJ, AS_OBJ, AS_NUM, etc.) to work with the new representation. Hoist CallFrame pointer, instruction pointer, and bytecode array into local variables inside the interpret loop, updating them on frame push/pop. Enable NAN_TAGGING define and DEBUG_GC_STRESS in common.h. Update Xcode project to use c99 standard, pedantic warnings, and treat warnings as errors. Add benchmark/fib.txt with timing comparisons showing fib benchmark within 25% of Lua.
Replace NUM_VAL and integer literals with TRUE_VAL, FALSE_VAL, and BOOL_VAL
in the string_contains primitive implementation, and update the test
expectations from 1/0 to true/false accordingly.
Introduce METHOD_FIBER type and FIBER_PRIMITIVE/DEF_FIBER_PRIMITIVE macros to handle primitives that directly manipulate the fiber's call stack, eliminating the need for the special NO_VAL return value hack. Remove all fn_call0 through fn_call8 primitives and convert them to fiber primitives that call callFunction without returning a value. Update Primitive typedef to remove the Fiber parameter, and adjust primitive_metaclass_new and the interpret switch case accordingly. Delete the NO_VAL macro and its TODO comment from value.h.
Remove two dead conditional branches that wrote "bad" and "bad2" when false, replacing them with a single unconditional call to io.write("Hello, world!") to serve as a proper introductory example for the Wren language.
The VAL_NO_VALUE enum variant and its associated NO_VAL macro were removed from the value type system. The NO_VAL sentinel is now represented as a VAL_OBJ with a NULL object pointer, eliminating the hacky "no value" type. Updated the interpret function's primitive call return check to detect this new sentinel by verifying both the type is VAL_OBJ and the object pointer is NULL, rather than checking for the removed VAL_NO_VALUE type. Removed the TODO(bob) comments referencing the hack.
The default garbage collection trigger threshold in newVM() is raised from 1024*1024 (1MB) to 1024*1024*10 (10MB) to reduce GC frequency for larger workloads. Additionally, the DEBUG_GC_STRESS macro in common.h is commented out to disable stress-test GC collections on every allocation by default.
Remove the ObjNum heap-allocated wrapper for numbers, storing the double value inline in the Value union. This eliminates OBJ_NUM enum case, the newNum() constructor, and all ObjNum-related code in the GC, printing, and type dispatch. Replace all (Value)newNum(vm, ...) calls with the NUM_VAL() macro and update AS_NUM() to read from the inline field. Adjust IS_FN/IS_STRING macros to use IS_OBJ() guard and update all Value literal macros to include the new num field initializer.
Introduce Value type system with explicit type tags (VAL_OBJ, VAL_NUM, VAL_BOOL, etc.) and update all macros (AS_FN, IS_BOOL, OBJ_VAL) to operate on Value structs instead of raw Obj pointers. Migrate constant table entries, global slots, and function return values from NULL to NO_VAL/NULL_VAL. Add objectToValue helper and adjust markObj to accept Obj* directly.
Add three language implementations of a naive recursive fibonacci(35) benchmark
alongside a design document exploring implicit field declaration semantics for
the wren language, including nested class scoping and static field conventions.
Extract shared parameter list parsing from namedSignature into a new parameterList function called by function, and replace single fn_call primitive with fn_call0 through fn_call8 primitives to support up to 8 arguments. Add comprehensive fn_parameters.wren test covering 0-8 parameter calls.
Add support for user-defined operator methods in classes by introducing a `SignatureFn` field to `GrammarRule` and implementing four signature compilation functions: `namedSignature`, `infixSignature`, `unarySignature`, and `mixedSignature`. These functions handle parameter parsing and name mangling for different operator types (infix, prefix, and mixed unary/infix). The change includes a new test file `test/method_operators.wren` that validates all supported operator overloads including arithmetic, comparison, and prefix operators.
The call function in compiler.c no longer supports multi-part mixfix method names like "foo.bar(arg) else { block } last". Instead, it now only builds a simple method name from the consumed token and adds spaces for argument count overloading. The loop that iterated over multiple name parts has been replaced with a single name extraction followed by optional parenthesized argument parsing.
Add two design documents exploring language semantics:
- `beta-style inner.txt` outlines a dispatch mechanism for `inner` method calls
using a two-list approach with method bodies and inheritance chain tracking
- `receiver-less calls.txt` analyzes implicit receiver resolution for bare
function calls, proposing they resolve to `this` and using leading "." for
top-level module function calls
Implement a new skipBlockComment function in the compiler that handles nested /* */ block comments by tracking a nesting counter. The parser advances through comment characters, incrementing nesting on opening /* and decrementing on closing */. Also add three test files: comment_block.wren verifying inline and nested block comments, comment_block_at_eof.wren for a block comment at end of file without newline, and comment_line_at_eof.wren for a line comment at end of file without newline.
Add support for class inheritance in the compiler by parsing the 'is' keyword to load a superclass and emit a CODE_SUBCLASS instruction. In the VM, extend newClass to accept a superclass parameter, copy inherited methods from the superclass into the new class, and store the superclass pointer in the ObjClass struct. Introduce a root Object class in the core library and set it as the superclass for all built-in types. Add a test file verifying method inheritance and arity-based dispatch.
Implement unary negation for numbers and logical not for booleans, introduce PREC_ASSIGNMENT and PREC_UNARY precedence levels, refactor parse functions to accept allowAssignment parameter, add assignment tests for global/local/chained/error cases, and update if-syntax to support statement branches and assignment in conditions.
Replace manual malloc/free for Obj allocations with GC-managed heap. Add Obj->next linked list, markObj traversal for all object types, and sweep phase in VM. Introduce MAX_PINNED stack for temporary GC roots during compilation. Refactor all object constructors (newBool, newFunction, newClass, newNum, newString) to accept VM pointer and register allocations. Move function constant registration earlier in compiler to ensure GC reachability. Add DEBUG_GC_STRESS and TRACE_MEMORY macros in new common.h header.
Add TOKEN_STATIC keyword to the lexer, replacing the unused TOKEN_META, and extend the method() compiler function with an isStatic parameter. When isStatic is true, emit a new CODE_METACLASS instruction before CODE_METHOD to push the class's metaclass onto the stack, enabling static method dispatch. Also fix a buffer overflow bug in string_plus by allocating one extra byte for the null terminator, and refactor object initialization across vm.c by introducing a shared initObj helper to eliminate repeated type/flag assignments.
Extend the metrics script to scan test/*.wren files, counting test files, TODOs, expectations via EXPECT_PATTERN, non-empty lines, and empty lines. Refactor output to print source and test sections with aligned formatting.
Add support for floating-point number literals in the parser by detecting decimal points with trailing digits in `readNumber()`, and switch the compiler's `number()` function from `strtol` to `strtod` for proper double conversion. Update the `num_abs` primitive to use `fabs()` instead of manual negation. Extend test coverage across arithmetic, comparison, equality, modulus, and string conversion tests with floating-point cases, and add a new test for decimal point at end-of-file error detection.
Add num_mod primitive using fmod from math.h to support the % operator on number types. Register the new primitive in the numClass method table. Include a comprehensive test file covering positive, negative, and left-associative modulo cases, plus a divide-by-zero TODO comment in the existing division test.
Introduce TOKEN_THIS token and `this` keyword parsing in the compiler, enabling the `this` expression for method contexts. Add `isMethod` flag to Compiler struct to track whether the current function is a method, and pass it through `initCompiler`. Implement `this_` parsing function that emits appropriate bytecode or errors when used outside a method. Remove the now-unnecessary `numLocals` field from ObjFn struct in vm.h. Add test cases for `this` at top level (expects error), in a method (valid usage), in a top-level function (expects error), and as a variable name (expects error).
The compiler's storeVariable function was incorrectly emitting CODE_STORE_LOCAL for all variables, including locals that already have their value in the correct stack slot. This change renames storeVariable to defineVariable and adds logic to only emit CODE_STORE_GLOBAL for globals, while for locals it emits CODE_DUP to preserve the value through the subsequent POP. Additionally, the vm's callFunction no longer pre-allocates empty slots for locals, as they are now placed on the stack during compilation. New test files verify duplicate local/parameter detection and correct local variable ordering in block scopes.
Rename the `SymbolTable symbols` field in `VM` struct to `methods` to clarify its purpose for method dispatch, and update all references across `vm.c`, `vm.h`, `primitives.c`, and `compiler.c`. Rename `defineName` to `declareVariable` to better reflect its actual behavior of declaring a variable without defining it. Remove the unused `internSymbol` helper function. Add `clearSymbolTable(&vm->globalSymbols)` to `freeVM` to fix a memory leak. Update `dumpCode` signature to take `VM*` and `ObjFn*` instead of `ObjBlock*`, and display method names via `getSymbolName`. Add `stackStart` field to `CallFrame` replacing `locals` for clearer semantics. Introduce `test/method_arity.wren` to validate method dispatch with up to 10 parameters.
Add TOKEN_IS token and CODE_IS bytecode to support runtime type checking via the `is` keyword. Refactor primitive registration by replacing `registerPrimitives` with `loadCore`, which compiles a core library string to define built-in classes (Bool, Class, Function, Num, Null, String, IO) and then attaches primitive methods to them. Update Primitive typedef to remove unused numArgs parameter, and add findGlobal helper to retrieve globals by name. Include test files for class syntax, class instantiation, and the new `is` operator.
Eliminate all forward declarations and reorder functions so each is defined before its first use, making recursion points explicit. Add semicolon counting to metrics script and include boolean equality test file.
Rename `block` parsing rule to `fn` by adding TOKEN_FN token and function prefix rule, removing the old block prefix from TOKEN_LEFT_BRACE. Update compiler.c to replace `block()` with `function()` and add fn equality primitives (fn_eqeq, fn_bangeq) in primitives.c. Migrate test files: rename block_call.wren to fn_call.wren, block_syntax.wren to fn_syntax.wren, and replace `{ ... }` with `fn { ... }` or `fn expr` syntax. Remove obsolete bool_equality.wren test.
Remove the `// skip: == not implemented yet` comments from both `test/number_to_string.wren` and `test/string_to_string.wren` test files, allowing the previously skipped equality comparison tests to execute and validate the now-functional `==` operator.
Introduce TOKEN_NULL to the token enum and register it as a prefix parse rule that emits CODE_NULL. Implement the null() compiler function to emit the null constant. Extend readName() to recognize the "null" keyword and map it to TOKEN_NULL. Add test files verifying null output, and that null, true, and false cannot be used as variable names.
Implement initial support for `if` expressions in the compiler, including new `TOKEN_IF` and `TOKEN_ELSE` tokens, `CODE_JUMP` and `CODE_JUMP_IF` bytecodes for conditional branching, and a `makeNull()` function in the VM to represent the value returned when an if-condition is false without an else clause. The `emit()` function now returns the index of the emitted bytecode to enable patching jump offsets. Also add a `nullClass` to the VM and a `OBJ_NULL` object type, along with a `dumpCode()` debugging helper and new test files for block syntax and if-expression behavior.
Implement equality and inequality operators across three primitive types in the compiler and runtime. Add `bool_eqeq`/`bool_bangeq`, `num_eqeq`/`num_bangeq`, and `string_eqeq`/`string_bangeq` primitives that return false/true respectively when comparing against incompatible types. Update the parse rule table with `INFIX_OPERATOR` macros for `TOKEN_EQEQ` and `TOKEN_BANGEQ` at `PREC_COMPARISON` precedence. Include test files `bool_equality.wren`, `number_equality.wren`, and `string_equality.wren` covering cross-type comparisons and edge cases.
Remove the `sourceLength` field from the parser and `compile()` signature, switching to null-terminated strings read by `readFile()`. Replace the special `METHOD_CALL` method type with a `block_call` primitive that invokes `callBlock()` on the fiber, and move the `Fiber` and `CallFrame` structs into the public header so primitives can access them. Add a test for block calling via the new primitive.
Add TOKEN_TRUE/TOKEN_FALSE parsing with boolean() prefix rule emitting CODE_TRUE/CODE_FALSE bytecodes. Wire comparison operators <, >, <=, >= as infix rules with PREC_COMPARISON precedence. Implement num_lt, num_gt, num_lte, num_gte primitives returning bool values. Register boolClass with toString primitive and move class initialization into registerPrimitives(). Add OBJ_TRUE/OBJ_FALSE object types with makeBool() helper and AS_BOOL macro. Include test files for bool_toString and number_comparison.
Replace the hand-written recursive descent parsing functions (term, factor, primary) with a table-driven Pratt parser using ParseRule structs. The new implementation introduces a parsePrecedence function that dispatches to prefix and infix parse functions based on token type and precedence levels, enabling cleaner extensibility for future operators. Adds precedence enum (PREC_NONE through PREC_CALL) and ParseRule table mapping token types to their corresponding parse functions and binding power.
Introduce num_toString primitive that converts numeric values to string representation via sprintf with "%g" format, and add AS_NUM and AS_STRING accessor macros to vm.h for cleaner type extraction. Refactor existing numeric and string primitives to use these macros instead of direct struct member access. Include test files for number_toString and string_toString with basic equality checks (skipped due to unimplemented == operator).
The compiler previously required a TOKEN_LINE after each statement in a block,
causing parse failures for files missing a final newline. Changed consume() to
match() with conditional break, and added a test case for no-trailing-newline
files.
Extract main execution logic into runFile() and runRepl() functions, where runRepl() reads input line by line from stdin using a 1024-char buffer, compiles each line into a block, interprets it, and prints the resulting value. Update main() to dispatch to runRepl() when no arguments are given, or to runFile() with a single path argument, with a usage message for invalid argument counts.
Implement parenthesized expression parsing in the primary() function by matching TOKEN_LEFT_PAREN, recursively calling expression(), and consuming TOKEN_RIGHT_PAREN. Add grammar test cases in test/grammar.wren verifying correct operator precedence with parentheses, including nested grouping expressions.
Replace the hardcoded MAX_FILE_SIZE buffer with a dynamically allocated buffer sized to the actual file length. Add a failIf helper function for consistent error reporting with formatted messages, and apply it to handle file open, memory allocation, and read failures with appropriate exit codes. Fix the primitive method call to include the receiver in the argument count.
Bob Nystrom