🎉 Blaise v0.11.0 is here!

[graemeg]

This is our biggest release yet — 237 commits since v0.10.0, and easily
the one I'm most excited to share. If v0.10.0 was about making the compiler
self-hosting and fast, v0.11.0 is about making the language comfortable to
write in and bringing the native x86-64 backend up to full parity with QBE.
Let's dig in. 🚀

🏗️ A second backend that's now a first-class citizen

Since its introduction, the native backend was the experimental sibling — handy
for debugging, but QBE did the real work. That's no longer true. This cycle
the native x86-64 backend learned almost everything QBE already knew:

• By-value record parameters and ABI-correct record-by-value returns (sret)
• Property reads/writes through getters and setters, virtual dispatch
• Nested procedures with captured variables, callbacks, is/as/Supports
• Open-array literals, interface/procedural/dynarray params and returns
• Inc/Dec on fields, derefs and var params; full ARC for const-string args
• Floating-point Format() with %f/%e/%g, width and precision

And — the part that proves it — Blaise can now builds itself with the
native backend, and we added a dedicated fixpoint-native.sh that
verifies the native compiler reproduces itself byte-for-byte. Two independent
backends, both reaching a self-hosting fixpoint. 🔁

🔗 Towards a self-contained toolchain

A long-standing goal is a single blaise binary that needs no external
tools. Two big steps landed this cycle:

• A self-assembler (--assembler internal) — the native backend can now
  emit ELF object files directly, no external assembler required.
• Phase A of the internal linker — an ELF object + ar-archive reader and
  a section merger, the foundation for replacing the external cc/ld link
  step entirely.

The linker is a multi-phase journey and it'll be the headline of v0.12.0 — but
the groundwork is in and tested. 🧱

✨ Language features that make day-to-day code nicer

A whole cluster of quality-of-life additions:

🔢 Compile-time constant folding — integer and floating-point, plus
multi-dimensional array constants:

const
  Tau = 3.14159 * 2;          // folded at compile time
  Grid: array[0..1, 0..1] of Integer = ((1, 2), (3, 4));

📐 Static arrays grow up — multi-dimensional, named-constant and expression
bounds, and enum-indexed arrays:

const N = 8;
type
  TColour = (Red, Green, Blue);
var
  Buffer: array[0..N - 1] of Byte;     // expression bound
  Hits: array[TColour] of Integer;     // enum-indexed

🎯 Sets, properly — set of Byte/Boolean, ranges in literals,
subset/superset operators, and "jumbo" sets up to 256 members:

var Digits: set of Byte;
begin
  Digits := [0..9];
  if [1, 2] <= Digits then WriteLn('subset!');   // <= is subset
end;

🪄 Default array properties — Obj[I] sugar, including List[i] on TList<T>:

var List: TList<Integer>;
begin
  List := TList<>.Create();
  List.Add(42);
  WriteLn(List[0]);            // default property — no .Items needed
end;

🧬 inherited Method() in expression position plus implicit integer→float
widening for math builtins:

Total := inherited Sum() + 1;  // inherited as a sub-expression
R := Sqrt(2);                  // Integer widens to float automatically

• 🧩 Generics — method-level type parameters and an out-of-line impl form
• 🌍 UTF-8 niceties — for..in over a string iterates codepoints, plus new
  StrUtils codepoint helpers (with SIMD-accelerated counting under the hood):

var
  CP: Integer;
  B: Byte;
begin
  for CP in 'héllo' do WriteLn(CP);   // iterates Unicode codepoints
  for B in 'héllo' do WriteLn(B);     // iterate Bytes
end;

🛡️ Every variable starts zeroed — guaranteed

This one is a language semantic, not just a feature: Blaise now guarantees
that every variable is zero-initialised before you can read it. Integers start
at 0, floats at 0.0, pointers/classes/interfaces at nil, strings empty, and
records and arrays are recursively zeroed.

var
  Count: Integer;     // 0, always
  Name: string;       // '' , always
  Node: TNode;        // nil, always
begin
  WriteLn(Count);     // prints 0 — never stack garbage
end;

No more "works on my machine" bugs from an uninitialised local. It also closed a
subtle cross-backend gap: the native backend used to leave scalar locals as
stack garbage while QBE zeroed them, so the same program could print different
output depending on the backend. Now both backends behave identically — the
guarantee is part of the language, not an accident of codegen. 🎯

🐞 Hardening, hardening, hardening

This release fixed 116 bugs — the vast majority in codegen and the maturing
native backend. If you hit an edge case with records, interfaces, generics,
dynamic arrays, var parameters or ARC ref-counting in an earlier version,
there's a good chance it's gone now. Integer div/mod by zero now raises a
catchable EDivByZero rather than crashing. 🧯

🔍 Native-first debugging with pdr

The OPDF debug emitter now records exact frame offsets and statement-level
line info from the native backend, with full field drilldown for records,
classes and Self. --debug-opdf binaries link as proper PIE executables, so
debugging under pdr "just works" — and every debug session dogfoods the native
backend we're hardening. 🐧

You can get the pdr (OPDF) debugger from the github project page.

⚡ Faster, too

Hash indexes for TDictionary/TSet/TStringList.Find, overload-group lookup
in the semantic pass, stack buffers for Format/WriteDecimal, and
SIMD-accelerated UTF-8 counting all shaved real time off compile and runtime.

📊 The numbers

• ✅ Self-hosting fixpoint verified on 371,292 lines of QBE IR
• ✅ QBE, native, and internal-assembler fixpoints all green
• ✅ 3,474 tests passing — TDD from day one
• ✅ Both backends self-host independently

🙏 Grab it and let us know

The release is on the GitHub releases page — a single self-contained
Linux x86-64 tarball. See the release changelog for the full technical breakdown.

As always, feedback, bug reports and "I tried to compile this and it broke" are
hugely welcome — that's exactly how this release got so much sturdier. 🛠️

Onwards to v0.12.0 and the internal linker! 🙌

---

Built with ❤ for the Pascal community.