Implement EnvDTE.CodeClass.ImplementedInterfaces.

src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj

@@ -102,6 +102,7 @@
     <Compile Include="Src\EnvDTE\Configuration.cs" />
     <Compile Include="Src\EnvDTE\Constants.cs" />
     <Compile Include="Src\EnvDTE\EditPoint.cs" />
+    <Compile Include="Src\EnvDTE\ImplementedInterfacesOnClass.cs" />
     <Compile Include="Src\EnvDTE\NamespaceName.cs" />
     <Compile Include="Src\EnvDTE\ProjectKind.cs" />
     <Compile Include="Src\EnvDTE\Projects.cs" />

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass.cs

@@ -18,7 +18,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		}
 		
 		public virtual CodeElements ImplementedInterfaces {
-			get { throw new NotImplementedException(); }
+			get { return new ImplementedInterfacesOnClass(ProjectContent, Class); }
 		}
 		
 		public virtual CodeVariable AddVariable(string name, object type, object Position = null, vsCMAccess Access = vsCMAccess.vsCMAccessPublic, object Location = null)

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeInterface.cs

@@ -8,14 +8,44 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 {
 	public class CodeInterface : CodeType
 	{
+		string fullName;
+		
 		public CodeInterface(IProjectContent projectContent, IClass c)
 			: base(projectContent, c)
 		{
+			fullName = base.FullName;
+		}
+		
+		public CodeInterface(IProjectContent projectContent, IReturnType type, IClass c)
+			: base(projectContent, c)
+		{
+			fullName = GetFullName(type);
+		}
+		
+		string GetFullName(IReturnType type)
+		{
+			return type.DotNetName.Replace("{", "<").Replace("}", ">");
+		}
+		
+		/// <summary>
+		/// Returns null if base type is not an interface.
+		/// </summary>
+		public static CodeInterface CreateFromBaseType(IProjectContent projectContent, IReturnType baseType)
+		{
+			IClass baseTypeClass = baseType.GetUnderlyingClass();
+			if (baseTypeClass.ClassType == ClassType.Interface) {
+				return new CodeInterface(projectContent, baseType, baseTypeClass);
+			}
+			return null;
 		}
 		
 		public CodeFunction AddFunction(string name, vsCMFunction kind, object type, object Position = null, vsCMAccess Access = vsCMAccess.vsCMAccessPublic)
 		{
 			throw new NotImplementedException();
 		}
+		
+		public override string FullName {
+			get { return fullName; }
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeType.cs

@@ -19,6 +19,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 			: base(c)
 		{
 			this.Class = c;
+			this.ProjectContent = projectContent;
 			InfoLocation = GetInfoLocation(projectContent, c);
 		}
 		
@@ -35,6 +36,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		}
 		
 		protected IClass Class { get; private set; }
+		protected IProjectContent ProjectContent { get; private set; }
 		
 		public virtual vsCMAccess Access {
 			get { return GetAccess(); }

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/ImplementedInterfacesOnClass.cs

@@ -0,0 +1,41 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace ICSharpCode.PackageManagement.EnvDTE
+{
+	public class ImplementedInterfacesOnClass : CodeElementsList
+	{
+		IProjectContent projectContent;
+		IClass c;
+		
+		public ImplementedInterfacesOnClass(IProjectContent projectContent, IClass c)
+		{
+			this.projectContent = projectContent;
+			this.c 	= c;
+			AddCodeInterfaces();
+		}
+		
+		void AddCodeInterfaces()
+		{
+			foreach (IReturnType baseType in c.BaseTypes) {
+				CodeInterface codeInterface = CodeInterface.CreateFromBaseType(projectContent, baseType);
+				if (codeInterface != null) {
+					AddCodeElement(codeInterface);
+				}
+			}
+		}
+		
+		void AddCodeInterface(IReturnType baseType, IClass baseTypeClass)
+		{
+			AddCodeElement(CreateCodeInterface(baseType, baseTypeClass));
+		}
+		
+		CodeInterface CreateCodeInterface(IReturnType baseType, IClass baseTypeClass)
+		{
+			return new CodeInterface(projectContent, baseType, baseTypeClass);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeClass2Tests.cs

@@ -45,6 +45,26 @@ namespace PackageManagement.Tests.EnvDTE
 			codeClass = new CodeClass2(helper.FakeProjectContent, fakeClass);
 		}
 		
+		void AddInterfaceToProjectContent(string fullName)
+		{
+			helper.AddInterfaceToProjectContent(fullName);
+		}
+		
+		void AddClassToProjectContent(string fullName)
+		{
+			helper.AddClassToProjectContent(fullName);
+		}
+		
+		void AddBaseTypeInterfaceToClass(string fullName, string dotNetName)
+		{
+			helper.AddInterfaceToClassBaseTypes(fakeClass, fullName, dotNetName);
+		}
+		
+		void AddBaseTypeClassToClass(string fullName)
+		{
+			helper.AddClassToClassBaseTypes(fakeClass, fullName);
+		}
+		
 		[Test]
 		public void Language_CSharpProject_ReturnsCSharpModelLanguage()
 		{
@@ -90,5 +110,31 @@ namespace PackageManagement.Tests.EnvDTE
 			
 			Assert.AreEqual(vsCMAccess.vsCMAccessPrivate, access);
 		}
+		
+		[Test]
+		public void ImplementedInterfaces_ClassImplementsGenericICollectionOfString_ReturnsCodeInterfaceForICollection()
+		{
+			CreateProjectContent();
+			CreatePublicClass("MyClass");
+			AddBaseTypeInterfaceToClass("System.Collections.Generic.ICollection", "System.Collections.Generic.ICollection{System.String}");
+			
+			CodeElements codeElements = codeClass.ImplementedInterfaces;
+			CodeInterface codeInterface = codeElements.FirstOrDefault() as CodeInterface;
+			
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("System.Collections.Generic.ICollection<System.String>", codeInterface.FullName);
+		}
+		
+		[Test]
+		public void ImplementedInterfaces_ClassHasBaseTypeButNoInterfaces_ReturnsNoItems()
+		{
+			CreateProjectContent();
+			CreatePublicClass("MyClass");
+			AddBaseTypeClassToClass("MyNamespace.MyBaseClass");
+			
+			CodeElements codeElements = codeClass.ImplementedInterfaces;			
+			
+			Assert.AreEqual(0, codeElements.Count);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ProjectContentHelper.cs

@@ -223,5 +223,30 @@ namespace PackageManagement.Tests.Helpers
 			MakeClassPrivate(fakeDelegate);
 			return fakeDelegate;
 		}
+		
+		public void AddInterfaceToClassBaseTypes(IClass fakeClass, string interfaceFullName, string dotNetName)
+		{
+			IClass interfaceClass = AddInterfaceToProjectContent(interfaceFullName);
+			AddClassToClassBaseTypes(fakeClass, interfaceClass, interfaceFullName, dotNetName);
+		}
+		
+		public void AddClassToClassBaseTypes(IClass fakeClass, IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
+		{
+			IReturnType baseType = MockRepository.GenerateStub<IReturnType>();
+			baseType.Stub(b => b.GetUnderlyingClass()).Return(baseTypeClass);
+			baseType.Stub(b => b.FullyQualifiedName).Return(baseTypeFullName);
+			baseType.Stub(b => b.DotNetName).Return(baseTypeDotNetName);
+			
+			var baseTypes = new List<IReturnType>();
+			baseTypes.Add(baseType);
+			
+			fakeClass.Stub(c => c.BaseTypes).Return(baseTypes);
+		}
+		
+		public void AddClassToClassBaseTypes(IClass fakeClass, string fullName)
+		{
+			IClass baseTypeClass = AddClassToProjectContent(fullName);
+			AddClassToClassBaseTypes(fakeClass, baseTypeClass, fullName, fullName);
+		}
 	}
 }