Interface implementations in TS

ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs

@@ -66,9 +66,8 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		[OneTimeSetUp]
 		public void FixtureSetUp()
 		{
-			// use "IncludeInternalMembers" so that Cecil results match C# parser results
-			MetadataLoader loader = new MetadataLoader() { IncludeInternalMembers = true };
-			compilation = new SimpleCompilation(TestAssembly, Mscorlib);
+			compilation = new SimpleCompilation(TestAssembly,
+				Mscorlib.WithOptions(TypeSystemOptions.Default | TypeSystemOptions.OnlyPublicAPI));
 		}
 
 		protected ICompilation compilation;
@@ -973,19 +972,19 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.AreEqual(1.0, arg.Value);
 		}
 
-		[Test, Ignore("interface impls need redesign")]
+		/* TS no longer provides implicitly implemented interface members.
+		[Test]
 		public void ImplicitImplementationOfUnifiedMethods()
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ImplementationOfUnifiedMethods));
 			IMethod test = type.Methods.Single(m => m.Name == "Test");
-			/*
 			Assert.AreEqual(2, test.ImplementedInterfaceMembers.Count);
 			Assert.AreEqual("Int32", ((IMethod)test.ImplementedInterfaceMembers[0]).Parameters.Single().Type.Name);
 			Assert.AreEqual("Int32", ((IMethod)test.ImplementedInterfaceMembers[1]).Parameters.Single().Type.Name);
 			Assert.AreEqual("T", ((IMethod)test.ImplementedInterfaceMembers[0].MemberDefinition).Parameters.Single().Type.Name);
 			Assert.AreEqual("S", ((IMethod)test.ImplementedInterfaceMembers[1].MemberDefinition).Parameters.Single().Type.Name);
-			*/
 		}
+		*/
 
 		[Test]
 		public void StaticityOfEventAccessors()
@@ -1112,6 +1111,7 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.AreEqual(Accessibility.Protected, prop.Setter.Accessibility);
 		}
 
+		/* TS no longer provides implicit interface impls
 		[Test]
 		public void PropertyAccessorsShouldBeReportedAsImplementingInterfaceAccessors()
 		{
@@ -1121,6 +1121,7 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.That(prop.Getter.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.get_Prop" }));
 			Assert.That(prop.Setter.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.set_Prop" }));
 		}
+		*/
 
 		[Test]
 		public void PropertyThatImplementsInterfaceIsNotVirtual()
@@ -1143,6 +1144,7 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.IsFalse(prop.IsOverridable);
 		}
 
+		/* The TS no longer provides implicit interface impls.
 		[Test]
 		public void IndexerAccessorsShouldBeReportedAsImplementingTheCorrectInterfaceAccessors()
 		{
@@ -1172,46 +1174,45 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.That(ix3.Setter.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithIndexers.set_Item" }));
 			Assert.That(ix3.Setter.ImplementedInterfaceMembers.All(m => ((IMethod)m).Parameters.Select(p => p.Type.GetDefinition().KnownTypeCode).SequenceEqual(new[] { KnownTypeCode.Int32, KnownTypeCode.Int32, KnownTypeCode.Int32 })));
 		}
+		*/
 
-		[Test, Ignore("interface impls need redesign")]
+		[Test]
 		public void ExplicitIndexerImplementationReturnsTheCorrectMembers()
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsIndexersExplicitly));
 
 			Assert.That(type.Properties.All(p => p.SymbolKind == SymbolKind.Indexer));
-			/*
-			Assert.That(type.Properties.All(p => p.ImplementedInterfaceMembers.Count == 1));
-			Assert.That(type.Properties.All(p => p.Getter.ImplementedInterfaceMembers.Count == 1));
-			Assert.That(type.Properties.All(p => p.Setter.ImplementedInterfaceMembers.Count == 1));
-			*/
+
+			Assert.That(type.Properties.All(p => p.ExplicitlyImplementedInterfaceMembers.Count() == 1));
+			Assert.That(type.Properties.All(p => p.Getter.ExplicitlyImplementedInterfaceMembers.Count() == 1));
+			Assert.That(type.Properties.All(p => p.Setter.ExplicitlyImplementedInterfaceMembers.Count() == 1));
 		}
 
-		[Test, Ignore("interface impls need redesign")]
+		[Test]
 		public void ExplicitDisposableImplementation()
 		{
 			ITypeDefinition disposable = GetTypeDefinition(typeof(ExplicitDisposableImplementation));
 			IMethod method = disposable.Methods.Single(m => !m.IsConstructor);
 			Assert.IsTrue(method.IsExplicitInterfaceImplementation);
-			Assert.AreEqual("System.IDisposable.Dispose", method.ImplementedInterfaceMembers.Single().FullName);
+			Assert.AreEqual("System.IDisposable.Dispose", method.ExplicitlyImplementedInterfaceMembers.Single().FullName);
 		}
 
-		[Test, Ignore("interface impls need redesign")]
+		[Test]
 		public void ExplicitImplementationOfUnifiedMethods()
 		{
-			/*
 			IType type = compilation.FindType(typeof(ExplicitGenericInterfaceImplementationWithUnifiableMethods<int, int>));
 			Assert.AreEqual(2, type.GetMethods(m => m.IsExplicitInterfaceImplementation).Count());
 			foreach (IMethod method in type.GetMethods(m => m.IsExplicitInterfaceImplementation)) {
-				Assert.AreEqual(1, method.ImplementedInterfaceMembers.Count, method.ToString());
+				Assert.AreEqual(1, method.ExplicitlyImplementedInterfaceMembers.Count(), method.ToString());
 				Assert.AreEqual("System.Int32", method.Parameters.Single().Type.ReflectionName);
-				IMethod interfaceMethod = (IMethod)method.ImplementedInterfaceMembers.Single();
+				IMethod interfaceMethod = (IMethod)method.ExplicitlyImplementedInterfaceMembers.Single();
 				Assert.AreEqual("System.Int32", interfaceMethod.Parameters.Single().Type.ReflectionName);
 				var genericParamType = ((IMethod)method.MemberDefinition).Parameters.Single().Type;
 				var interfaceGenericParamType = ((IMethod)interfaceMethod.MemberDefinition).Parameters.Single().Type;
 				Assert.AreEqual(TypeKind.TypeParameter, genericParamType.Kind);
 				Assert.AreEqual(TypeKind.TypeParameter, interfaceGenericParamType.Kind);
 				Assert.AreEqual(genericParamType.ReflectionName, interfaceGenericParamType.ReflectionName);
-			}*/
+			}
 		}
 		
 		[Test]
@@ -1224,11 +1225,11 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.IsTrue(implMethod1.IsExplicitInterfaceImplementation);
 			Assert.IsTrue(implMethod2.IsExplicitInterfaceImplementation);
 
-			IMethod interfaceMethod1 = (IMethod)implMethod1.ImplementedInterfaceMembers.Single();
+			IMethod interfaceMethod1 = (IMethod)implMethod1.ExplicitlyImplementedInterfaceMembers.Single();
 			Assert.AreEqual(genericInterfaceOfString, interfaceMethod1.DeclaringType);
 			Assert.IsTrue(!interfaceMethod1.Parameters[1].IsRef);
 
-			IMethod interfaceMethod2 = (IMethod)implMethod2.ImplementedInterfaceMembers.Single();
+			IMethod interfaceMethod2 = (IMethod)implMethod2.ExplicitlyImplementedInterfaceMembers.Single();
 			Assert.AreEqual(genericInterfaceOfString, interfaceMethod2.DeclaringType);
 			Assert.IsTrue(interfaceMethod2.Parameters[1].IsRef);
 		}
@@ -1238,9 +1239,9 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsPropertyExplicitly));
 			var prop = type.Properties.Single();
-			Assert.That(prop.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.Prop" }));
-			Assert.That(prop.Getter.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.get_Prop" }));
-			Assert.That(prop.Setter.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.set_Prop" }));
+			Assert.That(prop.ExplicitlyImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.Prop" }));
+			Assert.That(prop.Getter.ExplicitlyImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.get_Prop" }));
+			Assert.That(prop.Setter.ExplicitlyImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IInterfaceWithProperty.set_Prop" }));
 		}
 
 		[Test]
@@ -1253,6 +1254,7 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.IsTrue(prop.Setter.IsExplicitInterfaceImplementation);
 		}
 
+		/* The TS no longer provides implicit interface impls.
 		[Test]
 		public void EventAccessorsShouldBeReportedAsImplementingInterfaceAccessors()
 		{
@@ -1272,15 +1274,16 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.That(evt.AddAccessor.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.add_Event" }));
 			Assert.That(evt.RemoveAccessor.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.remove_Event" }));
 		}
+		*/
 
 		[Test]
 		public void ExplicitlyImplementedEventsShouldBeReportedAsBeingImplemented()
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsEventExplicitly));
 			var evt = type.Events.Single();
-			Assert.That(evt.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.Event" }));
-			Assert.That(evt.AddAccessor.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.add_Event" }));
-			Assert.That(evt.RemoveAccessor.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.remove_Event" }));
+			Assert.That(evt.ExplicitlyImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.Event" }));
+			Assert.That(evt.AddAccessor.ExplicitlyImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.add_Event" }));
+			Assert.That(evt.RemoveAccessor.ExplicitlyImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.Decompiler.Tests.TypeSystem.IHasEvent.remove_Event" }));
 		}
 
 		[Test]
@@ -1292,16 +1295,16 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			var prop = type.Properties.Single(p => p.Name == "Prop");
 			var evt = type.Events.Single(e => e.Name == "Evt");
 
-			Assert.That(method.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(indexer.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(indexer.Getter.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(indexer.Setter.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(prop.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(prop.Getter.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(prop.Setter.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(evt.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(evt.AddAccessor.ImplementedInterfaceMembers, Is.Empty);
-			Assert.That(evt.RemoveAccessor.ImplementedInterfaceMembers, Is.Empty);
+			Assert.That(method.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(indexer.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(indexer.Getter.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(indexer.Setter.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(prop.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(prop.Getter.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(prop.Setter.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(evt.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(evt.AddAccessor.ExplicitlyImplementedInterfaceMembers, Is.Empty);
+			Assert.That(evt.RemoveAccessor.ExplicitlyImplementedInterfaceMembers, Is.Empty);
 		}
 
 		[Test]
@@ -1422,45 +1425,43 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			Assert.AreEqual((short)default(MyEnum), field.ConstantValue);
 		}
 
-		[Test, Ignore("interface impls need redesign")]
+		[Test]
 		public void ExplicitImplementation()
 		{
-			/*
 				var type = GetTypeDefinition(typeof(ExplicitImplementationTests));
 				var itype = GetTypeDefinition(typeof(IExplicitImplementationTests));
 
-				var methods = type.GetMethods(m => m.Name == "M").ToList();
+				var methods = type.GetMethods(m => m.Name == "M" || m.Name.EndsWith(".M")).ToList();
 				var imethod = itype.GetMethods(m => m.Name == "M").Single();
-				Assert.That(methods.Select(m => m.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(methods.SelectMany(m => m.ImplementedInterfaceMembers).Single(), imethod);
+				Assert.That(methods.Select(m => m.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(methods.SelectMany(m => m.ExplicitlyImplementedInterfaceMembers).Single(), imethod);
 
-				var properties = type.GetProperties(p => p.Name == "P").ToList();
+				var properties = type.GetProperties(p => p.Name == "P" || p.Name.EndsWith(".P")).ToList();
 				var iproperty = itype.GetProperties(m => m.Name == "P").Single();
-				Assert.That(properties.Select(p => p.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(properties.SelectMany(p => p.ImplementedInterfaceMembers).Single(), iproperty);
-				Assert.That(properties.Select(p => p.Getter.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(properties.SelectMany(p => p.Getter.ImplementedInterfaceMembers).Single(), iproperty.Getter);
-				Assert.That(properties.Select(p => p.Setter.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(properties.SelectMany(p => p.Setter.ImplementedInterfaceMembers).Single(), iproperty.Setter);
-
-				var indexers = type.GetProperties(p => p.Name == "Item").ToList();
+				Assert.That(properties.Select(p => p.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(properties.SelectMany(p => p.ExplicitlyImplementedInterfaceMembers).Single(), iproperty);
+				Assert.That(properties.Select(p => p.Getter.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(properties.SelectMany(p => p.Getter.ExplicitlyImplementedInterfaceMembers).Single(), iproperty.Getter);
+				Assert.That(properties.Select(p => p.Setter.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(properties.SelectMany(p => p.Setter.ExplicitlyImplementedInterfaceMembers).Single(), iproperty.Setter);
+
+				var indexers = type.GetProperties(p => p.Name == "Item" || p.Name.EndsWith(".Item")).ToList();
 				var iindexer = itype.GetProperties(m => m.Name == "Item").Single();
-				Assert.That(indexers.Select(p => p.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(indexers.SelectMany(p => p.ImplementedInterfaceMembers).Single(), iindexer);
-				Assert.That(indexers.Select(p => p.Getter.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(indexers.SelectMany(p => p.Getter.ImplementedInterfaceMembers).Single(), iindexer.Getter);
-				Assert.That(indexers.Select(p => p.Setter.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(indexers.SelectMany(p => p.Setter.ImplementedInterfaceMembers).Single(), iindexer.Setter);
-
-				var events = type.GetEvents(e => e.Name == "E").ToList();
+				Assert.That(indexers.Select(p => p.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(indexers.SelectMany(p => p.ExplicitlyImplementedInterfaceMembers).Single(), iindexer);
+				Assert.That(indexers.Select(p => p.Getter.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(indexers.SelectMany(p => p.Getter.ExplicitlyImplementedInterfaceMembers).Single(), iindexer.Getter);
+				Assert.That(indexers.Select(p => p.Setter.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(indexers.SelectMany(p => p.Setter.ExplicitlyImplementedInterfaceMembers).Single(), iindexer.Setter);
+
+				var events = type.GetEvents(e => e.Name == "E" || e.Name.EndsWith(".E")).ToList();
 				var ievent = itype.GetEvents(m => m.Name == "E").Single();
-				Assert.That(events.Select(e => e.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(events.SelectMany(e => e.ImplementedInterfaceMembers).Single(), ievent);
-				Assert.That(events.Select(e => e.AddAccessor.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(events.SelectMany(e => e.AddAccessor.ImplementedInterfaceMembers).Single(), ievent.AddAccessor);
-				Assert.That(events.Select(e => e.RemoveAccessor.ImplementedInterfaceMembers.Count).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
-				Assert.AreEqual(events.SelectMany(e => e.RemoveAccessor.ImplementedInterfaceMembers).Single(), ievent.RemoveAccessor);
-			*/
+				Assert.That(events.Select(e => e.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(events.SelectMany(e => e.ExplicitlyImplementedInterfaceMembers).Single(), ievent);
+				Assert.That(events.Select(e => e.AddAccessor.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(events.SelectMany(e => e.AddAccessor.ExplicitlyImplementedInterfaceMembers).Single(), ievent.AddAccessor);
+				Assert.That(events.Select(e => e.RemoveAccessor.ExplicitlyImplementedInterfaceMembers.Count()).ToList(), Is.EquivalentTo(new[] { 0, 1 }));
+				Assert.AreEqual(events.SelectMany(e => e.RemoveAccessor.ExplicitlyImplementedInterfaceMembers).Single(), ievent.RemoveAccessor);
 		}
 
 		[Test]

ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemTestCase.cs

@@ -302,6 +302,12 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		int this[T x] { get; set; }
 	}
 
+	public interface IInterfaceWithRenamedIndexer
+	{
+		[IndexerName("NewName")]
+		int this[int x] { get; set; }
+	}
+
 	public class ClassThatImplementsIndexers : IInterfaceWithIndexers, IGenericInterfaceWithIndexer<int>
 	{
 		public int this[int x] { get { return 0; } set { } }
@@ -309,12 +315,13 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		public int this[int x, int y] { get { return 0; } set { } }
 	}
 
-	public class ClassThatImplementsIndexersExplicitly : IInterfaceWithIndexers, IGenericInterfaceWithIndexer<int>
+	public class ClassThatImplementsIndexersExplicitly : IInterfaceWithIndexers, IGenericInterfaceWithIndexer<int>, IInterfaceWithRenamedIndexer
 	{
 		int IInterfaceWithIndexers.this[int x] { get { return 0; } set { } }
 		int IGenericInterfaceWithIndexer<int>.this[int x] { get { return 0; } set { } }
 		int IInterfaceWithIndexers.this[string x] { get { return 0; } set { } }
 		int IInterfaceWithIndexers.this[int x, int y] { get { return 0; } set { } }
+		int IInterfaceWithRenamedIndexer.this[int x] { get { return 0; } set { } }
 	}
 
 	public interface IHasEvent

ICSharpCode.Decompiler/CSharp/CallBuilder.cs

@@ -325,7 +325,7 @@ namespace ICSharpCode.Decompiler.CSharp
 
 						// HACK : convert this.Dispose() to ((IDisposable)this).Dispose(), if Dispose is an explicitly implemented interface method.
 						if (method.IsExplicitInterfaceImplementation && target.Expression is ThisReferenceExpression) {
-							var interfaceMember = method.ImplementedInterfaceMembers.First();
+							var interfaceMember = method.ExplicitlyImplementedInterfaceMembers.First();
 							var castExpression = new CastExpression(expressionBuilder.ConvertType(interfaceMember.DeclaringType), target.Expression);
 							methodName = interfaceMember.Name;
 							targetExpr = new MemberReferenceExpression(castExpression, methodName);

ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs

@@ -130,7 +130,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 				get { return this; }
 			}
 
-			IEnumerable<IMember> IMember.ImplementedInterfaceMembers {
+			IEnumerable<IMember> IMember.ExplicitlyImplementedInterfaceMembers {
 				get { return EmptyList<IMember>.Instance; }
 			}
 			

ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs

@@ -399,7 +399,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 						var isCompletedProperty = (isCompletedRR is MemberResolveResult ? ((MemberResolveResult)isCompletedRR).Member as IProperty : null);
 						if (isCompletedProperty != null && (!isCompletedProperty.ReturnType.IsKnownType(KnownTypeCode.Boolean) || !isCompletedProperty.CanGet))
 							isCompletedProperty = null;
-
+						/*
 						var interfaceOnCompleted = compilation.FindType(KnownTypeCode.INotifyCompletion).GetMethods().FirstOrDefault(x => x.Name == "OnCompleted");
 						var interfaceUnsafeOnCompleted = compilation.FindType(KnownTypeCode.ICriticalNotifyCompletion).GetMethods().FirstOrDefault(x => x.Name == "UnsafeOnCompleted");
 
@@ -415,6 +415,10 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 						}
 
 						return new AwaitResolveResult(awaitResultType, getAwaiterInvocation, getAwaiterInvocation.Type, isCompletedProperty, onCompletedMethod, getResultMethod);
+						*/
+						// Not adjusted to TS changes for interface impls
+						// But I believe this is dead code for ILSpy anyways...
+						throw new NotImplementedException();
 					}
 
 					default:

ICSharpCode.Decompiler/CSharp/Resolver/ReducedExtensionMethod.cs

@@ -86,9 +86,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 			}
 		}
 
-		public IEnumerable<IMember> ImplementedInterfaceMembers {
+		public IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers {
 			get {
-				return baseMethod.ImplementedInterfaceMembers;
+				return baseMethod.ExplicitlyImplementedInterfaceMembers;
 			}
 		}
 

ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs

@@ -1303,7 +1303,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax
 		AstType GetExplicitInterfaceType (IMember member)
 		{
 			if (member.IsExplicitInterfaceImplementation) {
-				var baseMember = member.ImplementedInterfaceMembers.FirstOrDefault ();
+				var baseMember = member.ExplicitlyImplementedInterfaceMembers.FirstOrDefault ();
 				if (baseMember != null)
 					return ConvertType (baseMember.DeclaringType);
 			}

ICSharpCode.Decompiler/Metadata/Dom.cs

@@ -228,10 +228,32 @@ namespace ICSharpCode.Decompiler.Metadata
 			}
 		}
 
+		public TypeSystem.IAssemblyReference WithOptions(TypeSystemOptions options)
+		{
+			return new PEFileWithOptions(this, options);
+		}
+
 		IAssembly TypeSystem.IAssemblyReference.Resolve(ITypeResolveContext context)
 		{
 			return new MetadataAssembly(context.Compilation, this, TypeSystemOptions.Default);
 		}
+
+		private class PEFileWithOptions : TypeSystem.IAssemblyReference
+		{
+			readonly PEFile peFile;
+			readonly TypeSystemOptions options;
+
+			public PEFileWithOptions(PEFile peFile, TypeSystemOptions options)
+			{
+				this.peFile = peFile;
+				this.options = options;
+			}
+
+			IAssembly TypeSystem.IAssemblyReference.Resolve(ITypeResolveContext context)
+			{
+				return new MetadataAssembly(context.Compilation, peFile, options);
+			}
+		}
 	}
 
 	public enum ResourceType

ICSharpCode.Decompiler/TypeSystem/IMember.cs

@@ -122,9 +122,24 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		IType ReturnType { get; }
 
 		/// <summary>
-		/// Gets the interface members implemented by this member (both implicitly and explicitly).
-		/// </summary>
-		IEnumerable<IMember> ImplementedInterfaceMembers { get; }
+		/// Gets the interface members explicitly implemented by this member.
+		/// </summary>
+		/// <remarks>
+		/// For methods, equivalent to (
+		///		from impl in DeclaringTypeDefinition.GetExplicitInterfaceImplementations()
+		///		where impl.Implementation == this
+		///		select impl.InterfaceMethod
+		/// ),
+		/// but may be more efficient than searching the whole list.
+		/// 
+		/// Note that it is possible for a class to implement an interface using members in a
+		/// base class unrelated to that interface:
+		///   class BaseClass { public void Dispose() {} }
+		///   class C : BaseClass, IDisposable { }
+		/// In this case, the interface member will not show up in (BaseClass.Dispose).ImplementedInterfaceMembers,
+		/// so use (C).GetInterfaceImplementations() instead to handle this case.
+		/// </remarks>
+		IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers { get; }
 		
 		/// <summary>
 		/// Gets whether this member is explicitly implementing an interface.

ICSharpCode.Decompiler/TypeSystem/ITypeDefinition.cs

@@ -131,16 +131,5 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// </summary>
 		/// <remarks>This property is used to speed up the search for extension methods.</remarks>
 		bool HasExtensionMethods { get; }
-		
-		/// <summary>
-		/// Determines how this type is implementing the specified interface member.
-		/// </summary>
-		/// <returns>
-		/// The method on this type that implements the interface member;
-		/// or null if the type does not implement the interface.
-		/// </returns>
-		IMember GetInterfaceImplementation(IMember interfaceMember);
-
-		//IEnumerable<IMember> GetImplementedInterfaces();
 	}
 }

ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractResolvedMember.cs

@@ -53,7 +53,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			get { return unresolved; }
 		}
 		
-		public IEnumerable<IMember> ImplementedInterfaceMembers {
+		public IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers {
 			get {
 				IReadOnlyList<IMember> result = LazyInit.VolatileRead(ref this.implementedInterfaceMembers);
 				if (result != null) {
@@ -85,7 +85,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 				IEnumerable<IMember> otherMembers = DeclaringTypeDefinition.Members;
 				if (SymbolKind == SymbolKind.Accessor)
 					otherMembers = DeclaringTypeDefinition.GetAccessors(options: GetMemberOptions.IgnoreInheritedMembers);
-				result = result.Where(item => !otherMembers.Any(m => m.IsExplicitInterfaceImplementation && m.ImplementedInterfaceMembers.Contains(item))).ToArray();
+				result = result.Where(item => !otherMembers.Any(m => m.IsExplicitInterfaceImplementation && m.ExplicitlyImplementedInterfaceMembers.Contains(item))).ToArray();
 
 				return result;
 			}

ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractUnresolvedMember.cs

@@ -192,7 +192,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 					foreach (IMember member in context.CurrentTypeDefinition.Members) {
 						if (!member.IsExplicitInterfaceImplementation)
 							continue;
-						var interfaceMembers = member.ImplementedInterfaceMembers.ToList();
+						var interfaceMembers = member.ExplicitlyImplementedInterfaceMembers.ToList();
 						if (interfaceMembers.Count != 1)
 							continue;
 						if (IsNonGenericMatch(member, symbolKind, name, parameterTypes)) {
@@ -223,9 +223,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 					if (explicitInterfaceTypeReference == null) {
 						if (!method.IsExplicitInterfaceImplementation)
 							return method;
-					} else if (method.IsExplicitInterfaceImplementation && method.ImplementedInterfaceMembers.Count() == 1) {
+					} else if (method.IsExplicitInterfaceImplementation && method.ExplicitlyImplementedInterfaceMembers.Count() == 1) {
 						IType explicitInterfaceType = explicitInterfaceTypeReference.Resolve(contextForMethod);
-						if (explicitInterfaceType.Equals(method.ImplementedInterfaceMembers.First().DeclaringType))
+						if (explicitInterfaceType.Equals(method.ExplicitlyImplementedInterfaceMembers.First().DeclaringType))
 							return method;
 					}
 				}

ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs

@@ -771,13 +771,15 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 				}
 			}
 			foreach (var explicitImpl in GetMembers(m => m.IsExplicitInterfaceImplementation)) {
-				foreach (var interfaceMember in explicitImpl.ImplementedInterfaceMembers) {
+				/*foreach (var interfaceMember in explicitImpl.ImplementedInterfaceMembers) {
 					foreach (int potentialMatchingIndex in signatureToIndexDict[interfaceMember]) {
 						if (interfaceMember.Equals(interfaceMembers[potentialMatchingIndex])) {
 							result[potentialMatchingIndex] = explicitImpl;
 						}
 					}
-				}
+				}*/
+				// not adjusted to TS changes; but this is dead code and about to be deleted
+				throw new NotImplementedException();
 			}
 			return result;
 		}

ICSharpCode.Decompiler/TypeSystem/Implementation/FakeMember.cs

@@ -39,7 +39,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 
 		public IType ReturnType { get; set; } = SpecialType.UnknownType;
 
-		IEnumerable<IMember> IMember.ImplementedInterfaceMembers => EmptyList<IMember>.Instance;
+		IEnumerable<IMember> IMember.ExplicitlyImplementedInterfaceMembers => EmptyList<IMember>.Instance;
 
 		bool IMember.IsExplicitInterfaceImplementation => false;
 

ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataEvent.cs

@@ -54,6 +54,11 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			name = metadata.GetString(ev.Name);
 		}
 
+		public override string ToString()
+		{
+			return $"{MetadataTokens.GetToken(handle):X8} {DeclaringType?.ReflectionName}.{Name}";
+		}
+
 		public EntityHandle MetadataToken => handle;
 		public string Name => name;
 		
@@ -83,13 +88,13 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		#endregion
 
 		public bool IsExplicitInterfaceImplementation => AnyAccessor?.IsExplicitInterfaceImplementation ?? false;
-		public IEnumerable<IMember> ImplementedInterfaceMembers => GetInterfaceMembersFromAccessor(AnyAccessor);
+		public IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers => GetInterfaceMembersFromAccessor(AnyAccessor);
 
 		internal static IEnumerable<IMember> GetInterfaceMembersFromAccessor(IMethod method)
 		{
 			if (method == null)
 				return EmptyList<IMember>.Instance;
-			return method.ImplementedInterfaceMembers.Select(m => ((IMethod)m).AccessorOwner).Where(m => m != null);
+			return method.ExplicitlyImplementedInterfaceMembers.Select(m => ((IMethod)m).AccessorOwner).Where(m => m != null);
 		}
 
 		public ITypeDefinition DeclaringTypeDefinition => AnyAccessor?.DeclaringTypeDefinition;

ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataField.cs

@@ -92,7 +92,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		TypeParameterSubstitution IMember.Substitution => TypeParameterSubstitution.Identity;
 
 		// Fields can't implement interfaces:
-		IEnumerable<IMember> IMember.ImplementedInterfaceMembers => EmptyList<IMember>.Instance;
+		IEnumerable<IMember> IMember.ExplicitlyImplementedInterfaceMembers => EmptyList<IMember>.Instance;
 		bool IMember.IsExplicitInterfaceImplementation => false;
 		bool IMember.IsVirtual => false;
 		bool IMember.IsOverride => false;

ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs

@@ -49,7 +49,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		IAttribute[] returnTypeAttributes;
 		IParameter[] parameters;
 		IType returnType;
-		IMember[] implementedInterfaceMembers;
 
 		internal MetadataMethod(MetadataAssembly assembly, MethodDefinitionHandle handle)
 		{
@@ -194,8 +193,21 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		}
 		#endregion
 
-		public IEnumerable<IMember> ImplementedInterfaceMembers => throw new NotImplementedException();
-		public bool IsExplicitInterfaceImplementation => throw new NotImplementedException();
+		public bool IsExplicitInterfaceImplementation {
+			get {
+				if (Name.IndexOf('.') < 0)
+					return false;
+				var typeDef = ((MetadataTypeDefinition)DeclaringTypeDefinition);
+				return typeDef.HasOverrides(handle);
+			}
+		}
+
+		public IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers {
+			get {
+				var typeDef = ((MetadataTypeDefinition)DeclaringTypeDefinition);
+				return typeDef.GetOverrides(handle);
+			}
+		}
 
 		IMember IMember.MemberDefinition => this;
 		IMethod IMethod.ReducedFrom => this;

ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataProperty.cs

@@ -62,11 +62,20 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			name = metadata.GetString(prop.Name);
 			if (name == (DeclaringTypeDefinition as MetadataTypeDefinition)?.DefaultMemberName) {
 				symbolKind = SymbolKind.Indexer;
+			} else if (name.IndexOf('.') >= 0) {
+				// explicit interface implementation
+				var interfaceProp = this.ExplicitlyImplementedInterfaceMembers.FirstOrDefault() as IProperty;
+				symbolKind = interfaceProp?.SymbolKind ?? SymbolKind.Property;
 			} else {
 				symbolKind = SymbolKind.Property;
 			}
 		}
 
+		public override string ToString()
+		{
+			return $"{MetadataTokens.GetToken(propertyHandle):X8} {DeclaringType?.ReflectionName}.{Name}";
+		}
+
 		public EntityHandle MetadataToken => propertyHandle;
 		public string Name => name;
 
@@ -120,13 +129,13 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		#endregion
 
 		public bool IsExplicitInterfaceImplementation => AnyAccessor?.IsExplicitInterfaceImplementation ?? false;
-		public IEnumerable<IMember> ImplementedInterfaceMembers => GetInterfaceMembersFromAccessor(AnyAccessor);
+		public IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers => GetInterfaceMembersFromAccessor(AnyAccessor);
 
 		internal static IEnumerable<IMember> GetInterfaceMembersFromAccessor(IMethod method)
 		{
 			if (method == null)
 				return EmptyList<IMember>.Instance;
-			return method.ImplementedInterfaceMembers.Select(m => ((IMethod)m).AccessorOwner).Where(m => m != null);
+			return method.ExplicitlyImplementedInterfaceMembers.Select(m => ((IMethod)m).AccessorOwner).Where(m => m != null);
 		}
 
 		public ITypeDefinition DeclaringTypeDefinition => AnyAccessor?.DeclaringTypeDefinition;

ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeDefinition.cs

@@ -211,7 +211,10 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 				var methodsCollection = metadata.GetTypeDefinition(handle).GetMethods();
 				var methodsList = new List<IMethod>(methodsCollection.Count);
 				foreach (MethodDefinitionHandle h in methodsCollection) {
-					methodsList.Add(assembly.GetDefinition(h));
+					var md = metadata.GetMethodDefinition(h);
+					if (assembly.IsVisible(md.Attributes)) {
+						methodsList.Add(assembly.GetDefinition(h));
+					}
 				}
 				if (this.Kind == TypeKind.Struct || this.Kind == TypeKind.Enum) {
 					methodsList.Add(new FakeMethod(Compilation, SymbolKind.Constructor) {
@@ -588,43 +591,28 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 		}
 		#endregion
 
-		#region GetInterfaceImplementation
-		public IMember GetInterfaceImplementation(IMember interfaceMember)
+		#region GetOverrides
+		internal IEnumerable<IMethod> GetOverrides(MethodDefinitionHandle method)
 		{
-			return GetInterfaceImplementation(new[] { interfaceMember })[0];
+			var metadata = assembly.metadata;
+			var td = metadata.GetTypeDefinition(handle);
+			foreach (var implHandle in td.GetMethodImplementations()) {
+				var impl = metadata.GetMethodImplementation(implHandle);
+				if (impl.MethodBody == method)
+					yield return assembly.ResolveMethod(impl.MethodDeclaration, new GenericContext(this.TypeParameters));
+			}
 		}
 
-		public IReadOnlyList<IMember> GetInterfaceImplementation(IReadOnlyList<IMember> interfaceMembers)
+		internal bool HasOverrides(MethodDefinitionHandle method)
 		{
-			// TODO: review the subtle rules for interface reimplementation,
-			// write tests and fix this method.
-			// Also virtual/override is going to be tricky -
-			// I think we'll need to consider the 'virtual' method first for
-			// reimplemenatation purposes, but then actually return the 'override'
-			// (as that's the method that ends up getting called)
-
-			interfaceMembers = interfaceMembers.ToList(); // avoid evaluating more than once
-
-			var result = new IMember[interfaceMembers.Count];
-			var signatureToIndexDict = new MultiDictionary<IMember, int>(SignatureComparer.Ordinal);
-			for (int i = 0; i < interfaceMembers.Count; i++) {
-				signatureToIndexDict.Add(interfaceMembers[i], i);
-			}
-			foreach (var member in GetMembers(m => !m.IsExplicitInterfaceImplementation)) {
-				foreach (int interfaceMemberIndex in signatureToIndexDict[member]) {
-					result[interfaceMemberIndex] = member;
-				}
-			}
-			foreach (var explicitImpl in GetMembers(m => m.IsExplicitInterfaceImplementation)) {
-				foreach (var interfaceMember in explicitImpl.ImplementedInterfaceMembers) {
-					foreach (int potentialMatchingIndex in signatureToIndexDict[interfaceMember]) {
-						if (interfaceMember.Equals(interfaceMembers[potentialMatchingIndex])) {
-							result[potentialMatchingIndex] = explicitImpl;
-						}
-					}
-				}
+			var metadata = assembly.metadata;
+			var td = metadata.GetTypeDefinition(handle);
+			foreach (var implHandle in td.GetMethodImplementations()) {
+				var impl = metadata.GetMethodImplementation(implHandle);
+				if (impl.MethodBody == method)
+					return true;
 			}
-			return result;
+			return false;
 		}
 		#endregion
 	}

ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs

@@ -155,19 +155,14 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation
 			get { return baseMember.Attributes; }
 		}
 		
-		IReadOnlyList<IMember> implementedInterfaceMembers;
-		
-		public IEnumerable<IMember> ImplementedInterfaceMembers {
+		public IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers {
 			get {
-				return LazyInitializer.EnsureInitialized(ref implementedInterfaceMembers, FindImplementedInterfaceMembers);
+				// Note: if the interface is generic, then the interface members should already be specialized,
+				// so we only need to append our substitution.
+				return baseMember.ExplicitlyImplementedInterfaceMembers.Select(m => m.Specialize(substitution));
 			}
 		}
 		
-		IReadOnlyList<IMember> FindImplementedInterfaceMembers()
-		{
-			return baseMember.ImplementedInterfaceMembers.Select(m => m.Specialize(substitution)).ToArray();
-		}
-		
 		public bool IsExplicitInterfaceImplementation {
 			get { return baseMember.IsExplicitInterfaceImplementation; }
 		}

ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs

@@ -173,8 +173,8 @@ namespace ICSharpCode.Decompiler.TypeSystem
 			get { return baseMethod.ReturnType; }
 		}
 
-		public IEnumerable<IMember> ImplementedInterfaceMembers {
-			get { return baseMethod.ImplementedInterfaceMembers; }
+		public IEnumerable<IMember> ExplicitlyImplementedInterfaceMembers {
+			get { return baseMethod.ExplicitlyImplementedInterfaceMembers; }
 		}
 
 		public bool IsExplicitInterfaceImplementation {

ILSpy/Languages/ILAstLanguage.cs

@@ -87,9 +87,9 @@ namespace ICSharpCode.ILSpy
 			{
 				base.DecompileMethod(method, output, options);
 				var metadata = method.Module.Metadata;
-				if (!method.Handle.HasBody(metadata))
-					return;
 				var methodDef = metadata.GetMethodDefinition(method.Handle);
+				if (!methodDef.HasBody())
+					return;
 				var typeSystem = new DecompilerTypeSystem(method.Module);
 				ILReader reader = new ILReader(typeSystem);
 				var methodBody = method.Module.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
@@ -110,9 +110,9 @@ namespace ICSharpCode.ILSpy
 			{
 				base.DecompileMethod(method, output, options);
 				var metadata = method.Module.Metadata;
-				if (!method.Handle.HasBody(metadata))
-					return;
 				var methodDef = metadata.GetMethodDefinition(method.Handle);
+				if (!methodDef.HasBody())
+					return;
 				var typeSystem = new DecompilerTypeSystem(method.Module);
 				var specializingTypeSystem = typeSystem.GetSpecializingTypeSystem(new SimpleTypeResolveContext(typeSystem.ResolveAsMethod(method.Handle)));
 				var reader = new ILReader(specializingTypeSystem);

ILSpy/SearchStrategies.cs

@@ -325,9 +325,11 @@ namespace ICSharpCode.ILSpy
 			if (module == null)
 				return false;
 			var metadata = module.Metadata;
-			if (m.IsNil || !m.HasBody(metadata))
+			if (m.IsNil)
 				return false;
 			var methodDefinition = metadata.GetMethodDefinition(m);
+			if (!methodDefinition.HasBody())
+				return false;
 			var blob = module.Reader.GetMethodBody(methodDefinition.RelativeVirtualAddress).GetILReader();
 			if (searchTermLiteralType == TypeCode.Int64) {
 				long val = (long)searchTermLiteralValue;

ILSpy/TreeNodes/Analyzer/AnalyzedMethodTreeNode.cs

@@ -45,7 +45,7 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 
 		protected override void LoadChildren()
 		{
-			if (analyzedMethod.HasBody(module.Metadata))
+			if (module.Metadata.GetMethodDefinition(analyzedMethod).HasBody())
 				this.Children.Add(new AnalyzedMethodUsesTreeNode(module, analyzedMethod));
 
 			/*if (analyzedMethod.HasFlag(MethodAttributes.Virtual) && !(analyzedMethod.HasFlag(MethodAttributes.NewSlot) && analyzedMethod.HasFlag(MethodAttributes.Final)))