Restart inference of foreach nested functions when lowering returns

limepoutine · limepoutine · commit ae00eb31adac · 2026-03-03T12:24:05.000+08:00
diff --git a/compiler/src/dmd/frontend.h b/compiler/src/dmd/frontend.h
@@ -5024,6 +5024,8 @@ class ForeachStatement final : public Statement
     FuncDeclaration* func;
     Array<Statement* >* cases;
     Array<ScopeStatement* >* gotos;
+    bool hasReturnExp;
+    Statement* lowering;
     ForeachStatement* syntaxCopy() override;
     bool hasBreak() const override;
     bool hasContinue() const override;
diff --git a/compiler/src/dmd/funcsem.d b/compiler/src/dmd/funcsem.d
@@ -370,7 +370,7 @@ public:
             auto catches = new Catches(ctch);
 
             Statement s2 = new TryCatchStatement(Loc.initial, s._body, catches);
-            fd.hasNoEH = false;
+            fd.hasCatches = true;
             replaceCurrent(s2);
             s2.accept(this);
         }
@@ -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();
+    }
 }
 
 /****************************************************
diff --git a/compiler/src/dmd/semantic3.d b/compiler/src/dmd/semantic3.d
@@ -60,6 +60,7 @@ import dmd.opover;
 import dmd.optimize;
 import dmd.parse;
 import dmd.root.filename;
+import dmd.root.aav;
 import dmd.root.array;
 import dmd.common.outbuffer;
 import dmd.root.rmem;
@@ -755,25 +756,10 @@ private extern(C++) final class Semantic3Visitor : Visitor
                  */
                 funcdecl.buildEnsureRequire();
 
-                // Check for errors related to 'nothrow'.
-                const blockexit = funcdecl.fbody.blockExit(funcdecl, f.isNothrow ? global.errorSink : null);
-                if (f.isNothrow && blockexit & BE.throw_)
-                    error(funcdecl.loc, "%s `%s` may throw but is marked as `nothrow`", funcdecl.kind(), funcdecl.toPrettyChars());
-
-                if (!(blockexit & (BE.throw_ | BE.halt) || funcdecl.hasCatches))
-                {
-                    /* Don't generate unwind tables for this function
-                     * https://issues.dlang.org/show_bug.cgi?id=17997
-                     */
-                    funcdecl.hasNoEH = true;
-                }
-
-                if (funcdecl.nothrowInprocess)
-                {
-                    if (funcdecl.type == f)
-                        f = cast(TypeFunction)f.copy();
-                    f.isNothrow = !(blockexit & BE.throw_);
-                }
+                // Tentatively check the flow, ignoring errors.
+                const oldErrors2 = global.startGagging();
+                auto blockexit = funcdecl.fbody.blockExit(funcdecl, null);
+                global.endGagging(oldErrors2);
 
                 if (funcdecl.fbody.isErrorStatement())
                 {
@@ -834,6 +820,8 @@ private extern(C++) final class Semantic3Visitor : Visitor
                     if (funcdecl.vresult || funcdecl.returnLabel)
                         funcdecl.buildResultVar(scout ? scout : sc2, tret);
 
+                    scope flr = new ForeachLambdaRewriter(funcdecl);
+
                     /* Cannot move this loop into NrvoWalker, because
                      * returns[i] may be in the nested delegate for foreach-body.
                      */
@@ -975,7 +963,16 @@ private extern(C++) final class Semantic3Visitor : Visitor
 
                         if (funcdecl.vresult)
                         {
-                            Scope* scret = rs.fesFunc ? rs.fesFunc._scope : sc2;
+                            Scope* scret = sc2;
+
+                            if (rs.fesFunc)
+                            {
+                                flr.restartInference(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);
@@ -991,6 +988,8 @@ private extern(C++) final class Semantic3Visitor : Visitor
                         }
                         rs.exp = exp;
                     }
+
+                    flr.finish();
                 }
                 if (funcdecl.nrvo_var || funcdecl.returnLabel)
                 {
@@ -1000,6 +999,27 @@ private extern(C++) final class Semantic3Visitor : Visitor
                     nw.visitStmt(funcdecl.fbody);
                 }
 
+                // Definitively check for errors related to 'nothrow'.
+                blockexit = funcdecl.fbody.blockExit(funcdecl, f.isNothrow ? global.errorSink : null);
+
+                if (f.isNothrow && blockexit & BE.throw_)
+                    error(funcdecl.loc, "%s `%s` may throw but is marked as `nothrow`", funcdecl.kind(), funcdecl.toPrettyChars());
+
+                if (!(blockexit & (BE.throw_ | BE.halt) || funcdecl.hasCatches))
+                {
+                    /* Don't generate unwind tables for this function
+                     * https://issues.dlang.org/show_bug.cgi?id=17997
+                     */
+                    funcdecl.hasNoEH = true;
+                }
+
+                if (funcdecl.nothrowInprocess)
+                {
+                    if (funcdecl.type == f)
+                        f = cast(TypeFunction)f.copy();
+                    f.isNothrow = !(blockexit & BE.throw_);
+                }
+
                 sc2 = sc2.pop();
             }
 
@@ -1945,3 +1965,133 @@ private void findClosureVars(FuncDeclaration fd, scope void delegate(FuncDeclara
         }
     }
 }
+
+/* Rewrites nested functions generated by foreach statements
+ * that contain returns. Fixes up attributes and runs semantic
+ * on lowered statements.
+ */
+private final class ForeachLambdaRewriter
+{
+    // Parent function
+    FuncDeclaration parent;
+
+    // Set of nested functions pending rewrite
+    AssocArray!(FuncDeclaration, bool) lambdas;
+
+public:
+    this(FuncDeclaration parent)
+    {
+        this.parent = parent;
+    }
+
+    void restartInference(FuncDeclaration fd)
+    {
+        auto tfp = parent.type.isTypeFunction();
+
+        for (; fd && fd.fes; fd = fd.toParent2().isFuncDeclaration())
+        {
+            auto tfl = fd.type.isTypeFunction();
+
+            if (tfp.purity == PURE.impure && tfl.purity > PURE.impure)
+            {
+                tfl.purity = PURE.impure;
+                fd.purityInprocess = true;
+            }
+
+            if (tfp.trust != TRUST.safe && tfl.trust == TRUST.safe)
+                fd.safetyInprocess = true;
+
+            if (!tfp.isNogc && tfl.isNogc)
+                fd.nogcInprocess = true;
+
+            /* Always restart inference of nothrow because new exceptions
+             * can be introduced that are caught by parent function.
+             * However, parent catches should not change whether
+             * a nested function is nothrow.
+             */
+            if (tfl.isNothrow)
+                fd.nothrowInprocess = true;
+
+            lambdas.getLvalue(fd);
+        }
+    }
+
+    void finish()
+    {
+        Array!(FuncDeclarations*) nestLevels;
+
+        /* At this point, AST post-order no longer corresponds to function
+         * nesting depth. Do a counting sort of nesting levels.
+         */
+        foreach (keyValue; lambdas.asRange())
+        {
+            size_t level = 0;
+            for (auto fd = keyValue.key; fd && fd.fes;
+                 fd = fd.toParent2().isFuncDeclaration())
+            {
+                level++;
+            }
+
+            if (level > nestLevels.length)
+            {
+                size_t oldSize = nestLevels.length;
+                nestLevels.setDim(level);
+                foreach (size_t i; oldSize .. level)
+                    nestLevels[i] = new FuncDeclarations();
+            }
+
+            nestLevels[level - 1].push(keyValue.key);
+        }
+
+        foreach_reverse (funcs; nestLevels[])
+        {
+            foreach (fd; (*funcs)[])
+            {
+                // Redo attribute inference, most nested first.
+                auto tf = fd.type.isTypeFunction();
+
+                if (fd.purityInprocess)
+                {
+                    fd.purityInprocess = false;
+                    tf.purity = PURE.fwdref;
+                }
+
+                if (fd.safetyInprocess)
+                    fd.safetyInprocess = false;
+
+                if (fd.nogcInprocess)
+                    fd.nogcInprocess = false;
+
+                if (fd.nothrowInprocess)
+                {
+                    auto blockexit = fd.fbody.blockExit(fd, null);
+
+                    if (blockexit & (BE.throw_ | BE.halt))
+                        fd.hasNoEH = false;
+
+                    fd.nothrowInprocess = false;
+                    tf.isNothrow = !(blockexit & BE.throw_);
+                }
+
+                if (!fd.fes.lowering)
+                    continue;
+
+                // Run semantic on the calling point.
+                Expression* ec;
+                if (auto ss = fd.fes.lowering.isSwitchStatement())
+                    ec = &ss.condition;
+                else if (auto es = fd.fes.lowering.isExpStatement())
+                    if (auto ce = es.exp.isCastExp())
+                        ec = &ce.e1;
+
+                assert(ec, "Unexpected lowering of foreach statement");
+
+                ec.type = null;
+                *ec = expressionSemantic(*ec, fd._scope);
+
+                if (!ec.isErrorExp() && ec.type != Type.tint32)
+                    .error(fd.fes.loc, "`opApply()` function for `%s` must return an `int`", fd.fes.aggr.type.toBasetype().toChars());
+            }
+        }
+    }
+}
diff --git a/compiler/src/dmd/statement.d b/compiler/src/dmd/statement.d
@@ -852,6 +852,9 @@ extern (C++) final class ForeachStatement : Statement
     Statements* cases;          // put breaks, continues, gotos and returns here
     ScopeStatements* gotos;     // forward referenced goto's go here
 
+    bool hasReturnExp;          // has return exp; statement
+    Statement lowering;         // statement we lower to
+
     extern (D) this(Loc loc, TOK op, Parameters* parameters, Expression aggr, Statement _body, Loc endloc) @safe
     {
         super(loc, STMT.Foreach);
diff --git a/compiler/src/dmd/statement.h b/compiler/src/dmd/statement.h
@@ -335,6 +335,9 @@ class ForeachStatement final : public Statement
     Statements *cases;          // put breaks, continues, gotos and returns here
     ScopeStatements *gotos;     // forward referenced goto's go here
 
+    bool hasReturnExp;          // has return exp; statement
+    Statement *lowering;        // statement we lower to
+
     ForeachStatement *syntaxCopy() override;
     bool hasBreak() const override;
     bool hasContinue() const override;
diff --git a/compiler/src/dmd/statementsem.d b/compiler/src/dmd/statementsem.d
@@ -958,6 +958,9 @@ Statement statementSemanticVisit(Statement s, Scope* sc)
                     return null;
             }
 
+            if (fs.hasReturnExp && sc.fes)
+                sc.fes.hasReturnExp = true;
+
             Expression ec;
             switch (tab.ty)
             {
@@ -971,7 +974,15 @@ Statement statementSemanticVisit(Statement s, Scope* sc)
                 return null;
 
             e = Expression.combine(e, ec);
-            return loopReturn(e, fs.cases, loc);
+            Statement lrs = loopReturn(e, fs.cases, loc);
+
+            if (!e.type && fs.hasReturnExp)
+            {
+                e.type = Type.tint32;
+                fs.lowering = lrs;
+            }
+
+            return lrs;
         }
 
         switch (tab.ty)
@@ -2888,6 +2899,7 @@ Statement statementSemanticVisit(Statement s, Scope* sc)
                 //  return vresult;
                 Statement s = new ReturnStatement(Loc.initial, new VarExp(Loc.initial, fd.vresult));
                 sc.fes.cases.push(s);
+                sc.fes.hasReturnExp = true;
 
                 // Save receiver index for the later rewriting from:
                 //  return exp;
@@ -3847,6 +3859,8 @@ private extern(D) Expression applyOpApply(ForeachStatement fs, Expression flde,
     Expression ec;
     ec = new DotIdExp(fs.loc, fs.aggr, sapply.ident);
     ec = new CallExp(fs.loc, ec, flde);
+    if (fs.hasReturnExp) // would be rewritten in semantic3, run semantic later
+        return ec;
     ec = ec.expressionSemantic(sc2);
     if (ec.isErrorExp())
         return null;
@@ -3873,6 +3887,8 @@ private extern(D) Expression applyDelegate(ForeachStatement fs, Expression flde,
         fs.aggr = de.e1;
     }
     ec = new CallExp(fs.loc, fs.aggr, flde);
+    if (fs.hasReturnExp) // would be rewritten in semantic3, run semantic later
+        return ec;
     ec = ec.expressionSemantic(sc2);
     if (ec.op == EXP.error)
         return null;
diff --git a/compiler/test/compilable/pr22672.d b/compiler/test/compilable/pr22672.d
@@ -0,0 +1,23 @@
+struct S4
+{
+    this(ref inout S4) @system {}
+}
+
+struct V4
+{
+    int opApply(int delegate(Object) @safe dg) @safe
+    {
+        return dg(null);
+    }
+}
+
+S4 s;
+
+auto ref h4()
+{
+    foreach (_; V4())
+    {
+        return s;
+    }
+    return s;
+}
diff --git a/compiler/test/fail_compilation/issue22666.d b/compiler/test/fail_compilation/issue22666.d
diff --git a/compiler/test/runnable/issue22639.d b/compiler/test/runnable/issue22639.d

Original file line number	Diff line number	Diff line change
`@@ -852,6 +852,9 @@ extern (C++) final class ForeachStatement : Statement`
`852`	`852`	`Statements* cases; // put breaks, continues, gotos and returns here`
`853`	`853`	`ScopeStatements* gotos; // forward referenced goto's go here`
`854`	`854`
	`855`	`+ bool hasReturnExp; // has return exp; statement`
	`856`	`+ Statement lowering; // statement we lower to`
	`857`	`+`
`855`	`858`	`extern (D) this(Loc loc, TOK op, Parameters* parameters, Expression aggr, Statement _body, Loc endloc) @safe`
`856`	`859`	`{`
`857`	`860`	`super(loc, STMT.Foreach);`