Add AwaitInCatchTransform

ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs

@@ -257,8 +257,11 @@ namespace ICSharpCode.Decompiler.Tests
 		}
 
 		[Test]
-		public void Async([Values(CompilerOptions.None, CompilerOptions.Optimize)] CompilerOptions options)
+		public void Async([ValueSource("defaultOptions")] CompilerOptions options)
 		{
+			if (options.HasFlag(CompilerOptions.UseMcs)) {
+				Assert.Ignore("Decompiler bug with mono!");
+			}
 			RunCS(options: options);
 		}
 

ICSharpCode.Decompiler.Tests/TestCases/Correctness/Async.cs

@@ -123,6 +123,35 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness
 			}
 		}
 
+		public async Task AwaitMultipleCatchBlocks(Task<int> task)
+		{
+			try {
+				Console.WriteLine("Before throw");
+				throw new Exception();
+			} catch (OutOfMemoryException ex) {
+				Console.WriteLine(ex.ToString());
+				Console.WriteLine(await task);
+			} catch {
+				Console.WriteLine(await task);
+			}
+		}
+
+
+		public async Task AwaitMultipleCatchBlocks2(Task<int> task)
+		{
+			try {
+				Console.WriteLine("Before throw");
+				throw new Exception();
+			} catch (OutOfMemoryException ex) {
+				Console.WriteLine(ex.ToString());
+				Console.WriteLine(await task);
+			} catch (InternalBufferOverflowException ex) {
+				Console.WriteLine(ex.ToString());
+			} catch {
+				Console.WriteLine(await task);
+			}
+		}
+
 		public async Task AwaitFinally(Task<int> task)
 		{
 			try {

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -285,6 +285,7 @@
     <Compile Include="DotNetCore\LightJson\Serialization\TextScanner.cs" />
     <Compile Include="DotNetCore\UniversalAssemblyResolver.cs" />
     <Compile Include="DotNetCore\UnresolvedAssemblyNameReference.cs" />
+    <Compile Include="IL\ControlFlow\AwaitInCatchTransform.cs" />
     <Compile Include="IL\ILAstWritingOptions.cs" />
     <Compile Include="IL\Instructions\LdFlda.cs" />
     <Compile Include="IL\Instructions\NullableInstructions.cs" />

ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs

@@ -126,6 +126,8 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 			// Re-run control flow simplification over the newly constructed set of gotos,
 			// and inlining because TranslateFieldsToLocalAccess() might have opened up new inlining opportunities.
 			function.RunTransforms(CSharpDecompiler.EarlyILTransforms(), context);
+
+			AwaitInCatchTransform.Run(function, context);
 		}
 
 		private void CleanUpBodyOfMoveNext(ILFunction function)
@@ -513,15 +515,15 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow
 				}
 			}
 		}
-			#endregion
+		#endregion
 
-			#region AnalyzeStateMachine
+		#region AnalyzeStateMachine
 
-			/// <summary>
+		/// <summary>
-			/// Analyze the the state machine; and replace 'leave IL_0000' with await+jump to block that gets
+		/// Analyze the the state machine; and replace 'leave IL_0000' with await+jump to block that gets
-			/// entered on the next MoveNext() call.
+		/// entered on the next MoveNext() call.
-			/// </summary>
+		/// </summary>
-			void AnalyzeStateMachine(ILFunction function)
+		void AnalyzeStateMachine(ILFunction function)
 		{
 			context.Step("AnalyzeStateMachine()", function);
 			smallestAwaiterVarIndex = int.MaxValue;

ICSharpCode.Decompiler/IL/ControlFlow/AwaitInCatchTransform.cs

@@ -0,0 +1,187 @@
+// Copyright (c) 2018 Siegfried Pammer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using ICSharpCode.Decompiler.IL.Transforms;
+
+namespace ICSharpCode.Decompiler.IL.ControlFlow
+{
+	class AwaitInCatchTransform
+	{
+		public static void Run(ILFunction function, ILTransformContext context)
+		{
+			HashSet<BlockContainer> changedContainers = new HashSet<BlockContainer>();
+
+			// analyze all try-catch statements in the function
+			foreach (var tryCatch in function.Descendants.OfType<TryCatch>().ToArray()) {
+				if (!(tryCatch.Parent?.Parent is BlockContainer container))
+					continue;
+				// Detect all handlers that contain an await expression
+				AnalyzeHandlers(tryCatch.Handlers, out var transformableCatchBlocks);
+				var cfg = new ControlFlowGraph(container, context.CancellationToken);
+				if (transformableCatchBlocks.Count > 0)
+					changedContainers.Add(container);
+				foreach (var result in transformableCatchBlocks) {
+					var node = cfg.GetNode(result.RealCatchBlockEntryPoint);
+
+					context.Step("Inline catch block with await", result.Handler);
+
+					// Remove the IfInstruction from the jump table and eliminate all branches to the block.
+					var jumpTableBlock = (Block)result.JumpTableEntry.Parent;
+					jumpTableBlock.Instructions.RemoveAt(result.JumpTableEntry.ChildIndex);
+
+					if (result.NextBlock != null) {
+						foreach (var branch in tryCatch.Descendants.OfType<Branch>()) {
+							if (branch.TargetBlock == jumpTableBlock)
+								branch.ReplaceWith(new Branch(result.NextBlock));
+						}
+					}
+
+					// Add the real catch block entry-point to the block container
+					var catchBlockHead = ((BlockContainer)result.Handler.Body).Blocks.Last();
+
+					result.RealCatchBlockEntryPoint.Remove();
+					((BlockContainer)result.Handler.Body).Blocks.Insert(0, result.RealCatchBlockEntryPoint);
+
+					// Remove the generated catch block
+					catchBlockHead.Remove();
+
+					// Inline all blocks that are dominated by the entrypoint of the real catch block
+					foreach (var n in cfg.cfg) {
+						if (((Block)n.UserData).Parent == result.Handler.Body)
+							continue;
+						if (node.Dominates(n)) {
+							MoveBlock((Block)n.UserData, (BlockContainer)result.Handler.Body);
+						}
+					}
+
+					// Remove all assignments to the common object variable that stores the exception object.
+					if (result.ObjectVariableStore != null) {
+						foreach (var load in result.ObjectVariableStore.Variable.LoadInstructions.ToArray()) {
+							if (load.Parent is CastClass cc && cc.Type == result.Handler.Variable.Type)
+								cc.ReplaceWith(new LdLoc(result.Handler.Variable));
+							else
+								load.ReplaceWith(new LdLoc(result.Handler.Variable));
+						}
+					}
+				}
+			}
+
+			// clean up all modified containers
+			foreach (var container in changedContainers)
+				container.SortBlocks(deleteUnreachableBlocks: true);
+		}
+
+		static void MoveBlock(Block block, BlockContainer target)
+		{
+			block.Remove();
+			target.Blocks.Add(block);
+		}
+
+		/// <summary>
+		/// Analyzes all catch handlers and returns every handler that follows the await catch handler pattern.
+		/// </summary>
+		static bool AnalyzeHandlers(InstructionCollection<TryCatchHandler> handlers, out List<(int Id, TryCatchHandler Handler, Block RealCatchBlockEntryPoint, Block NextBlock, IfInstruction JumpTableEntry, StLoc ObjectVariableStore)> transformableCatchBlocks)
+		{
+			transformableCatchBlocks = new List<(int Id, TryCatchHandler Handler, Block RealCatchBlockEntryPoint, Block NextBlock, IfInstruction JumpTableEntry, StLoc ObjectVariableStore)>();
+			ILVariable catchHandlerIdentifier = null;
+			foreach (var handler in handlers) {
+				if (!MatchAwaitCatchHandler((BlockContainer)handler.Body, out int id, out var identifierVariable, out var realEntryPoint, out var nextBlock, out var jumpTableEntry, out var objectVariableStore))
+					continue;
+				if (id < 1 || (catchHandlerIdentifier != null && identifierVariable != catchHandlerIdentifier))
+					continue;
+				catchHandlerIdentifier = identifierVariable;
+				transformableCatchBlocks.Add((id, handler, realEntryPoint, nextBlock, jumpTableEntry, objectVariableStore));
+			}
+			return transformableCatchBlocks.Count > 0;
+		}
+
+		/// <summary>
+		/// Matches the await catch handler pattern:
+		/// stloc V_3(ldloc E_100)	- copy exception variable to a temporary
+		/// stloc V_6(ldloc V_3)	- store exception in 'global' object variable
+		/// stloc V_5(ldc.i4 2)		- store id of catch block in 'identifierVariable'
+		/// br IL_0075				- jump out of catch block to the head of the catch-handler jump table
+		/// </summary>
+		static bool MatchAwaitCatchHandler(BlockContainer container, out int id, out ILVariable identifierVariable, out Block realEntryPoint, out Block nextBlock, out IfInstruction jumpTableEntry, out StLoc objectVariableStore)
+		{
+			id = default(int);
+			identifierVariable = null;
+			realEntryPoint = null;
+			jumpTableEntry = null;
+			objectVariableStore = null;
+			nextBlock = null;
+			var catchBlock = container.EntryPoint;
+			if (catchBlock.Instructions.Count < 2 || catchBlock.Instructions.Count > 4)
+				return false;
+			if (!catchBlock.Instructions.Last().MatchBranch(out var jumpTableStartBlock))
+				return false;
+			if (catchBlock.Instructions.Count > 2) {
+				objectVariableStore = (StLoc)catchBlock.Instructions[catchBlock.Instructions.Count - 3];
+			}
+			var identifierVariableAssignment = catchBlock.Instructions.SecondToLastOrDefault();
+			if (!identifierVariableAssignment.MatchStLoc(out identifierVariable, out var value) || !value.MatchLdcI4(out id))
+				return false;
+			// analyze jump table:
+			// [stloc identifierVariableCopy(identifierVariable)]
+			// if (comp(identifierVariable == id)) br realEntryPoint
+			// br jumpTableEntryBlock
+			ILVariable identifierVariableCopy;
+			if (jumpTableStartBlock.Instructions.Count == 3) {
+				if (!jumpTableStartBlock.Instructions[0].MatchStLoc(out identifierVariableCopy, out var identifierVariableLoad) || !identifierVariableLoad.MatchLdLoc(identifierVariable))
+					return false;
+			} else if (jumpTableStartBlock.Instructions.Count == 2) {
+				identifierVariableCopy = identifierVariable;
+			} else return false;
+			var jumpTableEntryBlock = jumpTableStartBlock;
+			do {
+				if (!(jumpTableEntryBlock.Instructions.SecondToLastOrDefault() is IfInstruction ifInst))
+					return false;
+				ILInstruction lastInst = jumpTableEntryBlock.Instructions.Last();
+				if (ifInst.Condition.MatchCompEquals(out var left, out var right)) {
+					if (!ifInst.TrueInst.MatchBranch(out realEntryPoint))
+						return false;
+					if (!lastInst.MatchBranch(out jumpTableEntryBlock)) {
+						if (!lastInst.MatchLeave((BlockContainer)lastInst.Parent.Parent))
+							return false;
+					}
+				} else if (ifInst.Condition.MatchCompNotEquals(out left, out right)) {
+					if (!lastInst.MatchBranch(out realEntryPoint))
+						return false;
+					if (!ifInst.TrueInst.MatchBranch(out jumpTableEntryBlock)) {
+						if (!ifInst.TrueInst.MatchLeave((BlockContainer)lastInst.Parent.Parent))
+							return false;
+					}
+				} else {
+					return false;
+				}
+				if (!left.MatchLdLoc(identifierVariableCopy))
+					return false;
+				if (right.MatchLdcI4(id)) {
+					nextBlock = jumpTableEntryBlock;
+					jumpTableEntry = ifInst;
+					return true;
+				}
+			} while (jumpTableEntryBlock?.Instructions.Count == 2);
+			return false;
+		}
+	}
+}