Speculatively call copy constructor when returning in foreach

Author: limepoutine

compiler/src/dmd/funcsem.d

@@ -1687,6 +1687,15 @@ extern (D) void declareThis(FuncDeclaration fd, Scope* sc)
     fd.vthis.parent = fd;
     if (ad)
         fd.objc.selectorParameter = .objc.createSelectorParameter(fd, sc);
+
+    if (fd.fes && !fd.vthis._scope)
+    {
+        /* If foreach nested function, save the scope to allow outer semantic
+         * to access internal context pointer.
+         */
+        fd.vthis._scope = sc.copy();
+        fd.vthis._scope.setNoFree();
+    }
 }
 
 /****************************************************

compiler/src/dmd/semantic3.d

@@ -975,7 +975,14 @@ private extern(C++) final class Semantic3Visitor : Visitor
 
                         if (funcdecl.vresult)
                         {
-                            Scope* scret = rs.fesFunc ? rs.fesFunc._scope : sc2;
+                            Scope* scret = sc2;
+
+                            if (rs.fesFunc)
+                            {
+                                // Borrow context pointer's scope for vresult.
+                                assert(rs.fesFunc.vthis);
+                                scret = rs.fesFunc.vthis._scope;
+                            }
 
                             // Create: return (vresult = exp, vresult);
                             exp = new ConstructExp(rs.loc, funcdecl.vresult, exp);

compiler/src/dmd/statementsem.d

@@ -2774,6 +2774,21 @@ Statement statementSemanticVisit(Statement s, Scope* sc)
                  *    return x; return 3;  // ok, x can be a value
                  */
             }
+
+            if (rs.fesFunc &&
+                (!tf.isRef || (fd.storage_class & STC.auto_)))
+            {
+                /* In foreach inside non-ref or auto ref functions,
+                 * invoke copy/move constructor but ignore errors.
+                 * This relaxes attributes for the nested function and
+                 * allows semantic3 to generate the copy.
+                 * If the parent's attributes reject such a copy,
+                 * semantic3 would still error out.
+                 */
+                const olderrors = global.startGagging();
+                doCopyOrMove(sc, rs.exp, rs.exp.type, false, true);
+                global.endGagging(olderrors);
+            }
         }
         else
         {

compiler/test/fail_compilation/issue22666.d

@@ -0,0 +1,35 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/issue22666.d(25): Error: function `issue22666.V4.opApply(int delegate(Object) @safe dg)` is not callable using argument types `(int delegate(Object _) nothrow @system)`
+fail_compilation/issue22666.d(25):        cannot pass argument `int(Object _) => s` of type `int delegate(Object _) nothrow @system` to parameter `int delegate(Object) @safe dg`
+
+---
+*/
+struct S4
+{
+    this(ref inout S4) @system {}
+}
+
+struct V4
+{
+    int opApply(int delegate(Object) @safe dg)
+    {
+        return dg(null);
+    }
+}
+
+S4 h4()
+{
+    S4 s = S4();
+    foreach (_; V4())
+    {
+        return s;
+    }
+    return S4();
+}
+
+void main()
+{
+    h4();
+}

compiler/test/runnable/issue22639.d

@@ -0,0 +1,35 @@
+// REQUIRED_ARGS: -betterC
+
+struct Arr(T, int CAPACITY)
+{
+    int count = 0;
+    T[CAPACITY] items;
+    int opApply(scope int delegate(T) dg)
+    {
+        int result;
+        for (int i = 0; i < count; i++)
+            if ((result = dg(items[i])) != 0)
+                break;
+        return result;
+    }
+}
+
+struct Foo {}
+struct Bar {
+    Arr!(Foo*, 32) array;
+    Foo* get()
+    {
+        foreach(Foo* it; array)
+        {
+            return it;
+        }
+        return null;
+    }
+}
+
+Foo* foo;
+Bar bar;
+extern(C) void main()
+{
+    foo = bar.get();
+}