Rename InterfaceImplementations -> ImplementedInterfaceMembers.

ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs

@@ -131,7 +131,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return null; }
 			}
 			
-			IList<IMember> IMember.InterfaceImplementations {
+			IList<IMember> IMember.ImplementedInterfaceMembers {
 				get { return EmptyList<IMember>.Instance; }
 			}
 			

ICSharpCode.NRefactory.CSharp/TypeSystem/MethodTypeParameterWithInheritedConstraints.cs

@@ -43,8 +43,8 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 						break;
 					}
 				}
-			} else if (parentMethod.IsExplicitInterfaceImplementation && parentMethod.InterfaceImplementations.Count == 1) {
-				baseMethod = parentMethod.InterfaceImplementations[0] as IMethod;
+			} else if (parentMethod.IsExplicitInterfaceImplementation && parentMethod.ImplementedInterfaceMembers.Count == 1) {
+				baseMethod = parentMethod.ImplementedInterfaceMembers[0] as IMethod;
 			}
 			if (baseMethod != null && index < baseMethod.TypeParameters.Count)
 				return baseMethod.TypeParameters[index];

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeSystemConvertVisitorTests.cs

@@ -67,7 +67,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 			ITypeDefinition disposable = GetTypeDefinition(typeof(NRefactory.TypeSystem.TestCase.ExplicitDisposableImplementation));
 			IMethod method = disposable.Methods.Single(m => m.Name == "Dispose");
 			Assert.IsTrue(method.IsExplicitInterfaceImplementation);
-			Assert.AreEqual("System.IDisposable.Dispose", method.InterfaceImplementations.Single().FullName);
+			Assert.AreEqual("System.IDisposable.Dispose", method.ImplementedInterfaceMembers.Single().FullName);
 		}
 		
 		[Test]
@@ -80,11 +80,11 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 			Assert.IsTrue(implMethod1.IsExplicitInterfaceImplementation);
 			Assert.IsTrue(implMethod2.IsExplicitInterfaceImplementation);
 			
-			IMethod interfaceMethod1 = (IMethod)implMethod1.InterfaceImplementations.Single();
+			IMethod interfaceMethod1 = (IMethod)implMethod1.ImplementedInterfaceMembers.Single();
 			Assert.AreEqual(genericInterfaceOfString, interfaceMethod1.DeclaringType);
 			Assert.IsTrue(!interfaceMethod1.Parameters[1].IsRef);
 			
-			IMethod interfaceMethod2 = (IMethod)implMethod2.InterfaceImplementations.Single();
+			IMethod interfaceMethod2 = (IMethod)implMethod2.ImplementedInterfaceMembers.Single();
 			Assert.AreEqual(genericInterfaceOfString, interfaceMethod2.DeclaringType);
 			Assert.IsTrue(interfaceMethod2.Parameters[1].IsRef);
 		}
@@ -95,9 +95,9 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 			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.InterfaceImplementations.Count, method.ToString());
+				Assert.AreEqual(1, method.ImplementedInterfaceMembers.Count, method.ToString());
 				Assert.AreEqual("System.Int32", method.Parameters.Single().Type.ReflectionName);
-				IMethod interfaceMethod = (IMethod)method.InterfaceImplementations.Single();
+				IMethod interfaceMethod = (IMethod)method.ImplementedInterfaceMembers.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;

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs

@@ -682,11 +682,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ImplementationOfUnifiedMethods));
 			IMethod test = type.Methods.Single(m => m.Name == "Test");
-			Assert.AreEqual(2, test.InterfaceImplementations.Count);
-			Assert.AreEqual("Int32", ((IMethod)test.InterfaceImplementations[0]).Parameters.Single().Type.Name);
-			Assert.AreEqual("Int32", ((IMethod)test.InterfaceImplementations[1]).Parameters.Single().Type.Name);
-			Assert.AreEqual("T", ((IMethod)test.InterfaceImplementations[0].MemberDefinition).Parameters.Single().Type.Name);
-			Assert.AreEqual("S", ((IMethod)test.InterfaceImplementations[1].MemberDefinition).Parameters.Single().Type.Name);
+			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);
 		}
 	}
 }

ICSharpCode.NRefactory/Documentation/IdStringProvider.cs

@@ -60,8 +60,8 @@ namespace ICSharpCode.NRefactory.Documentation
 			IMember member = (IMember)entity;
 			AppendTypeName(b, member.DeclaringType, false);
 			b.Append('.');
-			if (member.IsExplicitInterfaceImplementation && member.Name.IndexOf('.') < 0 && member.InterfaceImplementations.Count == 1) {
-				AppendTypeName(b, member.InterfaceImplementations[0].DeclaringType, true);
+			if (member.IsExplicitInterfaceImplementation && member.Name.IndexOf('.') < 0 && member.ImplementedInterfaceMembers.Count == 1) {
+				AppendTypeName(b, member.ImplementedInterfaceMembers[0].DeclaringType, true);
 				b.Append('#');
 			}
 			b.Append(member.Name.Replace('.', '#'));

ICSharpCode.NRefactory/TypeSystem/IMember.cs

@@ -105,7 +105,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <summary>
 		/// Gets the interface members implemented by this member (both implicitly and explicitly).
 		/// </summary>
-		IList<IMember> InterfaceImplementations { get; }
+		IList<IMember> ImplementedInterfaceMembers { get; }
 		
 		/// <summary>
 		/// Gets whether this member is explicitly implementing an interface.

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		protected new readonly IUnresolvedMember unresolved;
 		protected readonly ITypeResolveContext context;
 		volatile IType returnType;
-		IList<IMember> interfaceImplementations;
+		IList<IMember> implementedInterfaceMembers;
 		
 		protected AbstractResolvedMember(IUnresolvedMember unresolved, ITypeResolveContext parentContext)
 			: base(unresolved, parentContext)
@@ -54,14 +54,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return unresolved; }
 		}
 		
-		public IList<IMember> InterfaceImplementations {
+		public IList<IMember> ImplementedInterfaceMembers {
 			get {
-				IList<IMember> result = this.interfaceImplementations;
+				IList<IMember> result = this.implementedInterfaceMembers;
 				if (result != null) {
 					LazyInit.ReadBarrier();
 					return result;
 				} else {
-					return LazyInit.GetOrSet(ref interfaceImplementations, FindInterfaceImplementations());
+					return LazyInit.GetOrSet(ref implementedInterfaceMembers, FindImplementedInterfaceMembers());
 				}
 			}
 		}
@@ -78,7 +78,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		IList<IMember> FindInterfaceImplementations()
+		IList<IMember> FindImplementedInterfaceMembers()
 		{
 			if (unresolved.IsExplicitInterfaceImplementation) {
 				List<IMember> result = new List<IMember>();
@@ -112,8 +112,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public virtual IMemberReference ToMemberReference()
 		{
 			var declTypeRef = this.DeclaringType.ToTypeReference();
-			if (IsExplicitInterfaceImplementation && InterfaceImplementations.Count == 1) {
-				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, InterfaceImplementations[0].ToMemberReference());
+			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
+				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
 			} else {
 				return new DefaultMemberReference(this.EntityType, declTypeRef, this.Name);
 			}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs

@@ -63,8 +63,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public override IMemberReference ToMemberReference()
 		{
 			var declTypeRef = this.DeclaringType.ToTypeReference();
-			if (IsExplicitInterfaceImplementation && InterfaceImplementations.Count == 1) {
-				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, InterfaceImplementations[0].ToMemberReference());
+			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
+				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
 			} else {
 				return new DefaultMemberReference(
 					this.EntityType, declTypeRef, this.Name, this.TypeParameters.Count,

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs

@@ -64,8 +64,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public override IMemberReference ToMemberReference()
 		{
 			var declTypeRef = this.DeclaringType.ToTypeReference();
-			if (IsExplicitInterfaceImplementation && InterfaceImplementations.Count == 1) {
-				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, InterfaceImplementations[0].ToMemberReference());
+			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
+				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToMemberReference());
 			} else {
 				return new DefaultMemberReference(
 					this.EntityType, declTypeRef, this.Name, 0,

ICSharpCode.NRefactory/TypeSystem/Implementation/ExplicitInterfaceImplementationMemberReference.cs

@@ -49,7 +49,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			var members = type.GetMembers(
 				m => m.EntityType == interfaceMember.EntityType && m.IsExplicitInterfaceImplementation,
 				GetMemberOptions.IgnoreInheritedMembers);
-			return members.FirstOrDefault(m => m.InterfaceImplementations.Count == 1 && interfaceMember.Equals(m.InterfaceImplementations[0]));
+			return members.FirstOrDefault(m => m.ImplementedInterfaceMembers.Count == 1 && interfaceMember.Equals(m.ImplementedInterfaceMembers[0]));
 		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs

@@ -130,17 +130,17 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return memberDefinition.Attributes; }
 		}
 		
-		IList<IMember> interfaceImplementations;
+		IList<IMember> implementedInterfaceMembers;
 		
-		public IList<IMember> InterfaceImplementations {
+		public IList<IMember> ImplementedInterfaceMembers {
 			get {
-				return LazyInitializer.EnsureInitialized(ref interfaceImplementations, FindInterfaceImplementations);
+				return LazyInitializer.EnsureInitialized(ref implementedInterfaceMembers, FindImplementedInterfaceMembers);
 			}
 		}
 		
-		IList<IMember> FindInterfaceImplementations()
+		IList<IMember> FindImplementedInterfaceMembers()
 		{
-			var definitionImplementations = memberDefinition.InterfaceImplementations;
+			var definitionImplementations = memberDefinition.ImplementedInterfaceMembers;
 			IMember[] result = new IMember[definitionImplementations.Count];
 			for (int i = 0; i < result.Length; i++) {
 				result[i] = Specialize(definitionImplementations[i]);

ICSharpCode.NRefactory/TypeSystem/InheritanceHelper.cs

@@ -51,6 +51,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				throw new ArgumentNullException("member");
 			
 			member = member.MemberDefinition;
+			if (member.IsExplicitInterfaceImplementation && member.ImplementedInterfaceMembers.Count == 1) {
+				// C#-style explicit interface implementation
+				yield return member.ImplementedInterfaceMembers[0];
+				member = member.ImplementedInterfaceMembers[0].MemberDefinition;
+			}
 			
 			IEnumerable<IType> allBaseTypes;
 			if (includeImplementedInterfaces) {