Support C# 7.3 pattern-based fixed statement.

ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.cs

@@ -354,6 +354,15 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty
 			return ptr->ToString();
 		}
 
+#if CS73
+		public unsafe void PinSpan(Span<int> span)
+		{
+			fixed (int* ptr = span) {
+				UsePointer(ptr);
+			}
+		}
+#endif
+
 		public unsafe string StackAlloc(int count)
 		{
 			char* ptr = stackalloc char[count];

ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs

@@ -1034,5 +1034,28 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
 			return base.VisitBinaryOperatorExpression(expr);
 		}
 		#endregion
+
+		#region C# 7.3 pattern based fixed
+		static readonly Expression addressOfPinnableReference = new UnaryOperatorExpression {
+			Operator = UnaryOperatorType.AddressOf,
+			Expression = new InvocationExpression {
+				Target = new MemberReferenceExpression(new AnyNode("target"), "GetPinnableReference"),
+				Arguments = { }
+			}
+		};
+
+		public override AstNode VisitFixedStatement(FixedStatement fixedStatement)
+		{
+			if (context.Settings.PatternBasedFixedStatement) {
+				foreach (var v in fixedStatement.Variables) {
+					var m = addressOfPinnableReference.Match(v.Initializer);
+					if (m.Success) {
+						v.Initializer = m.Get<Expression>("target").Single().Detach();
+					}
+				}
+			}
+			return base.VisitFixedStatement(fixedStatement);
+		}
+		#endregion
 	}
 }

ICSharpCode.Decompiler/DecompilerSettings.cs

@@ -104,6 +104,7 @@ namespace ICSharpCode.Decompiler
 				introduceUnmanagedConstraint = false;
 				stackAllocInitializers = false;
 				tupleComparisons = false;
+				patternBasedFixedStatement = false;
 			}
 			if (languageVersion < CSharp.LanguageVersion.CSharp8_0) {
 				nullableReferenceTypes = false;
@@ -117,7 +118,7 @@ namespace ICSharpCode.Decompiler
 		{
 			if (nullableReferenceTypes || readOnlyMethods || asyncEnumerator || asyncUsingAndForEachStatement)
 				return CSharp.LanguageVersion.CSharp8_0;
-			if (introduceUnmanagedConstraint || tupleComparisons || stackAllocInitializers)
+			if (introduceUnmanagedConstraint || tupleComparisons || stackAllocInitializers || patternBasedFixedStatement)
 				return CSharp.LanguageVersion.CSharp7_3;
 			if (introduceRefModifiersOnStructs || introduceReadonlyAndInModifiers || nonTrailingNamedArguments || refExtensionMethods)
 				return CSharp.LanguageVersion.CSharp7_2;
@@ -926,6 +927,23 @@ namespace ICSharpCode.Decompiler
 			}
 		}
 
+		bool patternBasedFixedStatement = true;
+
+		/// <summary>
+		/// Gets/Sets whether C# 7.3 pattern based fixed statement should be used.
+		/// </summary>
+		[Category("C# 7.3 / VS 2017.7")]
+		[Description("DecompilerSettings.UsePatternBasedFixedStatement")]
+		public bool PatternBasedFixedStatement {
+			get { return patternBasedFixedStatement; }
+			set {
+				if (patternBasedFixedStatement != value) {
+					patternBasedFixedStatement = value;
+					OnPropertyChanged();
+				}
+			}
+		}
+
 		bool tupleTypes = true;
 
 		/// <summary>

ILSpy/TreeNodes/AssemblyTreeNode.cs

@@ -126,8 +126,6 @@ namespace ICSharpCode.ILSpy.TreeNodes
 			RaisePropertyChanged("Tooltip");
 			if (moduleTask.IsFaulted) {
 				RaisePropertyChanged("ShowExpander"); // cannot expand assemblies with load error
-													  // observe the exception so that the Task's finalizer doesn't re-throw it
-				try { moduleTask.Wait(); } catch (AggregateException) { }
 			} else {
 				RaisePropertyChanged("Text"); // shortname might have changed
 			}