Always make a copy when constructing mutable struct literals

Author: limepoutine

compiler/src/dmd/expressionsem.d

@@ -808,8 +808,7 @@ bool canElideCopy(Expression e, Type to, bool checkMod = true)
         case EXP.dotVariable:
             return visitDotVarExp(e.isDotVarExp());
         case EXP.structLiteral:
-            auto sle = e.isStructLiteralExp();
-            return !(checkMod && sle.useStaticInit && to.isMutable());
+            return true;
         case EXP.variable:
             return (e.isVarExp().var.storage_class & STC.rvalue) != 0;
         default:

compiler/src/dmd/glue/e2ir.d

@@ -465,7 +465,14 @@ elem* addressElem(elem* e, Type t, bool alwaysCopy = false)
         return e;
     }
 
-    if (alwaysCopy || ((*pe).Eoper != OPvar && (*pe).Eoper != OPind))
+    static bool hasAddress(elem* e)
+    {
+        if (e.Eoper == OPeq || e.Eoper == OPstreq)
+            e = e.E1;
+        return e.Eoper == OPvar || e.Eoper == OPind;
+    }
+
+    if (alwaysCopy || !hasAddress(*pe))
     {
         elem* e2 = *pe;
         type* tx;
@@ -6737,36 +6744,37 @@ elem* toElemStructLit(StructLiteralExp sle, ref IRState irs, EXP op, Symbol* sym
         return ep;
     }
 
+    elem* e;
+    // struct symbol to initialize with the literal
+    Symbol* stmp = sym;
+
     if (sle.useStaticInit)
     {
         /* Use the struct declaration's init symbol
          */
-        elem* e = el_var(toInitializer(sle.sd));
+        e = el_var(toInitializer(sle.sd));
         e.ET = Type_toCtype(sle.sd.type);
         elem_setLoc(e, sle.loc);
 
-        if (sym)
+        if (!stmp && sle.type.isMutable())
+            stmp = symbol_genauto(Type_toCtype(sle.sd.type));
+
+        if (stmp)
         {
-            elem* ev = el_var(sym);
+            elem* ev = el_var(stmp);
             if (tybasic(ev.Ety) == TYnptr)
                 ev = el_una(OPind, e.Ety, ev);
             ev.ET = e.ET;
             e = elAssign(ev, e, null, ev.ET);
-
-            //ev = el_var(sym);
-            //ev.ET = e.ET;
-            //e = el_combine(e, ev);
             elem_setLoc(e, sle.loc);
         }
         if (forcetype)
             return Lreinterpret(sle.loc, e, forcetype);
         return e;
     }
 
-    // struct symbol to initialize with the literal
-    Symbol* stmp = sym ? sym : symbol_genauto(Type_toCtype(sle.sd.type));
-
-    elem* e = null;
+    if (!stmp)
+        stmp = symbol_genauto(Type_toCtype(sle.sd.type));
 
     /* If a field has explicit initializer (*sle.elements)[i] != null),
      * any other overlapped fields won't have initializer. It's asserted by

compiler/test/runnable/structlit_rvalue.d

@@ -1,15 +1,67 @@
-void refCounted(ProcessPipes val)
+struct S22585_1
 {
-    val = ProcessPipes.init;
+    char[32] a;
+    int b = 1;
+
+    this(ref S22585_1 s)
+    {
+        s.b = 2;
+    }
+}
+
+struct T22585_1
+{
+    S22585_1 s;
+}
+
+void copyConstruct(S22585_1) {}
+
+void mutate(ref S22585_1 s)
+{
+    s.b = 2;
+}
+
+struct S22585_2
+{
+    char[32] a;
+    int b = 1;
+    ~this() {}
+}
+
+struct T22585_2
+{
+    S22585_2 s;
+}
+
+pragma(inline, true)
+S22585_2 inlinedRvalue1()
+{
+    bool b;
+    return (b ? T22585_2.init : T22585_2.init).s;
+}
+
+void mutateCopyOf(S22585_2 s)
+{
+    s.b = 2;
+}
+
+pragma(inline, true)
+S22585_2 inlinedRvalue2()
+{
+    return S22585_2.init;
 }
 
-struct ProcessPipes
+void assignCopyOf(S22585_2 s)
 {
-    char[33] arr;
-    ~this() @safe {}
+    s = S22585_2.init;
 }
 
 void main()
 {
-    refCounted(ProcessPipes.init);
+    bool b;
+    copyConstruct((b ? T22585_1.init : T22585_1.init).s);
+    mutate((b ? T22585_1.init : T22585_1.init).s);
+    mutateCopyOf(inlinedRvalue1());
+    inlinedRvalue2.b = 2;
+    assignCopyOf(S22585_2.init);
 }