Fix Compiler should explain why implicit conversion to mutable fails

Author: abulgit

compiler/src/dmd/dcast.d

@@ -149,6 +149,23 @@ Expression implicitCastTo(Expression e, Scope* sc, Type t)
                 //type = type.typeSemantic(loc, sc);
                 //printf("type %s t %s\n", type.deco, t.deco);
                 auto ts = toAutoQualChars(e.type, t);
+                
+                // Special case for improved diagnostic when const to mutable conversion 
+                // fails due to struct having pointers
+                if (e.type.ty == Tstruct && t.ty == Tstruct && 
+                    e.type.isTypeStruct().sym == t.isTypeStruct().sym &&
+                    e.type.mod == MODFlags.const_ && t.mod == 0)
+                {
+                    auto sym = e.type.isTypeStruct().sym;
+                    sym.determineTypeProperties();
+                    if (sym.hasPointerField)
+                    {
+                        error(e.loc, "cannot implicitly convert expression `%s` of type `%s` to `%s` because struct `%s` contains pointers or references",
+                            e.toErrMsg(), ts[0], ts[1], sym.toChars());
+                        return ErrorExp.get();
+                    }
+                }
+                
                 error(e.loc, "cannot implicitly convert expression `%s` of type `%s` to `%s`",
                     e.toErrMsg(), ts[0], ts[1]);
             }

compiler/test/fail_compilation/fix20318.d

@@ -0,0 +1,46 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/fix20318.d(16): Error: cannot implicitly convert expression `c` of type `const(Bar)` to `Bar` because struct `Bar` contains pointers or references
+fail_compilation/fix20318.d(20): Error: cannot implicitly convert expression `complex_c` of type `const(ComplexBar)` to `ComplexBar` because struct `ComplexBar` contains pointers or references
+---
+*/
+
+void main() {
+    // This should work - struct without pointers
+    const Foo a;
+    Foo b = a; // This is okay
+    
+    // This should fail with improved diagnostic message
+    const Bar c;
+    Bar d = c; // Error with improved diagnostic message
+    
+    // Test with a more complex struct with nested pointers
+    const ComplexBar complex_c;
+    ComplexBar complex_d = complex_c; // Give improved error message
+}
+
+struct Foo {
+    int value;
+}
+
+struct Bar {
+    void* ptr;
+}
+
+// Simple struct without pointers
+struct Simple {
+    int value;
+}
+
+// Struct with a pointer
+struct WithPointer {
+    int* ptr;
+}
+
+// Complex struct that contains another struct with pointers
+struct ComplexBar {
+    Simple simple;       // This is fine
+    int data;            // This is fine
+    WithPointer nested;  // This field prevents implicit conversion
+}