Decoupled "Add using" functionality from context menu building.

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

src/AddIns/Misc/SharpRefactoring/Project/Src/ContextActions/Extensions.cs

@@ -36,7 +36,10 @@ namespace SharpRefactoring.ContextActions
 			foreach (var declaration in currentLineAST.FindTypeDeclarations()) {
 				var rr = ParserService.Resolve(new ExpressionResult(declaration.Name), editor.Caret.Line, editor.Caret.Column, editor.FileName, editor.Document.Text);
 				if (rr != null && rr.ResolvedType != null) {
-					yield return rr.ResolvedType.GetUnderlyingClass();
+					var foundClass = rr.ResolvedType.GetUnderlyingClass();
+					if (foundClass != null) {
+						yield return foundClass;
+					}
 				}
 			}
 		}

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

@@ -228,54 +228,34 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 		
 		#endregion
 		
-		MenuItem MakeItemForResolveError(UnknownIdentifierResolveResult rr, ExpressionContext context, ITextEditor textArea)
+		MenuItem MakeItemForResolveError(UnknownIdentifierResolveResult unknownIdent, ExpressionContext context, ITextEditor textArea)
 		{
-			return MakeItemForUnknownClass(rr.CallingClass, rr.Identifier, textArea);
+			return MakeItemForActions(RefactoringService.GetAddUsingActions(unknownIdent, textArea), unknownIdent.Identifier, unknownIdent.CallingClass);
 		}
 		
-		MenuItem MakeItemForResolveError(UnknownConstructorCallResolveResult rr, ExpressionContext context, ITextEditor textArea)
+		MenuItem MakeItemForResolveError(UnknownConstructorCallResolveResult unknownConstructor, ExpressionContext context, ITextEditor textArea)
 		{
-			return MakeItemForUnknownClass(rr.CallingClass, rr.TypeName, textArea);
+			return MakeItemForActions(RefactoringService.GetAddUsingActions(unknownConstructor, textArea), unknownConstructor.TypeName, unknownConstructor.CallingClass);
 		}
 		
-		MenuItem MakeItemForUnknownClass(IClass callingClass, string unknownClassName, ITextEditor textArea)
+		MenuItem MakeItemForActions(IEnumerable<RefactoringService.AddUsingAction> menuActions, string unknownClassName, IClass callingClass)
 		{
-			if (callingClass == null)
-				return null;
-			IProjectContent pc = callingClass.ProjectContent;
-			if (!pc.Language.RefactoringProvider.IsEnabledForFile(callingClass.CompilationUnit.FileName))
+			var actions = menuActions.ToList();
+			if (actions.Count == 0)
 				return null;
 			MenuItem item = MakeItemInternal(unknownClassName, ClassBrowserIconService.GotoArrow, callingClass.CompilationUnit, DomRegion.Empty);
-			List<IClass> searchResults = new List<IClass>();
-			SearchAllClassesWithName(searchResults, pc, unknownClassName, pc.Language);
-			foreach (IProjectContent rpc in pc.ReferencedContents) {
-				SearchAllClassesWithName(searchResults, rpc, unknownClassName, pc.Language);
-			}
-			if (searchResults.Count == 0)
-				return null;
-			foreach (IClass c in searchResults) {
-				string newNamespace = c.Namespace;
+			foreach (var action in actions) {
 				MenuItem subItem = new MenuItem();
-				subItem.Header = "using " + newNamespace;
+				subItem.Header = "using " + action.NewNamespace;
 				subItem.Icon = ClassBrowserIconService.Namespace.CreateImage();
 				item.Items.Add(subItem);
 				subItem.Click += delegate {
-					NamespaceRefactoringService.AddUsingDeclaration(callingClass.CompilationUnit, textArea.Document, newNamespace, true);
-					ParserService.BeginParse(textArea.FileName, textArea.Document);
+					action.Execute();
 				};
 			}
 			return item;
 		}
 		
-		void SearchAllClassesWithName(List<IClass> searchResults, IProjectContent pc, string name, LanguageProperties language)
-		{
-			foreach (string ns in pc.NamespaceNames) {
-				IClass c = pc.GetClass(ns + "." + name, 0, language, GetClassOptions.None);
-				if (c != null)
-					searchResults.Add(c);
-			}
-		}
-		
 		IMember GetCallingMember(IClass callingClass, int caretLine, int caretColumn)
 		{
 			if (callingClass == null) {

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

@@ -475,7 +475,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 		
 		#region Interface / abstract class implementation
 		/// <summary>
-		/// Gets actions which can add implementation of interface to this class.
+		/// Gets actions which can add implementation of interface to given class.
 		/// </summary>
 		public static IEnumerable<ImplementInterfaceAction> GetImplementInterfaceActions(IClass c, bool isExplicitImpl, bool returnMissingInterfacesOnly = true)
 		{
@@ -492,7 +492,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			}
 		}
 		/// <summary>
-		/// Gets actions which can add implementation of abstract classes to this class.
+		/// Gets actions which can add implementation of abstract class to given class.
 		/// </summary>
 		public static IEnumerable<ImplementAbstractClassAction> GetImplementAbstractClassActions(IClass c, bool returnMissingClassesOnly = true)
 		{
@@ -561,5 +561,70 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			}
 		}
 		#endregion
+		
+		#region Add using
+		public static IEnumerable<AddUsingAction> GetAddUsingActions(UnknownIdentifierResolveResult rr, ITextEditor textArea)
+		{
+			return GetAddUsingActionsForUnknownClass(rr.CallingClass, rr.Identifier, textArea);
+		}
+		
+		public static IEnumerable<AddUsingAction> GetAddUsingActions(UnknownConstructorCallResolveResult rr, ITextEditor textArea)
+		{
+			return GetAddUsingActionsForUnknownClass(rr.CallingClass, rr.TypeName, textArea);
+		}
+		
+		static IEnumerable<AddUsingAction> GetAddUsingActionsForUnknownClass(IClass callingClass, string unknownClassName, ITextEditor editor)
+		{
+			if (callingClass == null)
+				yield break;
+			IProjectContent pc = callingClass.ProjectContent;
+			if (!pc.Language.RefactoringProvider.IsEnabledForFile(callingClass.CompilationUnit.FileName))
+				yield break;
+			List<IClass> searchResults = new List<IClass>();
+			SearchAllClassesWithName(searchResults, pc, unknownClassName, pc.Language);
+			foreach (IProjectContent rpc in pc.ReferencedContents) {
+				SearchAllClassesWithName(searchResults, rpc, unknownClassName, pc.Language);
+			}
+			foreach (IClass c in searchResults) {
+				string newNamespace = c.Namespace;
+				yield return new AddUsingAction(callingClass.CompilationUnit, editor, newNamespace);
+			}
+		}
+		
+		static void SearchAllClassesWithName(List<IClass> searchResults, IProjectContent pc, string name, LanguageProperties language)
+		{
+			foreach (string ns in pc.NamespaceNames) {
+				IClass c = pc.GetClass(ns + "." + name, 0, language, GetClassOptions.None);
+				if (c != null)
+					searchResults.Add(c);
+			}
+		}
+		
+		public class AddUsingAction
+		{
+			public ICompilationUnit CompilationUnit { get; private set; }
+			public ITextEditor Editor { get; private set; }
+			public string NewNamespace { get; private set; }
+			
+			public AddUsingAction(ICompilationUnit compilationUnit, ITextEditor editor, string newNamespace)
+			{
+				if (compilationUnit == null)
+					throw new ArgumentNullException("compilationUnit");
+				if (editor == null)
+					throw new ArgumentNullException("editor");
+				if (newNamespace == null)
+					throw new ArgumentNullException("newNamespace");
+				this.CompilationUnit = compilationUnit;
+				this.Editor = editor;
+				this.NewNamespace = newNamespace;
+			}
+			
+			public void Execute()
+			{
+				NamespaceRefactoringService.AddUsingDeclaration(CompilationUnit, Editor.Document, NewNamespace, true);
+				ParserService.BeginParse(Editor.FileName, Editor.Document);
+			}
+		}
+		#endregion
 	}
 }