Proposal: Make comptime var convert to runtime var when modified at runtime

[Matceporial]

This also solves #1470, #906 and #7396, while being better at preserving variable semantics

comptime var a = 0;
a += 1;
if (runtime_condition) {
  a += 1;
} else {
  a += 2;
}
a += 1;
comptime {
  a += 1;
}

becomes equivalent to

var a = 1;
if (runtime_condition) {
  a += 1; // this lines makes it become runtime
} else {
  a += 2;
}
a += 1;
comptime {
 a += 1; // error from modifying a runtime var at comptime
         // maybe include reference to the line that made it runtime
}

Essentially, a comptime variable is converted into a runtime var with its last comptime value at the instantiation site if it is modified at runtime.
#7396 becomes the same as closing over a runtime var.

[SpexGuy]

How does this interact with pointers and addressof (&)?

[Matceporial]

How does this interact with pointers and addressof (&)?

Should be same as storing into runtime variable and using that. Maybe we can add some special cases for pointers (e.g convert to const ptr when out of scope), maybe not

[ghost]

I'm not sure I see the benefit of this. Throwing an error when a comptime var is modified at runtime looks like reasonable behavior to me. Why would we want to silently throw out the comptime annotation instead? Actually, what would be the point of making a variable comptime at all?

[Matceporial]

I'm not sure I see the benefit of this. Throwing an error when a comptime var is modified at runtime looks like reasonable behavior to me. Why would we want to silently throw out the comptime annotation instead? Actually, what would be the point of making a variable comptime at all?

The comptime annotation is not thrown out, the variable is comptime until it is runtime modified, that is it can do comptime work until the first run-time modification to it, so the point of it being comptime remains until you try to modify it at runtime. The point of placing the last comptime value at the instantiation site is for scoping runtime access to it the same way as for runtime variables, rather than the current situation of closing over it (#7396) in a broken way.

[SpexGuy]

So what would this program do?

const std = @import("std");
pub fn main() void {
  var x: u32 = 0;
  const px = &x; // x is not yet modified, what does this point to?
  if (runtime_cond) x += 1; // conditionally modify x
  const px2 = &x; // x is definitely runtime now
  std.debug.print("ptrs_eql={}, vals_eql={}\n", .{ px == px2, px.* == px2.* });
}

[ghost]

@Matceporial
Thanks for the explanation. I missed the "with the last comptime value" part.

Edit: But my other point still stands: With this change, what is the point of a comptime annotation for vars? In principle, all vars could be comptime until they become runtime.

[Jarred-Sumner]

Personally, when I explicitly use comptime, I want it to error if it cannot be comptime – the intent is to ensure the code does not execute at runtime.