writeln doesn't support printing bit-fields

[ibuclaw]

import std.stdio;
struct S
{
    ubyte a : 4;
    ubyte b : 4;
}

void main()
{
    S s = S(8, 15);
    writeln(s);
}

prints

S(#{overlap a, b})

[ibuclaw]

The lazy fix would be:

--- a/std/format/internal/write.d
+++ b/std/format/internal/write.d
@@ -2546,7 +2546,7 @@ if ((is(T == struct) || is(T == union)) && (hasToString!(T, Char) || !is(Builtin
             {
                 // ignore hidden context pointer
             }
-            else static if (0 < i && T.tupleof[i-1].offsetof == T.tupleof[i].offsetof)
+            else static if (0 < i && T.tupleof[i-1].offsetof == T.tupleof[i].offsetof && !__traits(isBitfield, T.tupleof[i]))
             {
                 static if (i == T.tupleof.length - 1 || T.tupleof[i].offsetof != T.tupleof[i+1].offsetof)
                 {
@@ -2559,7 +2559,7 @@ if ((is(T == struct) || is(T == union)) && (hasToString!(T, Char) || !is(Builtin
                     put(w, el);
                 }
             }
-            else static if (i+1 < T.tupleof.length && T.tupleof[i].offsetof == T.tupleof[i+1].offsetof)
+            else static if (i+1 < T.tupleof.length && T.tupleof[i].offsetof == T.tupleof[i+1].offsetof && !__traits(isBitfield, T.tupleof[i]))
             {
                 enum el = (i > 0 ? separator : "") ~ "#{overlap " ~ __traits(identifier, T.tupleof[i]);
                 put(w, el);

However this is incorrect. Bit-fields can be overlapping other fields/bit-fields too. So it requires a bit more special handling.

[crazymonkyyy]

...
void mywrite(T)(T t){
	static if(is(T==struct)){
		mywrite(__traits(identifier,T),'(');
		static foreach(I,A;T.tupleof){
			__traits(getMember,t,A.stringof).mywrite;
			static if(I!=T.tupleof.length-1){
				mywrite(", ");
		}}
		mywrite(')');
	}
...

import std;
struct foo{
	bool iscircle:1;
	uint rest:31;
}
struct bar{
	bool iscircle;
	uint rest;
}
enum shape{none,circle,rect,square}
struct foobar{
	shape myshape:2;
	uint i:30;
	foo[3] myfoos;
	bar[3] mybars;
}

foobar().mywriteln; => foobar(none, 0, [foo(false, 0),foo(false, 0),foo(false, 0)], [bar(false, 0),bar(false, 0),bar(false, 0)])

it should just work naturally with if you undo whatever damage in write struct handling; maybe thats old work around code; try just deleting that chunk of code

phobos/std/format/internal/write.d

Line 2558 in 205256a

else static if (i+1 < T.tupleof.length && T.tupleof[i].offsetof == T.tupleof[i+1].offsetof)

[ibuclaw]

it should just work naturally with if you undo whatever damage in write struct handling; maybe thats old work around code; try just deleting that chunk of code

No, it's still relevant, for example:

struct S
{
    union {
        string a;
        int b;
    }
}

S s = S(b:123)
s.writeln();

I think your custom "write" function would segfault on this.

The same applies - and is further complicated by - bitfields.

struct S
{
    union {
        string a;
        struct {
            int b : 16;
            int c : 16;
        }
    }
}