[dev-dami]

Summary

Track is now self-hosting. trackc (compiler/src/) is written entirely in Track and compiles itself to a fixed point: the Rust-built and Track-built compilers emit byte-identical C (20,125 lines), and the stage 2 and stage 3 executables are byte-identical.

Self-hosted compiler

• Lexer, full-grammar parser, whole-program module loader, ownership checker (same rules as src/checker/), and a portable C99 backend.
• CLI: trackc build | run | check | emit-c | tokens | --version, with error[Exxxx] diagnostics and source frames.
• runtime/track_runtime.c: one word-ABI runtime shared by both compilers (embedded into trackc by scripts/embed_runtime.sh).

Bugs fixed in the Rust compiler

• Cranelift backend moved to a uniform 64-bit word ABI (cross-module bool returns had garbage upper bits; C int results lost their sign).
• argv never reached os_args_count/os_arg.
• &&/|| were bitwise and didn't short-circuit.
• return inside match arms / while bodies / nested ifs panicked the backend.
• if/match values, dangling returned tuples, pointer-compared string patterns, lost union payloads, ignored enum discriminants.
• Cross-module constants compiled to 0; constants used before declaration were rejected.
• Block bindings leaked into the enclosing scope; let mut leaked across functions; assignment to undeclared variables was accepted.
• Vec/math_* runtime ABI bugs; O(n) str_substr/str_char_at; open-ended slices failed to parse.
• yard reused stale objects after compiler changes or imported-constant changes.

New language support (both compilers)

• Structs (literals, field read/update, struct patterns) and bounds-checked arrays with slicing and array_len.

Verification

• scripts/bootstrap.sh: stage 0 → 3 with the fixed-point gate (now in CI).
• tests/selfhost_tests.rs: fixed point, example parity (stdout + exit code), 29 shared accept/reject verdicts, diagnostic frames, native suite under trackc.
• tests/codegen_semantics_tests.rs: run-and-compare regressions for each backend fix.
• Locally: 115 Rust tests pass, yard test passes, cargo clippy -- -D warnings and cargo fmt --check clean.

Known limitations

• Stage 0 still needs the Rust compiler; yard, the track CLI, and the LSP remain in Rust.
• Neither compiler frees linear values at scope exit yet (docs corrected; on the roadmap).
• Verified on Linux x86-64 only.

See docs/bootstrap.md and CHANGELOG.md.

---

Generated by Claude Code

Summary by CodeRabbit

• New Features

  • Released Track 1.0 with a self-hosted compiler that can check programs, emit C, build executables, and run programs.
  • Added support for structs and fixed-length arrays, including field access, pattern matching, indexing, and slicing.
  • Added a shared runtime with bounds-checked arrays and expanded process, file, string, and networking capabilities.
  • Improved compiler diagnostics and ownership and mutability checks.

• Documentation

  • Updated the language specification, examples, and guides for Track 1.0, compiler commands, runtime behavior, and bootstrap verification.

• Bug Fixes

  • Improved compiler behavior for control flow, values, and array bounds; added broader compiler and runtime verification.

[coderabbitai]

Caution

Review failed

The pull request is closed.

Walkthrough

The change adds a Track-written compiler with a full frontend, ownership checker, C backend, and command-line interface. It adds a shared C runtime and bootstrap verification. The Rust compiler, tests, release metadata, examples, and documentation are updated for version 1.0.0 and the compiler changes.

Changes: Track compiler and runtime

Layer / File(s)	Summary
Native compiler frontend compiler/src/base.trk, compiler/src/ast.trk, compiler/src/lexer.trk, compiler/src/parser.trk, compiler/tests/*	The Track compiler adds shared context utilities, a node-pool AST, a token-based lexer, and a recursive-descent parser. Native tests cover lexer, parser, AST, and backend behavior.
Module loading and program checking compiler/src/loader.trk, compiler/src/symbols.trk, compiler/src/checker.trk	The compiler loads modules, collects symbols, and checks ownership, borrowing, types, assignments, and control flow.
Shared runtime and native C backend runtime/track_runtime.c, compiler/src/runtime_c.trk, compiler/src/cgen.trk, scripts/embed_runtime.sh	A C runtime provides process, memory, I/O, collection, array, and socket functions. The Track backend emits C for functions, control flow, patterns, structs, arrays, tuples, and runtime calls.
Compiler commands and bootstrap compiler/src/main.trk, scripts/bootstrap.sh, .github/workflows/ci.yml, .gitignore	The trackc CLI adds check, build, run, C-emission, token-dump, help, and version commands. The bootstrap script builds three compiler stages and compares generated C and executables. CI checks compiler sources and the bootstrapped version.
Rust compiler checker metadata src/ast/mod.rs, src/checker/mod.rs	The Rust compiler adds struct expressions, stores type metadata for code generation, checks struct fields, and tracks mutability across scopes and control flow.
Rust compiler backend and integration src/codegen/mod.rs, src/lib.rs, src/mono.rs, src/parser/*, src/yard/builder.rs, tests/codegen_semantics_tests.rs	The Rust backend uses a word ABI and adds code generation for structs, arrays, unions, and tuple returns. The compiler passes checker metadata to code generation, updates parsing and source traversal, and fingerprints package inputs for build caching. Runtime tests cover execution results and bounds-checked array access.
Release, documentation, and parity tests Cargo.toml, compiler/Track.toml, CHANGELOG.md, README.md, SPEC.md, docs/*, examples/*, tests/*	Release metadata and documentation describe version 1.0.0, runtime and language behavior, and bootstrap stages. Tests compare host and self-hosted compiler results, diagnostics, and bootstrap outputs. Examples demonstrate slice, struct, and array operations.

Estimated code review effort: 5 (Critical) | ~120 minutes

Change: Feature

Sequence Diagram(s)

sequenceDiagram
  participant User
  participant Trackc as trackc CLI
  participant FrontEnd as front_end
  participant Loader as load_program
  participant Parser as parse_file
  participant Checker as check_program
  participant Backend as generate_c
  participant Runtime as runtime_source
  User->>Trackc: run build or emit-c
  Trackc->>FrontEnd: compile source path
  FrontEnd->>Loader: load root and imported modules
  Loader->>Parser: parse each source file
  FrontEnd->>Checker: collect symbols and check program
  Trackc->>Backend: generate C from checked context
  Backend->>Runtime: include runtime implementation

Loading

Merge Risk: High · up to da1ee

The new compiler can silently miscompile valid programs, producing dangling tuple pointers, unchecked struct field access that can corrupt memory, constants read as 0, and wrong array iteration. These should be fixed before merge, or the limitations explicitly accepted.

Finishing Touches

📝 Generate docstrings

• Commit to this branch
• Create a new PR

🧪 Generate unit tests (beta)

• Commit to this branch
• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}