Implements full PostgreSQL support through the Postgres effect:
- connect(connStr): Connect to PostgreSQL database
- close(conn): Close connection
- execute(conn, sql): Execute INSERT/UPDATE/DELETE, return affected rows
- query(conn, sql): Execute SELECT, return all rows as records
- queryOne(conn, sql): Execute SELECT, return first row as Option
- beginTx(conn): Start transaction
- commit(conn): Commit transaction
- rollback(conn): Rollback transaction
Includes:
- Connection tracking with connection IDs
- Row mapping to Lux records with field access
- Transaction support
- Example: examples/postgres_demo.lux
- Documentation in docs/guide/11-databases.md
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add ErrorCode enum with categorized codes (E01xx parse, E02xx type,
E03xx name, E04xx effect, E05xx pattern, E06xx module, E07xx behavioral)
- Extend Diagnostic struct with error code, expected/actual types, and
secondary spans
- Add format_type_diff() for visual type comparison in error messages
- Add help URLs linking to lux-lang.dev/errors/{code}
- Update typechecker, parser, and interpreter to use error codes
- Categorize errors with specific codes and helpful hints
Error messages now show:
- Error code in header: -- ERROR[E0301] ──
- Clear error category title
- Visual type diff for type mismatches
- Context-aware hints
- "Learn more" URL for documentation
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add String.fromChar, chars, substring, toUpper, toLower, replace,
startsWith, endsWith, join to C backend
- Fix record type alias unification by adding expand_type_alias and
unify_with_env functions
- Update docs to reflect current implementation status
- Clean up outdated roadmap items and fix inconsistencies
- Add comprehensive language comparison document
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Parser and typechecker updates for new features
- Schema evolution refinements
- Type system enhancements
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Auto-discover .lux files for fmt and check commands
- Add --target js flag for JavaScript compilation
- Improve help text for new features
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add full Dom effect: querySelector, createElement, addEventListener,
setAttribute, classList, styles, forms, scrolling, etc.
- Add Html module for type-safe HTML construction (Elm-style)
- Add TEA (The Elm Architecture) runtime for browser apps
- Add view dependency analysis for Svelte-style optimizations
- Support both browser and Node.js environments
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Auto-add .lux_packages/ to module search paths
- Find project root by looking for lux.toml
- Enable importing modules from installed packages
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add magic number system (LUX_RC_MAGIC) to distinguish RC-managed
allocations from static string literals, preventing crashes on decref
- Convert string helpers (trim, lines, split) to use lux_rc_alloc
- Track inline RC temps from effect operations (Process.exec, File.read,
Console.readLine, Http ops, String ops) by creating temp variables
- Implement ownership transfer: when RC temp is bound to a variable,
unregister temp and only track bound variable to avoid double-free
- Result: grapho runs with 0 memory leaks
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Phase 2 of JS backend: implement effect handlers in runtime
Effects added:
- Console: print, readLine, readInt
- Random: int, bool, float
- Time: now, sleep
- Http: get, post, postJson (async with fetch)
Bug fixes:
- Fix if-else with blocks executing both branches (use if-else
statement instead of ternary for branches with statements)
- Fix main function being called twice when top-level let binding
already invokes it
- Fix List module operations incorrectly treated as effect operations
New tests:
- test_js_random_int
- test_js_random_bool
- test_js_random_float
- test_js_time_now
All 19 JS backend tests pass.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add 10 integration tests that compile Lux to JavaScript and verify
correct execution in Node.js:
- test_js_factorial: Recursion and effects
- test_js_fibonacci: Classic recursive algorithm
- test_js_adt_and_pattern_matching: Custom ADTs with match
- test_js_option_type: Built-in Option type handling
- test_js_closures: Closure creation and variable capture
- test_js_higher_order_functions: Functions as values
- test_js_list_operations: List.map, List.foldl
- test_js_pipe_operator: Pipe (|>) operator
- test_js_records: Record literal and field access
- test_js_string_concatenation: String operations
Also fix List module operations being incorrectly treated as effects
by adding special-case handling in EffectOp emission.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Fix unused import std::io::Read in interpreter.rs by using qualified call
- Add #[allow(dead_code)] to CGenError.span (kept for future error reporting)
- Add #[allow(dead_code)] to local_vars field (planned for free variable analysis)
- Add #[allow(dead_code)] to unbox_value and emit_all_scope_cleanup methods
All 263 tests pass.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Benchmarks:
- Add fib, list_ops, primes benchmarks comparing Lux vs Node.js vs Rust
- Lux matches Rust performance and is 8-30x faster than Node.js
- Add docs/benchmarks.md documenting results
LSP improvements:
- Context-aware completions (module access vs general)
- Add List, String, Option, Result, Console, Math method completions
- Add type and builtin completions
- Hover now shows type signatures and documentation for known symbols
- Hover returns formatted markdown with code blocks
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- toString now stores result in temp variable and registers for RC
- String concatenation stores result and registers for RC
- Immediately decref temporary input strings after concat to avoid leaks
- Add is_rc_temp() helper to identify RC temporary variables
This fixes the memory leak where dynamically created strings from
toString() and string concatenation were not being freed.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add runtime counters tracking FBIP reuse vs copy operations:
- lux_fbip_reuse_count: incremented when rc=1 allows in-place mutation
- lux_fbip_copy_count: incremented when rc>1 forces allocation
Output now shows both memory stats and FBIP stats:
[RC] No leaks: 13 allocs, 13 frees
[FBIP] 3 reuses, 0 copies
Rename test_no_fbip.lux to test_ownership_transfer.lux to better
reflect that ownership transfer enables FBIP even with aliases.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
When rc=1 at update sites, mutate in-place instead of allocating new:
List.reverse:
- Swap element pointers in-place instead of creating new list
List.take:
- Truncate list in-place, decref dropped elements
List.drop:
- Shift elements to front in-place, decref dropped elements
List.map:
- Mutate elements in-place, decref old values before storing new
List.filter:
- Filter in-place by shifting kept elements, decref filtered-out elements
All operations check LUX_RC_HEADER(list)->rc == 1 at runtime and
fall back to allocation when rc > 1 (list is shared).
This completes Phase B performance optimizations:
- B1: Last-use optimization (ownership transfer) ✅
- B2: Reuse analysis (FBIP) ✅
- B3: Drop specialization ✅
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Phase B Performance Optimizations:
Drop Specialization:
- Add specialized decref functions: lux_decref_list, lux_decref_closure,
lux_decref_string, lux_decref_boxed
- Inline drop logic eliminates polymorphic dispatch through lux_drop
- Forward type declarations (typedef struct X_s X) for proper C ordering
Ownership Transfer (Last-Use Optimization):
- Track variable types in var_types HashMap for type inference
- When assigning let b = a where a is RC-tracked:
- Unregister source variable from RC cleanup
- Register destination variable instead
- Prevents double-free and eliminates unnecessary incref/decref pairs
Also:
- Fix type inference for variable references in infer_expr_type
- Add is_rc_tracked() and unregister_rc_var() helper functions
- Update REFERENCE_COUNTING.md with Phase B progress
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add escape_c_keyword() to mangle C reserved words (double, int, etc.)
- Implement toString() mapping to lux_int_to_string()
- Add string concatenation detection for BinaryOp::Add using lux_string_concat()
- Add is_string_expr() helper for string expression detection
- Update infer_expr_type() for toString, string concat, and if expressions
- Implement complex conditionals RC handling: use if-statements instead of
ternaries when branches create RC values to avoid allocating unused branches
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add pop_rc_scope_except() to skip decref'ing returned variables
- Block expressions now properly preserve returned RC variables
- Function returns skip cleanup for variables being returned
- Track function return types for call expression type inference
- Function calls returning RC types now register for cleanup
- Fix main() entry point to call main_lux() when present
Test result: [RC] No leaks: 17 allocs, 17 frees
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
ADT values with pointer fields (like recursive Tree types) now properly
manage memory:
- Assign unique type tags (starting at 100) to each ADT type
- Track which ADTs have pointer fields that need cleanup
- Generate lux_drop_adt() function with per-ADT drop logic
- Allocate ADT pointer fields with lux_rc_alloc instead of malloc
- Track ADT variables with pointer fields in scope
- Emit field cleanup code at scope exit (switch on tag, decref fields)
Test results:
- ADT test: [RC] No leaks: 6 allocs, 6 frees
- List test: [RC] No leaks: 31 allocs, 31 frees
- Closure test: [RC] No leaks: 8 allocs, 8 frees
- All 263 tests pass
Remaining: early returns, complex conditionals.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Closures and their environments are now properly reference-counted:
- Allocate closures with lux_rc_alloc(sizeof(LuxClosure), LUX_TAG_CLOSURE)
- Allocate environments with lux_rc_alloc(sizeof(LuxEnv_N), LUX_TAG_ENV)
- Enable Lambda in expr_creates_rc_value() to track closure variables
- Add lux_decref() after List higher-order operations (map, filter, fold,
find, any, all) to clean up inline lambdas
Test results:
- Closure test: [RC] No leaks: 8 allocs, 8 frees
- List RC test: [RC] No leaks: 31 allocs, 31 frees
- All 263 tests pass
Remaining for full memory safety: ADT RC, early returns, conditionals.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add scope tracking for reference-counted variables in the C backend:
- Add RcVariable struct and rc_scopes stack to CBackend
- Track RC variables when assigned in let bindings
- Emit lux_decref() calls when scopes exit (functions, blocks)
- Add memory tracking counters (alloc/free) for leak detection
- Fix List.filter to incref elements before copying (prevents double-free)
- Handle return values by incref/decref to keep them alive through cleanup
The RC system now properly frees memory at scope exit. Verified with
test showing "[RC] No leaks: 28 allocs, 28 frees".
Remaining work: early returns, complex conditionals, closures, ADTs.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Implements Phase 1-3 of the RC system for automatic memory management:
- Add LuxRcHeader with refcount and type tag for all heap objects
- Add lux_rc_alloc, lux_incref, lux_decref, and lux_drop functions
- Update list allocation to use RC (lux_list_new uses lux_rc_alloc)
- List operations (concat, reverse, take, drop) now incref shared elements
- Update boxing functions (box_int, box_bool, box_float) to use RC
- String operations (concat, int_to_string, readLine) return RC strings
- File and HTTP operations return RC-managed strings
The infrastructure is ready for automatic decref insertion at scope exit
(Phase 4) and closure RC (Phase 5) in future work.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Implement HTTP client using POSIX sockets:
- Http.get(url) - GET request
- Http.post(url, body) - POST request
- Http.put(url, body) - PUT request
- Http.delete(url) - DELETE request
Features:
- Self-contained implementation (no libcurl dependency)
- URL parsing for host, port, and path
- HTTP/1.1 protocol with Connection: close
- Response body extraction
All Http operations use evidence passing for handler customization.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
New effects with evidence passing support:
Random effect:
- int(min, max) - random integer in range
- float() - random float 0-1
- bool() - random boolean
Time effect:
- now() - milliseconds since epoch
- sleep(ms) - pause execution
File effect:
- read(path) - read file contents
- write(path, content) - write file
- append(path, content) - append to file
- exists(path) - check if file exists
- delete(path) - delete file
- isDir(path) - check if directory
- mkdir(path) - create directory
Also fixed:
- Function calls as statements now properly emit in generated C
- Return type inference for all effect operations
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
C backend now fully threads evidence through effectful function calls:
- Track effectful functions via effectful_functions HashSet
- Add has_evidence flag to track context during code generation
- Add LuxEvidence* ev parameter to effectful function signatures
- Transform effect operations to use ev->console->print() when evidence available
- Update function calls to pass evidence (ev or &default_evidence)
- Update main entry point to pass &default_evidence
Generated code now uses zero-cost evidence passing:
void greet_lux(LuxEvidence* ev) {
ev->console->print(ev->console->env, "Hello!");
}
This completes the evidence passing implementation for both interpreter
(O(1) HashMap lookup) and C backend (direct function pointer calls).
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Interpreter changes:
- Add evidence HashMap for O(1) handler lookup instead of O(n) stack search
- Update eval_run to manage evidence when entering/exiting run blocks
- Modify handle_effect to use evidence.get() instead of stack iteration
C backend infrastructure:
- Add handler structs (LuxConsoleHandler, LuxStateHandler, LuxReaderHandler)
- Add LuxEvidence struct containing pointers to all handlers
- Add default handlers that delegate to built-in implementations
- Add Console.readLine built-in implementation
Documentation:
- Create docs/EVIDENCE_PASSING.md explaining design and implementation
- Update docs/C_BACKEND.md with current progress
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Implements full pattern matching with variable binding for the C backend:
- Extract variable bindings from patterns (Var, Constructor, Tuple, Record)
- Infer C types for bound variables using variant field type tracking
- Handle recursive ADTs with pointer fields and heap allocation
- Dereference pointer bindings automatically for value semantics
Key implementation details:
- variant_to_type: Maps variant names to parent type for tag generation
- variant_field_types: Maps (type, variant) to field types for inference
- Recursive type fields use Type* pointers with malloc/memcpy
- Pattern bindings dereference pointers to maintain value semantics
Examples that now work:
- match opt { Some(x) => x, None => 0 }
- match tree { Leaf(n) => n, Node(l, r) => sum(l) + sum(r) }
Updates documentation to reflect C backend progress.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Implement closures/lambdas in the C code generator:
- Add LuxClosure struct (env pointer + function pointer)
- Add ClosureInfo to track closure metadata during generation
- Implement free variable analysis to find captured variables
- Generate environment structs for each lambda's captured vars
- Generate lambda implementation functions
- Support indirect closure calls via function pointer casting
- Track functions returning closures for proper type inference
Example: fn(x) => x + n compiles to a LuxEnv struct holding n,
a lambda_N function taking env + x, and closure allocation code.
Limitations: No memory management (closures leak), types
mostly hardcoded to LuxInt.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Remove Cranelift JIT compiler and expose the existing C backend as the
compilation target. Generated C code can be compiled with GCC/Clang.
Changes:
- Remove cranelift-* dependencies from Cargo.toml
- Delete src/compiler.rs (565 lines of Cranelift code)
- Add compile_to_c() function with -o and --run flags
- Fix C backend name mangling (main -> main_lux) to avoid conflicts
- Update CLI help text and documentation
Usage:
lux compile <file.lux> # Output C to stdout
lux compile <file.lux> -o out.c # Write to file
lux compile <file.lux> --run # Compile and execute
C backend supports: functions, basic types, operators, if/then/else,
records, enums, Console.print. Future work: closures, lists, patterns.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Record equality: add Record case to values_equal in interpreter
- Invalid escapes: error on unknown escape sequences in lexer
- Unknown effects: validate effect names in check_function with suggestions
- Circular types: add DFS cycle detection in check_type_cycles
- Parser: require | for enum variants, enabling proper type alias syntax
All 265 tests pass.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add Test effect with operations: assert, assertEqual, assertNotEqual,
assertTrue, assertFalse, fail
- Implement Test effect handlers in interpreter with TestResults tracking
- Add values_equal method for comparing Value types in tests
- Update lux test command to discover and run test_* functions
- Create example test files: test_math.lux, test_lists.lux
- Add TESTING_DESIGN.md documentation
- Fix AST mismatches in C backend and compiler.rs for compatibility
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Show specific expression type when JIT compilation fails, e.g.:
- "Unsupported in JIT: String literal"
- "Effect operation 'Console.print' - effects are not supported in JIT"
- "ADT constructor 'Success' - algebraic data types are not supported in JIT"
This helps users understand exactly which expression is blocking
JIT compilation instead of a generic "Unsupported expression type".
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add 30 integration tests that verify all examples and projects
parse and type-check correctly
- Add scripts/lint-examples.sh for quick pre-commit validation
- Tests will catch regressions like missing `run ... with {}` syntax
or broken escape sequences
Run with: cargo test example_tests
Or quick check: ./scripts/lint-examples.sh
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Schema Evolution:
- Preserve version info in type resolution (Type::Versioned)
- Track versioned type declarations in typechecker
- Detect version mismatches at compile time (@v1 vs @v2 errors)
- Support @v2+ (at least) and @latest version constraints
- Store migrations for future auto-migration support
- Fix let bindings to preserve declared type annotations
HTTP Server Effect:
- Add HttpServer effect with listen, accept, respond, respondWithHeaders, stop
- Implement blocking request handling via tiny_http
- Request record includes method, path, body, headers
- Add http_server.lux example with routing via pattern matching
- Add type-checking test for HttpServer effect
Tests: 222 passing (up from 217)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add `lux compile <file>` command that compiles and runs Lux code using
the Cranelift JIT compiler. Includes --benchmark flag for timing.
- Add compile_file() function in main.rs
- Add jit_test.lux example with fib(30) + factorial(10)
- Update VISION.md status
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add String.fromChar function to convert Char to String
- Create four stress test projects demonstrating Lux features:
- json-parser: recursive descent parsing with Char handling
- markdown-converter: string manipulation and ADTs
- todo-app: list operations and pattern matching
- mini-interpreter: AST evaluation and environments
- Add comprehensive testing documentation (docs/testing.md)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Neovim improvements:
- Add tree-sitter text objects for functions, types, blocks
- Add folding support
- Enhanced REPL integration (toggle, send line/selection)
- New commands: LuxCheck, LuxReplToggle, LuxSend
- Better keybindings with localleader
VS Code extension:
- Full syntax highlighting with TextMate grammar
- LSP client integration
- 20+ snippets for common patterns
- Commands: run, format, check, REPL
- Keybindings and context menu
Fixes:
- Fix all cargo warnings with #[allow(dead_code)] annotations
- Clean up unused variables
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Show 2 lines of context before and after errors (dimmed)
- Fix guessing_game.lux to be non-interactive for testing
- Use binary search simulation to demonstrate game logic
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add readLine and readInt operations to the Console effect for interactive
input. Create a number guessing game project demonstrating ADTs, pattern
matching, effects, and game state management.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add a JIT compiler using Cranelift that compiles Lux functions to native
machine code. Achieves ~160x speedup over the tree-walking interpreter
(fib(30): 11.59ms JIT vs 1.87s interpreter).
Supports: arithmetic, comparisons, conditionals, let bindings, function
calls, and recursion. Compile time overhead is minimal (~500µs).
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add Http effect for making HTTP requests:
- Http.get(url) - GET request
- Http.post(url, body) - POST with string body
- Http.postJson(url, json) - POST with JSON body
- Http.put(url, body) - PUT request
- Http.delete(url) - DELETE request
Returns Result<HttpResponse, String> where HttpResponse contains
status code, body, and headers.
Includes reqwest dependency with blocking client, OpenSSL support
in flake.nix, and example at examples/http.lux demonstrating
API requests with JSON parsing.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Add comprehensive JSON support via the Json module:
- Parse JSON strings with Json.parse() returning Result<Json, String>
- Stringify with Json.stringify() and Json.prettyPrint()
- Extract values with Json.get(), getIndex(), asString(), asInt(), etc.
- Build JSON with constructors: Json.null(), bool(), int(), string(), array(), object()
- Query with Json.isNull() and Json.keys()
Includes example at examples/json.lux demonstrating building, parsing,
and extracting JSON data with file I/O integration.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Adds two essential effects that enable Lux to interact with the system:
File effect:
- read(path) - Read file contents as string
- write(path, content) - Write string to file
- append(path, content) - Append to file
- exists(path) - Check if file/directory exists
- delete(path) - Delete a file
- readDir(path) - List directory contents
- isDir(path) - Check if path is directory
- mkdir(path) - Create directory (including parents)
Process effect:
- exec(cmd) - Run shell command, return stdout
- execStatus(cmd) - Run command, return exit code
- env(name) - Get environment variable (returns Option)
- args() - Get command line arguments
- exit(code) - Exit program with code
- cwd() - Get current working directory
- setCwd(path) - Change working directory
Also fixes formatter bug with empty handler blocks in `run ... with {}`.
These effects make Lux capable of writing real CLI tools and scripts.
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
