Fix Issue 22384 - Add support for default values in C-style bitfields

This implements parsing, semantic analysis, and backend support for default initializers in bitfields.

- Modified 'declaration.d' & 'parse.d' to parse assignment expressions after bitfield width.
- Implemented semantic cheks in 'semantic2.d' using IntRange for bound
  validation.
- Updated 'todt.d' to pack default values into the binary representation.
- Added regression tests.

Author: MadhurKumar004

compiler/src/dmd/declaration.d

@@ -663,9 +663,9 @@ extern (C++) class BitFieldDeclaration : VarDeclaration
     uint fieldWidth;
     uint bitOffset;
 
-    final extern (D) this(Loc loc, Type type, Identifier ident, Expression width)
+    final extern (D) this(Loc loc, Type type, Identifier ident, Expression width, Initializer _init = null)
     {
-        super(loc, type, ident, null);
+        super(loc, type, ident, _init);
         this.dsym = DSYM.bitFieldDeclaration;
         this.width = width;
         this.storage_class |= STC.field;
@@ -675,7 +675,7 @@ extern (C++) class BitFieldDeclaration : VarDeclaration
     {
         //printf("BitFieldDeclaration::syntaxCopy(%s)\n", toChars());
         assert(!s);
-        auto bf = new BitFieldDeclaration(loc, type ? type.syntaxCopy() : null, ident, width.syntaxCopy());
+        auto bf = new BitFieldDeclaration(loc, type ? type.syntaxCopy() : null, ident, width.syntaxCopy(), _init ? _init.syntaxCopy() : null);
         bf.comment = comment;
         return bf;
     }

compiler/src/dmd/glue/todt.d

@@ -1002,13 +1002,32 @@ private void membersToDt(AggregateDeclaration ad, ref DtBuilder dtb,
                 auto value = ie.getInteger();
                 const width = bf.fieldWidth;
                 const mask = (1L << width) - 1;
-                bitFieldValue = (bitFieldValue & ~(mask << bitOffset)) | ((value & mask) << bitOffset);
+                bitFieldValue = (bitFieldValue & ~(mask << bf.bitOffset)) | ((value & mask) << bf.bitOffset);
                 //printf("bitFieldValue x%llx\n", bitFieldValue);
             }
             else
                 Expression_toDt(e, dtbx);    // convert e to an initializer dt
         }
-        else if (!bf)
+        else if (bf)
+        {
+            if (Initializer init = vd._init)
+            {
+                if (init.isVoidInitializer())
+                    continue;
+
+                assert(vd.semanticRun >= PASS.semantic2done);
+                auto ei = init.isExpInitializer();
+                assert(ei); 
+                auto ie = ei.exp.isIntegerExp();
+                assert(ie);
+
+                auto value = ie.getInteger();
+                const width = bf.fieldWidth;
+                const mask = (1L << width) - 1;
+                bitFieldValue = (bitFieldValue & ~(mask << bf.bitOffset)) | ((value & mask) << bf.bitOffset);
+            }
+        }
+        else
         {
             if (Initializer init = vd._init)
             {

compiler/src/dmd/parse.d

@@ -4792,11 +4792,9 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
                 AST.Dsymbol s;
                 if (width)
                 {
-                    if (_init)
-                        error("initializer not allowed for bitfield declaration");
                     if (storage_class)
                         error("storage class not allowed for bitfield declaration");
-                    s = new AST.BitFieldDeclaration(width.loc, t, ident, width);
+                    s = new AST.BitFieldDeclaration(width.loc, t, ident, width, _init);
                 }
                 else
                 {

compiler/src/dmd/semantic2.d

@@ -53,6 +53,7 @@ import dmd.nogc;
 import dmd.nspace;
 import dmd.objc;
 import dmd.opover;
+import dmd.optimize;
 import dmd.parse;
 import dmd.root.filename;
 import dmd.common.outbuffer;
@@ -320,6 +321,41 @@ private extern(C++) final class Semantic2Visitor : Visitor
         vd.semanticRun = PASS.semantic2done;
     }
 
+    override void visit(BitFieldDeclaration bfd)
+    {
+        visit(cast(VarDeclaration)bfd);
+        if (bfd.semanticRun != PASS.semantic2done)
+            return;
+
+        if (!bfd._init)
+            return;
+
+        auto ei = bfd._init.isExpInitializer();
+        if (!ei)
+            return;
+
+        ei.exp = ei.exp.optimize(WANTvalue);
+        auto e = ei.exp;
+        if (!e.isIntegerExp())
+            return;
+
+        import dmd.intrange;
+        auto value = getIntRange(e);
+
+        const bool isUnsigned = bfd.type.isUnsigned();
+        auto bounds = IntRange(
+            SignExtendedNumber(bfd.getMinMax(Id.min), !isUnsigned),
+            SignExtendedNumber(bfd.getMinMax(Id.max), false)
+        );
+
+        if (!bounds.contains(value))
+        {
+            const uwidth = bfd.fieldWidth;
+            error(bfd.loc, "bitfield initializer `%s` does not fit in %d bit%s",
+                e.toChars(), cast(int) uwidth, uwidth == 1 ? "".ptr : "s".ptr);
+        }
+    }
+
     override void visit(Module mod)
     {
         //printf("Module::semantic2('%s'): parent = %p\n", toChars(), parent);

compiler/test/fail_compilation/fail22384.d

@@ -0,0 +1,9 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/fail22384.d(8): Error: bitfield initializer `4294967295u` does not fit in 4 bits
+---
+*/
+struct S {
+    uint d : 4 = -1;
+}

compiler/test/runnable/test22384.d

@@ -0,0 +1,49 @@
+//https://github.com/dlang/dmd/issues/22384
+struct S
+{
+    int a = 1;
+    int b : 16 = 2;
+    int c : 16 = 3;
+    int d = 4;
+}
+
+struct T
+{
+    int a = 1;       // .long 1
+    int b : 4 = 2;   // .byte 0x32 (b=2, c=3 merged)
+    int c : 4 = 3;
+    int d : 8 = 4;   // .byte 0x04
+    int e : 4 = 5;   // .byte 0x65 (e=5, f_low=6 merged)
+    int f : 12 = 6;  // .byte 0x00 (f_high)
+    int g = 7;       // .long 7
+}
+
+struct M
+{
+    int a : 4 = 1;
+    int   : 4;
+    int b : 4 = 2;
+}
+
+S s;
+T t;
+M m;
+
+void main()
+{
+    assert(s.a == 1);
+    assert(s.b == 2);
+    assert(s.c == 3);
+    assert(s.d == 4);
+
+    assert(t.a == 1);
+    assert(t.b == 2);
+    assert(t.c == 3);
+    assert(t.d == 4);
+    assert(t.e == 5);
+    assert(t.f == 6);
+    assert(t.g == 7);
+
+    assert(m.a == 1);
+    assert(m.b == 2);
+}