Proposal: Allow aligned zero-size pointers

[SpexGuy]

Zero-sized pointers are really inconsistent about alignment.

// compiles
[]void, []align(0) void, []align(4) void, []align(@alignOf(void)) void
comptime { const x = @alignOf(void); }

// doesn't compile
var x: u29 = @alignOf(void);
var y: u29 = @typeInfo([]void).Pointer.alignment;
[]align(@compileError("")) void

fn slice(comptime ment: u29) type { return []align(ment) void; }
slice(@alignOf(void));

// crashes compiler
_ = ([]align(2) void == []align(4) void);

I see two ways to resolve this:

• never allow alignment on zero-sized types
• define default alignment on zero-sized types and allow it always

Never allowing alignment causes a lot of special cases for zero sized types. So I think we should standardize alignment. In all places, we have the invariant that @alignOf(T) <= @sizeOf(T). This means the only valid alignment for zero-sized types is 0. Which kind of makes sense, you could argue that they are bit packed. Defining the alignment this way isn't perfect but definitely cuts down on the number of special cases with zero-sized types.

[daurnimator]

Alignment of types can be user defined; it's our definition of @sizeOf which is a bit weird: it's defined as the size the type takes in an array. i.e. max(ceil(@bitSizeOf(T)/8), @alignOf(T)).

You can create a small object with large alignment with e.g.

const Foo = struct {
   x: u32 align(4096),
};
pub fn main() !void {
  const f = Foo{.x=2};
  std.debug.print("align={}, size={}, {}\n", .{@alignOf(Foo), @sizeOf(Foo), f});
}

You'll see

align=4096, size=4096, Foo{ .x = 2 }

See also #4016

[marler8997]

I suggest the invariant @alignOf(T) >= 1. By forbidding @alignOf from being 0, you're able to use the alignment in more mathematical expressions without having a special case for 0. Using this invariant, the alignment of all 0 sized types would be 1. I think this makes things simple.

[SpexGuy]

In #6706 it was decided that pointers to zero-sized types should actually be pointers, so I'm closing this issue. However I think there's a case to be made that the abi alignment of zero sized types should be 1 instead of 0, so I've opened #7221 to continue that discussion.