#994: Implement DecompilerException in DecompileBody

ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs

@@ -737,65 +737,69 @@ namespace ICSharpCode.Decompiler.CSharp
 
 		void DecompileBody(MethodDefinition methodDefinition, IMethod method, EntityDeclaration entityDecl, ITypeResolveContext decompilationContext)
 		{
-			// Special case: code size is 0
-			// This might be a reference assembly:
-			if (methodDefinition.Body.CodeSize == 0) {
-				var dummy = new BlockStatement();
-				dummy.InsertChildAfter(null, new EmptyStatement(), BlockStatement.StatementRole);
-				dummy.InsertChildAfter(null, new Comment(" Empty body found. Decompiled assembly might be a reference assembly."), Roles.Comment);
-				entityDecl.AddChild(dummy, Roles.Body);
-				return;
-			}
-			var specializingTypeSystem = typeSystem.GetSpecializingTypeSystem(decompilationContext);
-			var ilReader = new ILReader(specializingTypeSystem);
-			ilReader.UseDebugSymbols = settings.UseDebugSymbols;
-			var function = ilReader.ReadIL(methodDefinition.Body, CancellationToken);
-			function.CheckInvariant(ILPhase.Normal);
-
-			if (entityDecl != null) {
-				int i = 0;
-				var parameters = function.Variables.Where(v => v.Kind == VariableKind.Parameter).ToDictionary(v => v.Index);
-				foreach (var parameter in entityDecl.GetChildrenByRole(Roles.Parameter)) {
-					if (parameters.TryGetValue(i, out var v))
-						parameter.AddAnnotation(new ILVariableResolveResult(v, method.Parameters[i].Type));
-					i++;
+			try {
+				// Special case: code size is 0
+				// This might be a reference assembly:
+				if (methodDefinition.Body.CodeSize == 0) {
+					var dummy = new BlockStatement();
+					dummy.InsertChildAfter(null, new EmptyStatement(), BlockStatement.StatementRole);
+					dummy.InsertChildAfter(null, new Comment(" Empty body found. Decompiled assembly might be a reference assembly."), Roles.Comment);
+					entityDecl.AddChild(dummy, Roles.Body);
+					return;
 				}
-			}
-
-			var context = new ILTransformContext(function, specializingTypeSystem, settings) {
-				CancellationToken = CancellationToken
-			};
-			foreach (var transform in ilTransforms) {
-				CancellationToken.ThrowIfCancellationRequested();
-				transform.Run(function, context);
+				var specializingTypeSystem = typeSystem.GetSpecializingTypeSystem(decompilationContext);
+				var ilReader = new ILReader(specializingTypeSystem);
+				ilReader.UseDebugSymbols = settings.UseDebugSymbols;
+				var function = ilReader.ReadIL(methodDefinition.Body, CancellationToken);
 				function.CheckInvariant(ILPhase.Normal);
-			}
 
-			AddDefinesForConditionalAttributes(function);
-			var statementBuilder = new StatementBuilder(specializingTypeSystem, decompilationContext, function, settings, CancellationToken);
-			var body = statementBuilder.ConvertAsBlock(function.Body);
+				if (entityDecl != null) {
+					int i = 0;
+					var parameters = function.Variables.Where(v => v.Kind == VariableKind.Parameter).ToDictionary(v => v.Index);
+					foreach (var parameter in entityDecl.GetChildrenByRole(Roles.Parameter)) {
+						if (parameters.TryGetValue(i, out var v))
+							parameter.AddAnnotation(new ILVariableResolveResult(v, method.Parameters[i].Type));
+						i++;
+					}
+				}
+
+				var context = new ILTransformContext(function, specializingTypeSystem, settings) {
+					CancellationToken = CancellationToken
+				};
+				foreach (var transform in ilTransforms) {
+					CancellationToken.ThrowIfCancellationRequested();
+					transform.Run(function, context);
+					function.CheckInvariant(ILPhase.Normal);
+				}
+
+				AddDefinesForConditionalAttributes(function);
+				var statementBuilder = new StatementBuilder(specializingTypeSystem, decompilationContext, function, settings, CancellationToken);
+				var body = statementBuilder.ConvertAsBlock(function.Body);
 
-			Comment prev = null;
-			foreach (string warning in function.Warnings) {
-				body.InsertChildAfter(prev, prev = new Comment(warning), Roles.Comment);
-			}
+				Comment prev = null;
+				foreach (string warning in function.Warnings) {
+					body.InsertChildAfter(prev, prev = new Comment(warning), Roles.Comment);
+				}
 
-			entityDecl.AddChild(body, Roles.Body);
-			entityDecl.AddAnnotation(function);
+				entityDecl.AddChild(body, Roles.Body);
+				entityDecl.AddAnnotation(function);
 
-			if (function.IsIterator) {
-				if (!body.Descendants.Any(d => d is YieldReturnStatement || d is YieldBreakStatement)) {
-					body.Add(new YieldBreakStatement());
+				if (function.IsIterator) {
+					if (!body.Descendants.Any(d => d is YieldReturnStatement || d is YieldBreakStatement)) {
+						body.Add(new YieldBreakStatement());
+					}
+					RemoveAttribute(entityDecl, new TopLevelTypeName("System.Runtime.CompilerServices", "IteratorStateMachineAttribute"));
+					if (function.StateMachineCompiledWithMono) {
+						RemoveAttribute(entityDecl, new TopLevelTypeName("System.Diagnostics", "DebuggerHiddenAttribute"));
+					}
 				}
-				RemoveAttribute(entityDecl, new TopLevelTypeName("System.Runtime.CompilerServices", "IteratorStateMachineAttribute"));
-				if (function.StateMachineCompiledWithMono) {
-					RemoveAttribute(entityDecl, new TopLevelTypeName("System.Diagnostics", "DebuggerHiddenAttribute"));
+				if (function.IsAsync) {
+					entityDecl.Modifiers |= Modifiers.Async;
+					RemoveAttribute(entityDecl, new TopLevelTypeName("System.Runtime.CompilerServices", "AsyncStateMachineAttribute"));
+					RemoveAttribute(entityDecl, new TopLevelTypeName("System.Diagnostics", "DebuggerStepThroughAttribute"));
 				}
-			}
-			if (function.IsAsync) {
-				entityDecl.Modifiers |= Modifiers.Async;
-				RemoveAttribute(entityDecl, new TopLevelTypeName("System.Runtime.CompilerServices", "AsyncStateMachineAttribute"));
-				RemoveAttribute(entityDecl, new TopLevelTypeName("System.Diagnostics", "DebuggerStepThroughAttribute"));
+			} catch (Exception innerException) {
+				throw new DecompilerException(methodDefinition, innerException);
 			}
 		}
 

ICSharpCode.Decompiler/DecompilerException.cs

@@ -17,7 +17,14 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
+using System.Security;
+using System.Text;
+using ICSharpCode.Decompiler.TypeSystem;
 using Mono.Cecil;
 
 namespace ICSharpCode.Decompiler
@@ -27,16 +34,134 @@ namespace ICSharpCode.Decompiler
 	/// </summary>
 	public class DecompilerException : Exception, ISerializable
 	{
-		public MethodDefinition DecompiledMethod { get; set; }
+		public AssemblyNameDefinition AssemblyName => DecompiledMethod.Module.Assembly.Name;
+
+		public string FileName => DecompiledMethod.Module.FileName;
+
+		public FullTypeName DecompiledType => new FullTypeName(DecompiledMethod.DeclaringType.FullName);
+
+		public MethodDefinition DecompiledMethod { get; }
 		
 		public DecompilerException(MethodDefinition decompiledMethod, Exception innerException) 
 			: base("Error decompiling " + decompiledMethod.FullName + Environment.NewLine, innerException)
 		{
+			this.DecompiledMethod = decompiledMethod;
 		}
 
 		// This constructor is needed for serialization.
 		protected DecompilerException(SerializationInfo info, StreamingContext context) : base(info, context)
 		{
 		}
+
+		public override string StackTrace => GetStackTrace(this);
+
+		public override string ToString() => ToString(this);
+
+		string ToString(Exception exception)
+		{
+			if (exception == null)
+				throw new ArgumentNullException("exception");
+			string exceptionType = GetTypeName(exception);
+			string stacktrace = GetStackTrace(exception);
+			while (exception.InnerException != null) {
+				exception = exception.InnerException;
+
+				stacktrace = GetStackTrace(exception) + Environment.NewLine
+					+ "-- continuing with outer exception (" + exceptionType + ") --" + Environment.NewLine
+					+ stacktrace;
+				exceptionType = GetTypeName(exception);
+			}
+			return this.Message
+				+ " ---> " + exceptionType + ": " + exception.Message + Environment.NewLine
+				+ stacktrace;
+		}
+
+		static string GetTypeName(Exception exception)
+		{
+			string type = exception.GetType().FullName;
+			if (exception is ExternalException || exception is IOException)
+				return type + " (" + Marshal.GetHRForException(exception).ToString("x8") + ")";
+			else
+				return type;
+		}
+
+		static string GetStackTrace(Exception exception)
+		{
+			// Output stacktrace in custom format (very similar to Exception.StackTrace property on English systems).
+			// Include filenames where available, but no paths.
+			StackTrace stackTrace = new StackTrace(exception, true);
+			StringBuilder b = new StringBuilder();
+			for (int i = 0; i < stackTrace.FrameCount; i++) {
+				StackFrame frame = stackTrace.GetFrame(i);
+				MethodBase method = frame.GetMethod();
+				if (method == null)
+					continue;
+
+				if (b.Length > 0)
+					b.AppendLine();
+
+				b.Append("   at ");
+				Type declaringType = method.DeclaringType;
+				if (declaringType != null) {
+					b.Append(declaringType.FullName.Replace('+', '.'));
+					b.Append('.');
+				}
+				b.Append(method.Name);
+				// output type parameters, if any
+				if ((method is MethodInfo) && ((MethodInfo)method).IsGenericMethod) {
+					Type[] genericArguments = ((MethodInfo)method).GetGenericArguments();
+					b.Append('[');
+					for (int j = 0; j < genericArguments.Length; j++) {
+						if (j > 0)
+							b.Append(',');
+						b.Append(genericArguments[j].Name);
+					}
+					b.Append(']');
+				}
+
+				// output parameters, if any
+				b.Append('(');
+				ParameterInfo[] parameters = method.GetParameters();
+				for (int j = 0; j < parameters.Length; j++) {
+					if (j > 0)
+						b.Append(", ");
+					if (parameters[j].ParameterType != null) {
+						b.Append(parameters[j].ParameterType.Name);
+					} else {
+						b.Append('?');
+					}
+					if (!string.IsNullOrEmpty(parameters[j].Name)) {
+						b.Append(' ');
+						b.Append(parameters[j].Name);
+					}
+				}
+				b.Append(')');
+
+				// source location
+				if (frame.GetILOffset() >= 0) {
+					string filename = null;
+					try {
+						string fullpath = frame.GetFileName();
+						if (fullpath != null)
+							filename = Path.GetFileName(fullpath);
+					} catch (SecurityException) {
+						// StackFrame.GetFileName requires PathDiscovery permission
+					} catch (ArgumentException) {
+						// Path.GetFileName might throw on paths with invalid chars
+					}
+					b.Append(" in ");
+					if (filename != null) {
+						b.Append(filename);
+						b.Append(":line ");
+						b.Append(frame.GetFileLineNumber());
+					} else {
+						b.Append("offset ");
+						b.Append(frame.GetILOffset());
+					}
+				}
+			}
+
+			return b.ToString();
+		}
 	}
 }

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -245,6 +245,7 @@
     <Compile Include="CSharp\TypeSystem\SimpleTypeOrNamespaceReference.cs" />
     <Compile Include="CSharp\TypeSystem\TypeOrNamespaceReference.cs" />
     <Compile Include="CSharp\TypeSystem\UsingScope.cs" />
+    <Compile Include="DecompilerException.cs" />
     <Compile Include="DecompilerSettings.cs" />
     <Compile Include="CSharp\Transforms\ContextTrackingVisitor.cs" />
     <Compile Include="CSharp\Transforms\DecimalConstantTransform.cs" />