Merge pull request #1920 from icsharpcode/fix-1919

Fix #1919: Use unmapped IL offsets at the start of a catch-block for the 'exception specifier' sequence point.

ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpOutputVisitor.cs

@@ -1812,11 +1812,11 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor
 				Space();
 				WriteKeyword(CatchClause.WhenKeywordRole);
 				Space(policy.SpaceBeforeIfParentheses);
-				LPar();
+				WriteToken(CatchClause.CondLPar);
 				Space(policy.SpacesWithinIfParentheses);
 				catchClause.Condition.AcceptVisitor(this);
 				Space(policy.SpacesWithinIfParentheses);
-				RPar();
+				WriteToken(CatchClause.CondRPar);
 			}
 			WriteBlock(catchClause.Body, policy.StatementBraceStyle);
 			EndNode(catchClause);

ICSharpCode.Decompiler/CSharp/SequencePointBuilder.cs

@@ -113,7 +113,13 @@ namespace ICSharpCode.Decompiler.CSharp
 			ILInstruction blockContainer = blockStatement.Annotations.OfType<ILInstruction>().FirstOrDefault();
 			if (blockContainer != null) {
 				StartSequencePoint(blockStatement.LBraceToken);
-				int intervalStart = blockContainer.ILRanges.First().Start;
+				int intervalStart;
+				if (blockContainer.Parent is TryCatchHandler handler && !handler.ExceptionSpecifierILRange.IsEmpty) {
+					// if this block container is part of a TryCatchHandler, do not steal the exception-specifier IL range
+					intervalStart = handler.ExceptionSpecifierILRange.End;
+				} else {
+					intervalStart = blockContainer.StartILOffset;
+				}
 				// The end will be set to the first sequence point candidate location before the first statement of the function when the seqeunce point is adjusted
 				int intervalEnd = intervalStart + 1; 
 
@@ -256,12 +262,15 @@ namespace ICSharpCode.Decompiler.CSharp
 			foreachStatement.InExpression.AcceptVisitor(this);
 			AddToSequencePoint(foreachInfo.GetEnumeratorCall);
 			EndSequencePoint(foreachStatement.InExpression.StartLocation, foreachStatement.InExpression.EndLocation);
+
 			StartSequencePoint(foreachStatement);
 			AddToSequencePoint(foreachInfo.MoveNextCall);
 			EndSequencePoint(foreachStatement.InToken.StartLocation, foreachStatement.InToken.EndLocation);
+			
 			StartSequencePoint(foreachStatement);
 			AddToSequencePoint(foreachInfo.GetCurrentCall);
 			EndSequencePoint(foreachStatement.VariableType.StartLocation, foreachStatement.VariableNameToken.EndLocation);
+			
 			VisitAsSequencePoint(foreachStatement.EmbeddedStatement);
 		}
 
@@ -310,6 +319,33 @@ namespace ICSharpCode.Decompiler.CSharp
 			VisitAsSequencePoint(fixedStatement.EmbeddedStatement);
 		}
 
+		public override void VisitTryCatchStatement(TryCatchStatement tryCatchStatement)
+		{
+			VisitAsSequencePoint(tryCatchStatement.TryBlock);
+			foreach (var c in tryCatchStatement.CatchClauses) {
+				VisitAsSequencePoint(c);
+			}
+			VisitAsSequencePoint(tryCatchStatement.FinallyBlock);
+		}
+
+		public override void VisitCatchClause(CatchClause catchClause)
+		{
+			if (catchClause.Condition.IsNull) {
+				var tryCatchHandler = catchClause.Annotation<TryCatchHandler>();
+				if (!tryCatchHandler.ExceptionSpecifierILRange.IsEmpty) {
+					StartSequencePoint(catchClause.CatchToken);
+					var function = tryCatchHandler.Ancestors.OfType<ILFunction>().FirstOrDefault();
+					AddToSequencePointRaw(function, new[] { tryCatchHandler.ExceptionSpecifierILRange });
+					EndSequencePoint(catchClause.CatchToken.StartLocation, catchClause.RParToken.IsNull ? catchClause.CatchToken.EndLocation : catchClause.RParToken.EndLocation);
+				}
+			} else {
+				StartSequencePoint(catchClause.WhenToken);
+				AddToSequencePoint(catchClause.Condition);
+				EndSequencePoint(catchClause.WhenToken.StartLocation, catchClause.CondRParToken.EndLocation);
+			}
+			VisitAsSequencePoint(catchClause.Body);
+		}
+
 		/// <summary>
 		/// Start a new C# statement = new sequence point.
 		/// </summary>
@@ -339,6 +375,13 @@ namespace ICSharpCode.Decompiler.CSharp
 			current = outerStates.Pop();
 		}
 
+		void AddToSequencePointRaw(ILFunction function, IEnumerable<Interval> ranges)
+		{
+			current.Intervals.AddRange(ranges);
+			Debug.Assert(current.Function == null || current.Function == function);
+			current.Function = function;
+		}
+
 		/// <summary>
 		/// Add the ILAst instruction associated with the AstNode to the sequence point.
 		/// Also add all its ILAst sub-instructions (unless they were already added to another sequence point).

ICSharpCode.Decompiler/CSharp/StatementBuilder.cs

@@ -363,6 +363,7 @@ namespace ICSharpCode.Decompiler.CSharp
 			tryCatch.TryBlock = ConvertAsBlock(inst.TryBlock);
 			foreach (var handler in inst.Handlers) {
 				var catchClause = new CatchClause();
+				catchClause.AddAnnotation(handler);
 				var v = handler.Variable;
 				if (v != null) {
 					catchClause.AddAnnotation(new ILVariableResolveResult(v, v.Type));

ICSharpCode.Decompiler/CSharp/Syntax/Statements/TryCatchStatement.cs

@@ -90,6 +90,8 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		public static readonly TokenRole CatchKeywordRole = new TokenRole("catch");
 		public static readonly TokenRole WhenKeywordRole = new TokenRole("when");
 		public static readonly Role<Expression> ConditionRole = Roles.Condition;
+		public static readonly TokenRole CondLPar = new TokenRole("(");
+		public static readonly TokenRole CondRPar = new TokenRole(")");
 
 		#region Null
 		public new static readonly CatchClause Null = new NullCatchClause();
@@ -195,7 +197,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 				if (string.IsNullOrEmpty(value))
 					SetChildByRole(Roles.Identifier, null);
 				else
-					SetChildByRole (Roles.Identifier, Identifier.Create (value));
+					SetChildByRole(Roles.Identifier, Identifier.Create(value));
 			}
 		}
 
@@ -216,11 +218,19 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 			get { return GetChildByRole(WhenKeywordRole); }
 		}
 
+		public CSharpTokenNode CondLParToken {
+			get { return GetChildByRole(CondLPar); }
+		}
+
 		public Expression Condition {
 			get { return GetChildByRole(ConditionRole); }
 			set { SetChildByRole(ConditionRole, value); }
 		}
 
+		public CSharpTokenNode CondRParToken {
+			get { return GetChildByRole(CondRPar); }
+		}
+
 		public BlockStatement Body {
 			get { return GetChildByRole(Roles.Body); }
 			set { SetChildByRole(Roles.Body, value); }

ICSharpCode.Decompiler/IL/Instructions/ILInstruction.cs

@@ -214,24 +214,29 @@ namespace ICSharpCode.Decompiler.IL
 
 		public void AddILRange(Interval newRange)
 		{
-			if (this.ILRange.IsEmpty) {
-				this.ILRange = newRange;
-				return;
+			this.ILRange = CombineILRange(this.ILRange, newRange);
+		}
+
+		protected static Interval CombineILRange(Interval oldRange, Interval newRange)
+		{
+			if (oldRange.IsEmpty) {
+				return newRange;
 			}
 			if (newRange.IsEmpty) {
-				return;
+				return oldRange;
 			}
-			if (newRange.Start <= this.StartILOffset) {
-				if (newRange.End < this.StartILOffset) {
-					this.ILRange = newRange; // use the earlier range
+			if (newRange.Start <= oldRange.Start) {
+				if (newRange.End < oldRange.Start) {
+					return newRange; // use the earlier range
 				} else {
 					// join overlapping ranges
-					this.ILRange = new Interval(newRange.Start, Math.Max(newRange.End, this.ILRange.End));
+					return new Interval(newRange.Start, Math.Max(newRange.End, oldRange.End));
 				}
-			} else if (newRange.Start <= this.ILRange.End) {
+			} else if (newRange.Start <= oldRange.End) {
 				// join overlapping ranges
-				this.ILRange = new Interval(this.StartILOffset, Math.Max(newRange.End, this.ILRange.End));
+				return new Interval(oldRange.Start, Math.Max(newRange.End, oldRange.End));
 			}
+			return oldRange;
 		}
 
 		public void AddILRange(ILInstruction sourceInstruction)

ICSharpCode.Decompiler/IL/Instructions/TryInstruction.cs

@@ -19,6 +19,7 @@
 using System;
 using System.Diagnostics;
 using System.Linq;
+using ICSharpCode.Decompiler.Util;
 
 namespace ICSharpCode.Decompiler.IL
 {
@@ -175,6 +176,18 @@ namespace ICSharpCode.Decompiler.IL
 			output.Write(' ');
 			body.WriteTo(output, options);
 		}
+
+		/// <summary>
+		/// Gets the ILRange of the instructions at the start of the catch-block,
+		/// that take the exception object and store it in the exception variable slot.
+		/// Note: This range is empty, if Filter is not empty, i.e., ldloc 1.
+		/// </summary>
+		public Interval ExceptionSpecifierILRange { get; private set; }
+
+		public void AddExceptionSpecifierILRange(Interval newRange)
+		{
+			ExceptionSpecifierILRange = CombineILRange(ExceptionSpecifierILRange, newRange);
+		}
 	}
 	
 	partial class TryFinally

ICSharpCode.Decompiler/IL/Transforms/ExpressionTransforms.cs

@@ -17,10 +17,12 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Linq.Expressions;
 using ICSharpCode.Decompiler.TypeSystem;
+using ICSharpCode.Decompiler.Util;
 
 namespace ICSharpCode.Decompiler.IL.Transforms
 {
@@ -692,7 +694,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 				TransformCatchWhen(inst, filterContainer.EntryPoint);
 			}
 			if (inst.Body is BlockContainer catchContainer)
-				TransformCatchVariable(inst, catchContainer.EntryPoint);
+				TransformCatchVariable(inst, catchContainer.EntryPoint, isCatchBlock: true);
 		}
 
 		/// <summary>
@@ -709,7 +711,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		/// 	}
 		/// }
 		/// </summary>
-		void TransformCatchVariable(TryCatchHandler handler, Block entryPoint)
+		void TransformCatchVariable(TryCatchHandler handler, Block entryPoint, bool isCatchBlock)
 		{
 			if (!handler.Variable.IsSingleDefinition || handler.Variable.LoadCount != 1)
 				return; // handle.Variable already has non-trivial uses
@@ -720,6 +722,8 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 					if (inlinedUnboxAny.Type.Equals(handler.Variable.Type)) {
 						context.Step("TransformCatchVariable - remove inlined UnboxAny", inlinedUnboxAny);
 						inlinedUnboxAny.ReplaceWith(inlinedUnboxAny.Argument);
+						foreach (var range in inlinedUnboxAny.ILRanges)
+							handler.AddExceptionSpecifierILRange(range);
 					}
 				}
 				return;
@@ -746,6 +750,10 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 			exceptionVar.Kind = VariableKind.ExceptionLocal;
 			exceptionVar.Type = handler.Variable.Type;
 			handler.Variable = exceptionVar;
+			if (isCatchBlock) {
+				foreach (var offset in entryPoint.Instructions[0].Descendants.SelectMany(o => o.ILRanges))
+					handler.AddExceptionSpecifierILRange(offset);
+			}
 			entryPoint.Instructions.RemoveAt(0);
 		}
 
@@ -754,7 +762,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms
 		/// </summary>
 		void TransformCatchWhen(TryCatchHandler handler, Block entryPoint)
 		{
-			TransformCatchVariable(handler, entryPoint);
+			TransformCatchVariable(handler, entryPoint, isCatchBlock: false);
 			if (entryPoint.Instructions.Count == 1 && entryPoint.Instructions[0].MatchLeave(out _, out var condition)) {
 				context.Step("TransformCatchWhen", entryPoint.Instructions[0]);
 				handler.Filter = condition;