Cleaned up RefactoringService.FindDerivedClasses a bit.

Removed IClass.GetBaseType(int index) - it had only one implementation returning this.BaseTypes[index] -> user can always use IClass.BaseTypes.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@5992 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj

@@ -693,6 +693,7 @@
     <Compile Include="Src\Gui\Dialogs\ReferenceDialog\AsyncDiscoveryState.cs" />
     <Compile Include="Src\Gui\Dialogs\ReferenceDialog\DiscoveryNetworkCredential.cs" />
     <Compile Include="Src\Services\ProjectService\ProjectLoader.cs" />
+    <Compile Include="Src\Util\ITreeNode.cs" />
     <Compile Include="Src\Util\NativeMethods.cs" />
     <Compile Include="Src\Util\ProcessRunnerException.cs" />
     <Compile Include="Src\Util\LineReceivedEventArgs.cs" />

src/Main/Base/Project/Src/Gui/Pads/ClassBrowser/Nodes/BaseTypesNode.cs

@@ -56,9 +56,7 @@ namespace ICSharpCode.SharpDevelop.Gui.ClassBrowser
 			
 			IProjectContent content = c.ProjectContent;
 			if (content != null) {
-				int count = c.BaseTypes.Count;
-				for (int i = 0; i < count; i++) {
-					IReturnType baseType = c.GetBaseType(i);
+				foreach (var baseType in c.BaseTypes) {
 					IClass baseClass = (baseType != null) ? baseType.GetUnderlyingClass() : null;
 					if (baseClass != null) {
 						new ClassNode(project, baseClass).AddTo(this);

src/Main/Base/Project/Src/Services/RefactoringService/RefactoringService.cs

@@ -35,20 +35,22 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			return resultList.OrderBy(c => c.FullyQualifiedName);
 		}
 		
+		public static IEnumerable<ITreeNode<IClass>> FindDerivedClasses(IClass baseClass, IEnumerable<IProjectContent> projectContents)
+		{
+			return null;
+		}
+		
 		static void FindDerivedClasses(HashSet<IClass> resultList, IClass baseClass, IEnumerable<IProjectContent> projectContents, bool directDerivationOnly)
 		{
 			baseClass = baseClass.GetCompoundClass();
-			string baseClassName = baseClass.Name;
-			string baseClassFullName = baseClass.FullyQualifiedName;
-			LoggingService.Debug("FindDerivedClasses for " + baseClassFullName);
+			LoggingService.Debug("FindDerivedClasses for " + baseClass.FullyQualifiedName);
 			List<IClass> list = new List<IClass>();
 			foreach (IProjectContent pc in projectContents) {
-				if (pc != baseClass.ProjectContent && !pc.ReferencedContents.Contains(baseClass.ProjectContent)) {
+				if ((pc == baseClass.ProjectContent) || pc.ReferencedContents.Contains(baseClass.ProjectContent)) {
 					// only project contents referencing the content of the base class
 					// can derive from the class
-					continue;
+					AddDerivedClasses(pc, baseClass, pc.Classes, list);
 				}
-				AddDerivedClasses(pc, baseClass, baseClassName, baseClassFullName, pc.Classes, list);
 			}
 			if (directDerivationOnly) {
 				resultList.AddRange(list);
@@ -61,20 +63,19 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			}
 		}
 		
-		static void AddDerivedClasses(IProjectContent pc, IClass baseClass, string baseClassName, string baseClassFullName,
-		                              IEnumerable<IClass> classList, IList<IClass> resultList)
+		static void AddDerivedClasses(IProjectContent pc, IClass baseClass, IEnumerable<IClass> classList, IList<IClass> resultList)
 		{
+			string baseClassName = baseClass.Name;
+			string baseClassFullName = baseClass.FullyQualifiedName;
 			foreach (IClass c in classList) {
-				AddDerivedClasses(pc, baseClass, baseClassName, baseClassFullName, c.InnerClasses, resultList);
-				int count = c.BaseTypes.Count;
-				for (int i = 0; i < count; i++) {
-					string baseTypeName = c.BaseTypes[i].Name;
-					if (pc.Language.NameComparer.Equals(baseTypeName, baseClassName) ||
-					    pc.Language.NameComparer.Equals(baseTypeName, baseClassFullName)) {
-						IReturnType possibleBaseClass = c.GetBaseType(i);
-						if (possibleBaseClass.FullyQualifiedName == baseClass.FullyQualifiedName
-						    && possibleBaseClass.TypeArgumentCount == baseClass.TypeParameters.Count)
-						{
+				AddDerivedClasses(pc, baseClass, c.InnerClasses, resultList);
+				foreach (var baseType in c.BaseTypes) {
+					string baseTypeName = baseType.Name;
+					// If this type has our type as base, add it to derived
+					if (pc.Language.NameComparer.Equals(baseType.Name, baseClassName) ||
+					    pc.Language.NameComparer.Equals(baseType.Name, baseClassFullName)) {
+						if (baseType.FullyQualifiedName == baseClassFullName &&
+						    baseType.TypeArgumentCount == baseClass.TypeParameters.Count) {
 							resultList.Add(c);
 						}
 					}

src/Main/Base/Project/Src/TextEditor/Commands/ClassBookmarkMenuBuilder.cs

@@ -5,6 +5,7 @@
 //     <version>$Revision$</version>
 // </file>
 
+using System.Linq;
 using ICSharpCode.SharpDevelop.Editor.Search;
 using System;
 using System.Collections.Generic;

src/Main/Base/Project/Src/Util/ITreeNode.cs

@@ -0,0 +1,18 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Martin Konicek" email="martin.konicek@gmail.com"/>
+//     <version>$Revision: $</version>
+// </file>
+using System;
+
+namespace ICSharpCode.SharpDevelop
+{
+	/// <summary>
+	/// Generic TreeNode with content and children.
+	/// </summary>
+	public interface ITreeNode<TContent>
+	{
+		TContent Content { get; }
+	}
+}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DefaultClass.cs

@@ -507,11 +507,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get { return false; }
 		}
 		
-		public IReturnType GetBaseType(int index)
-		{
-			return BaseTypes[index];
-		}
-		
 		IReturnType cachedBaseType;
 		
 		public IReturnType BaseType {

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Interfaces/IClass.cs

@@ -43,9 +43,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get;
 		}
 		
-		/// <summary>Gets the class associated with the base type with the same index.</summary>
-		IReturnType GetBaseType(int index);
-		
 		IList<IClass> InnerClasses {
 			get;
 		}