compiler: add error for unnecessary use of 'var'

[mlugg]

Depends on #18006, which corrects some unnecessary uses of var in Aro.

This PR implements #224. The compile error is emitted when a var is never used as an lvalue - more detailed analysis is unfortunately not possible under Zig's current analysis model, as whether a var is actually mutated may depend on semantic analysis where conditional compilation may incorrect affect the answer.

Despite how limited this analysis is, the change identified around 1000 incorrect uses across the standard library and compiler, which have been manually corrected. It also led to me catching a few bugs in std, and one in the compiler - these have been fixed, aside from one in std which I wasn't sure of the correct solution for, so a temporary @compileError has been put in place to point out the issue. (This shows the usefulness of the error!)

Since the analysis is simply based on whether a variable is ever used as an lvalue, there is a quite convenient way to silence this error when needed: _ = &x. This is kind of a dirty secret, and should ideally never be used in user code, but it's useful in the test cases and behavior tests, where we sometimes want to force values to be semantically runtime-known.

The actual implementation of this change is fairly trivial - the bulk of this PR is spent fixing the entire codebase to not trigger this error.

[andrewrk]

Great work! I'm very happy about this change. I've been letting contributions slide that make this mistake knowing that the compiler would solve the problem eventually. Thanks for going through and making the fixes.

[andrewrk]

Oops forgot to mark as approved

[IntegratedQuantum]

More tautological cases you missed in math/big_int_test.zig

[InKryption]

A small issue I've just encountered with this change is that unlike with _ = x;, _ = &x; doesn't become an error after it becomes unnecessary. If _ = &x; is to become the official way to allow unused mutability, then it should probably be recognized as unnecessary as well.

[Atomk]

In my opinion _ = &x; looks a bit too much like a hack to be the "official" way to do it, maybe something like a @forceRuntimeKnown that can only be used in tests would help to clarify the intent.

[andrewrk]

The official way is to fix your code. Don't work around the error.

[mlugg]

The workaround has the following uses:

• working around compiler bugs where making something const triggers the bug
• writing tests for the compiler itself (behavior tests or test cases)
• writing std tests where you absolutely need to force a value to be runtime-known; this came up in bigint tests and a small handful of other places

This means that outside of the compiler codebase, there is pretty much no use in it.

Also note: currently, translate-c emits _ = &x discards all over the place to avoid triggering the error, but I hope that eventually we can instead internally give the translate-c output to zig fmt --autofix, so things just become const (which is the simple, correct, readable solution).

[linusg]

This has a limitation that I'd assume to be quite common as it applies to built-ins like @memset() and many C APIs:

fn foo(ptr: *usize) void {
    ptr.* = 42;
}

fn main() void {
    const s: struct { i: usize = 0 } = .{};
    var i = &s.i; // error: local variable is never mutated
    foo(i);
}

[andrewrk]

The compiler is correct; the code is wrong. It should be const not var.

[linusg]

That doesn't build either (0.12.0-dev.1676+40b8c993f):

file.zig:8:9: error: expected type '*usize', found '*const usize'
    foo(i);

[Snektron]

You mean to write

fn foo(ptr: *usize) void {
    ptr.* = 42;
}

fn main() void {
    var s: struct { i: usize = 0 } = .{};
    const i = &s.i;
    foo(i);
}