Reverse runtime-async flag-based early-return across a try-finally.

When a return crosses an enclosing try-finally with await, runtime-async lowers it as: capture the return value, set an int flag to a unique non-zero value, leave the try block normally so the finally runs, then post-finally check "if (flag == K) return capture;". Detect that pattern after my outer try-finally rewrite (or, in optimized builds, the compiler-emitted TryFinally directly) and replace each capture-flag-and-leave site with a direct "leave outer (capture)" — the leave still passes through the TryFinally, so the user's finally body executes before the function returns, which matches the source-level semantics.

Handles both the "if (flag == K)" and "if (flag != K)" check forms (the optimizer emits the latter). Closes the last gap in Issue2436 — RuntimeAsync now passes both Optimize and non-Optimize modes; the full RuntimeAsync* sweep is 12/12 green.

Also remap reads of the captured-obj local inside the cleaned filter so optimized builds (where Roslyn inlines the typed-cast directly into the user filter expression instead of stashing it in a local) render against the catch variable rather than against "((T)obj)".

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: siegfriedpammer

ICSharpCode.Decompiler/IL/ControlFlow/RuntimeAsyncExceptionRewriteTransform.cs

@@ -108,6 +108,14 @@ public static void Run(ILFunction function, ILTransformContext context)
 				}
 			}
 
+			// Recognize the "early return from inside a try via a flag local" pattern that runtime-async
+			// emits whenever a return statement crosses an enclosing try-finally with await.
+			foreach (var tryFinally in function.Descendants.OfType<TryFinally>().ToArray())
+			{
+				if (TryRewriteFlagBasedEarlyReturn(tryFinally, context))
+					changed = true;
+			}
+
 			if (changed)
 			{
 				foreach (var c in function.Body.Descendants.OfType<BlockContainer>())
@@ -204,8 +212,12 @@ static bool NormalizeRuntimeAsyncFilter(TryCatchHandler handler, ILFunction func
 			if (typedExVar != null)
 				RemapVariableReads(function, typedExVar, handler.Variable);
 
-			// The obj variable is shared between handlers in the multi-handler form; remap it later,
-			// scoped to the moved catch body, when TryRewriteTryCatch / multi-handler relocates it.
+			// Optimized builds inline `castclass T(ldloc obj)` directly into the user filter expression
+			// instead of stashing it in a typedEx local. Remap obj reads within the filter only.
+			RemapVariableReads(handler.Filter, objVar, handler.Variable);
+
+			// The obj variable is shared between handlers in the multi-handler form; the body rewriter
+			// remaps it scoped per handler.
 			filterObjByHandler[handler] = objVar;
 
 			context.StepEndGroup(keepIfEmpty: true);
@@ -912,6 +924,187 @@ static void ReplaceVariableReadsWithHandlerVariable(ILInstruction root, ILVariab
 			}
 		}
 
+		// Recognize the runtime-async lowering of an early return that crosses a try-finally.
+		// Roslyn rewrites `return value;` inside a try-block as:
+		//     stloc capture(value)
+		//     stloc flag(K)
+		//     leave-try   (i.e. let the finally run, then exit the try-finally)
+		// followed by post-try logic of the form:
+		//     if (flag == K) leave outer (capture)
+		//
+		// Detect that pattern around a TryFinally we just produced and rewrite each capture-set-flag-and-leave
+		// site into a direct `leave outer (value)`, then drop the flag/post-flag-check machinery. The leave
+		// still passes through the TryFinally so the user's finally body runs before the function returns,
+		// which is the intended source-level semantics of `return` from inside a try-finally.
+		static bool TryRewriteFlagBasedEarlyReturn(TryFinally tryFinally, ILTransformContext context)
+		{
+			if (tryFinally.Parent is not Block parentBlock)
+				return false;
+			if (parentBlock.Parent is not BlockContainer container)
+				return false;
+
+			// The TryFinally is followed in parentBlock by either nothing (fall-through into the next block)
+			// or a single `br checkBlock` we appended ourselves. Locate the post-try check block.
+			Block checkBlock;
+			int tryFinallyIdx = tryFinally.ChildIndex;
+			if (tryFinallyIdx == parentBlock.Instructions.Count - 1)
+				return false;
+			if (parentBlock.Instructions[tryFinallyIdx + 1] is Branch br)
+				checkBlock = br.TargetBlock;
+			else
+				return false;
+			if (checkBlock?.Parent != container)
+				return false;
+
+			// checkBlock: `if (flagVar == K) br earlyBlock; br normalBlock`
+			//        or:  `if (flagVar != K) br normalBlock; br earlyBlock`
+			if (checkBlock.Instructions.Count != 2)
+				return false;
+			if (checkBlock.Instructions[0] is not IfInstruction ifInst)
+				return false;
+			if (ifInst.TrueInst is not Branch toIfTrue)
+				return false;
+			if (!checkBlock.Instructions[1].MatchBranch(out var fallthroughBlock))
+				return false;
+
+			ILVariable flagVar;
+			int targetK;
+			Block earlyBlock, normalBlock;
+			if (ifInst.Condition.MatchCompEquals(out var lhs, out var rhs)
+				&& lhs.MatchLdLoc(out flagVar) && rhs.MatchLdcI4(out targetK))
+			{
+				earlyBlock = toIfTrue.TargetBlock;
+				normalBlock = fallthroughBlock;
+			}
+			else if (ifInst.Condition.MatchCompNotEquals(out lhs, out rhs)
+				&& lhs.MatchLdLoc(out flagVar) && rhs.MatchLdcI4(out targetK))
+			{
+				normalBlock = toIfTrue.TargetBlock;
+				earlyBlock = fallthroughBlock;
+			}
+			else
+			{
+				return false;
+			}
+			if (!flagVar.Type.IsKnownType(KnownTypeCode.Int32))
+				return false;
+			if (earlyBlock?.Parent != container || normalBlock?.Parent != container)
+				return false;
+
+			// earlyBlock chain: optional `stloc returnVar(ldloc capture); br leaveBlock` followed by
+			// `leave outer (ldloc returnVar)` (or a direct leave with the capture).
+			if (!ResolveEarlyReturnValue(earlyBlock, container, out var captureVar, out var returnVar, out var leaveBlock))
+				return false;
+
+			// Inside the try-block find the flag-setter block(s): `stloc flagVar(K); leave-tryBlock`.
+			// There may be multiple — e.g. several catches in a multi-handler try each with its own
+			// early-return — but for the simple case we only need one.
+			if (tryFinally.TryBlock is not BlockContainer tryBlockContainer)
+				return false;
+			var flagSetters = new List<Block>();
+			foreach (var b in tryBlockContainer.Blocks)
+			{
+				if (b.Instructions.Count == 2
+					&& b.Instructions[0] is StLoc setStore
+					&& setStore.Variable == flagVar
+					&& setStore.Value.MatchLdcI4(targetK)
+					&& b.Instructions[1] is Leave leaveFromTry
+					&& leaveFromTry.TargetContainer == tryBlockContainer)
+				{
+					flagSetters.Add(b);
+				}
+			}
+			if (flagSetters.Count == 0)
+				return false;
+
+			// Verify flagVar is only set in flag-setters and the pre-try init (`stloc flagVar(0)`).
+			foreach (var store in flagVar.StoreInstructions.OfType<StLoc>())
+			{
+				if (flagSetters.Any(fs => fs.Instructions.Contains(store)))
+					continue;
+				if (store.Parent == parentBlock && store.Value.MatchLdcI4(0))
+					continue;
+				return false;
+			}
+
+			// Build the leave instruction shape: leave outer (ldloc captureSource).
+			var outerContainer = (BlockContainer)leaveBlock.Parent;
+			var outerLeave = (Leave)leaveBlock.Instructions[leaveBlock.Instructions.Count - 1];
+			if (outerLeave.TargetContainer != outerContainer)
+				return false;
+
+			context.StepStartGroup("Reduce runtime-async flag-based early return", tryFinally);
+
+			// For each flag-setter, redirect predecessor branches to a new "leave outer (capture)".
+			foreach (var fs in flagSetters)
+			{
+				foreach (var pred in container.Descendants.OfType<Branch>().ToArray())
+				{
+					if (pred.TargetBlock != fs)
+						continue;
+					if (!pred.IsDescendantOf(tryBlockContainer))
+						continue;
+					// The predecessor block's tail is: ...; stloc capture(value); br fs.
+					// Replace `br fs` with `leave outer (ldloc capture)` and let the existing capture
+					// store stay (it now feeds the leave value via the variable read).
+					pred.ReplaceWith(new Leave(outerContainer, new LdLoc(captureVar)).WithILRange(pred));
+				}
+				fs.Remove();
+			}
+
+			// The post-flag-check block can now be replaced with `br normalBlock`. The flag write/read,
+			// the early-return chain and (eventually) the captureVar/returnVar become unreferenced.
+			checkBlock.Instructions.Clear();
+			checkBlock.Instructions.Add(new Branch(normalBlock));
+
+			// Drop the pre-try `stloc flagVar(0)` (and the `stloc returnVar(default)` if present).
+			for (int i = 0; i < tryFinallyIdx; i++)
+			{
+				if (parentBlock.Instructions[i] is StLoc s && s.Variable == flagVar && s.Value.MatchLdcI4(0))
+				{
+					parentBlock.Instructions.RemoveAt(i);
+					tryFinallyIdx--;
+					i--;
+				}
+			}
+
+			context.StepEndGroup(keepIfEmpty: true);
+			return true;
+		}
+
+		// earlyBlock should be either:
+		//   `stloc returnVar(ldloc capture); br leaveBlock` followed by leaveBlock = `leave outer (ldloc returnVar)`
+		//   or a direct `leave outer (ldloc capture)`.
+		static bool ResolveEarlyReturnValue(Block earlyBlock, BlockContainer container,
+			out ILVariable captureVar, out ILVariable returnVar, out Block leaveBlock)
+		{
+			captureVar = null;
+			returnVar = null;
+			leaveBlock = null;
+			if (earlyBlock.Instructions.Count == 2
+				&& earlyBlock.Instructions[0] is StLoc rvStore
+				&& rvStore.Value.MatchLdLoc(out captureVar)
+				&& earlyBlock.Instructions[1].MatchBranch(out leaveBlock)
+				&& leaveBlock?.Parent == container
+				&& leaveBlock.Instructions.Count == 1
+				&& leaveBlock.Instructions[0] is Leave finalLeave
+				&& finalLeave.IsLeavingFunction
+				&& finalLeave.Value.MatchLdLoc(rvStore.Variable))
+			{
+				returnVar = rvStore.Variable;
+				return true;
+			}
+			if (earlyBlock.Instructions.Count == 1
+				&& earlyBlock.Instructions[0] is Leave directLeave
+				&& directLeave.IsLeavingFunction
+				&& directLeave.Value.MatchLdLoc(out captureVar))
+			{
+				leaveBlock = earlyBlock;
+				return true;
+			}
+			return false;
+		}
+
 		static void ReplaceDispatchIdiomWithRethrow(Block block, ILVariable handlerVariable, ILTransformContext context)
 		{
 			// Reuse AwaitInCatchTransform.MatchExceptionCaptureBlock through the block-tail shape: