Adjust SharpDevelop to new context actions API.

src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.addin

@@ -140,79 +140,54 @@
 	<Path path = "/SharpDevelop/ViewContent/TextEditor/C#/ContextActions">
 		<!-- TODO: translate -->
 		<CSharpContextAction id = "AddAnotherAccessor"
-			displayName = "Add another accessor"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.AddAnotherAccessor" />
 		<CSharpContextAction id = "CheckIfParameterIsNull"
-			displayName = "${res:AddIns.SharpRefactoring.InsertCtor.AddCheckForNullLabel}"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.CheckIfParameterIsNull" />
 		<CSharpContextAction id = "ConvertDecToHex"
-			displayName = "Convert to hexadecimal"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.ConvertDecToHex" />
 		<CSharpContextAction id = "ConvertHexToDec"
-			displayName = "Convert to decimal"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.ConvertHexToDec" />
 		<CSharpContextAction id = "ConvertForeachToFor"
-			displayName = "Convert to for loop"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.ConvertForeachToFor" />
 		<CSharpContextAction id = "CreateBackingStore"
-			displayName = "${res:SharpDevelop.Refactoring.ExpandAutomaticProperty}"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.CreateBackingStore" />
 		<CSharpContextAction id = "CreateEventInvocator"
-			displayName = "${res:SharpDevelop.Refactoring.CreateOnEventMethod}"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.CreateEventInvocator" />
 		<CSharpContextAction id = "CreateField"
-			displayName = "Introduce field"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.CreateField" />
 		<CSharpContextAction id = "CreateLocalVariable"
-			displayName = "Introduce local variable"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.CreateLocalVariable" />
 		<CSharpContextAction id = "CreateProperty"
-			displayName = "Introduce property"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.CreateProperty" />
 		<CSharpContextAction id = "FlipOperatorArguments"
-			displayName = "Flip operands"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.FlipOperatorArguments" />
 		<CSharpContextAction id = "GenerateGetter"
-			displayName = "Generate getter"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.GenerateGetter" />
 		<CSharpContextAction id = "GenerateProperty"
-			displayName = "Generate property"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.GenerateProperty" />
 		<CSharpContextAction id = "GenerateSwitchLabels"
-			displayName = "Generate switch labels"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.GenerateSwitchLabels" />
 		<CSharpContextAction id = "InsertAnonymousMethodSignature"
-			displayName = "Create anonymous method"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.InsertAnonymousMethodSignature" />
 		<CSharpContextAction id = "IntroduceFormatItem"
-			displayName = "Introduce string.Format call"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.IntroduceFormatItem" />
 		<CSharpContextAction id = "InvertIf"
-			displayName = "Invert if"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.InvertIf" />
 		<CSharpContextAction id = "RemoveBackingStore"
-			displayName = "${res:SharpDevelop.Refactoring.ConvertToAutomaticProperty}"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.RemoveBackingStore" />
 		<CSharpContextAction id = "RemoveBraces"
-			displayName = "Remove braces"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.RemoveBraces" />
 		<CSharpContextAction id = "RemoveRegion"
-			displayName = "Remove #region"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.RemoveRegion" />
 		<CSharpContextAction id = "ReplaceEmptyString"
-			displayName = "Use string.Empty"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.ReplaceEmptyString" />
 		<CSharpContextAction id = "SplitDeclarationAndAssignment"
-			displayName = "Split declaration and assignment"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.SplitDeclarationAndAssignment" />
 		<CSharpContextAction id = "SplitString"
-			displayName = "Split string literal"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.SplitString" />
 		<CSharpContextAction id = "UseExplicitType"
-			displayName = "Use explicit type"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.UseExplicitType" />
 		<CSharpContextAction id = "UseVarKeyword"
-			displayName = "Use 'var' keyword"
 			class       = "ICSharpCode.NRefactory.CSharp.Refactoring.UseVarKeyword" />
 	</Path>
 </AddIn>

src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpLanguageBinding.cs

@@ -33,8 +33,8 @@ namespace CSharpBinding
 		
 		ITextEditor editor;
 		CSharpSemanticHighlighter semanticHighlighter;
-		InspectionManager inspectionManager;
-		IList<IContextActionsProvider> contextActionProviders;
+		//InspectionManager inspectionManager;
+		IList<IContextActionProvider> contextActionProviders;
 		
 		public override void Attach(ITextEditor editor)
 		{
@@ -45,11 +45,11 @@ namespace CSharpBinding
 				semanticHighlighter = new CSharpSemanticHighlighter(editor, highlighter);
 				highlighter.AddAdditionalHighlighter(semanticHighlighter);
 			}
-			inspectionManager = new InspectionManager(editor);
+			//inspectionManager = new InspectionManager(editor);
 			//codeManipulation = new CodeManipulation(editor);
 			
 			if (!editor.ContextActionProviders.IsReadOnly) {
-				contextActionProviders = AddInTree.BuildItems<IContextActionsProvider>("/SharpDevelop/ViewContent/TextEditor/C#/ContextActions", null);
+				contextActionProviders = AddInTree.BuildItems<IContextActionProvider>("/SharpDevelop/ViewContent/TextEditor/C#/ContextActions", null);
 				editor.ContextActionProviders.AddRange(contextActionProviders);
 			}
 		}
@@ -63,10 +63,10 @@ namespace CSharpBinding
 				semanticHighlighter.Dispose();
 				semanticHighlighter = null;
 			}
-			if (inspectionManager != null) {
-				inspectionManager.Dispose();
-				inspectionManager = null;
-			}
+//			if (inspectionManager != null) {
+//				inspectionManager.Dispose();
+//				inspectionManager = null;
+//			}
 			if (contextActionProviders != null) {
 				editor.ContextActionProviders.RemoveWhere(contextActionProviders.Contains);
 			}

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Refactoring/CSharpContextActionDoozer.cs

@@ -3,18 +3,19 @@
 
 using System;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using CSharpBinding.Parser;
 using ICSharpCode.Core;
+using ICSharpCode.NRefactory.CSharp;
+using ICSharpCode.NRefactory.CSharp.Refactoring;
 using ICSharpCode.NRefactory.CSharp.Resolver;
 using ICSharpCode.SharpDevelop.Editor;
 using ICSharpCode.SharpDevelop.Refactoring;
 
 namespace CSharpBinding.Refactoring
 {
-	using NR5ContextAction = ICSharpCode.NRefactory.CSharp.Refactoring.IContextAction;
-	
 	/// <summary>
 	/// Doozer for C# context actions.
 	/// Expects a 'class' referencing an NR5 context action and provides an SD IContextActionsProvider.
@@ -27,34 +28,55 @@ namespace CSharpBinding.Refactoring
 		
 		public object BuildItem(BuildItemArgs args)
 		{
-			return new CSharpContextActionWrapper(args.AddIn, args.Codon.Properties);
+			Type providerType = args.AddIn.FindType(args.Codon.Properties["class"]);
+			if (providerType == null)
+				return null;
+			var attributes = providerType.GetCustomAttributes(typeof(ContextActionAttribute), true);
+			if (attributes.Length == 0) {
+				LoggingService.Error("[ContextAction] attribute is missing on " + providerType.FullName);
+				return null;
+			}
+			if (!typeof(ICodeActionProvider).IsAssignableFrom(providerType)) {
+				LoggingService.Error(providerType.FullName + " does nto implement ICodeActionProvider");
+				return null;
+			}
+			return new CSharpContextActionProviderWrapper((ContextActionAttribute)attributes[0], providerType);
 		}
 		
-		sealed class CSharpContextActionWrapper : ContextAction
+		sealed class CSharpContextActionProviderWrapper : IContextActionProvider
 		{
-			readonly AddIn addIn;
-			readonly string className;
-			readonly string displayName;
+			readonly ContextActionAttribute attribute;
+			readonly Type type;
 			
-			public CSharpContextActionWrapper(AddIn addIn, Properties properties)
+			public CSharpContextActionProviderWrapper(ContextActionAttribute attribute, Type type)
 			{
-				this.addIn = addIn;
-				this.className = properties["class"];
-				this.displayName = properties["displayName"];
+				this.attribute = attribute;
+				this.type = type;
 			}
 			
-			bool contextActionCreated;
-			NR5ContextAction contextAction;
+			ICodeActionProvider codeActionProvider;
 			
-			public override string ID {
-				get { return className; }
+			bool CreateCodeActionProvider()
+			{
+				lock (this) {
+					if (codeActionProvider == null) {
+						codeActionProvider = (ICodeActionProvider)Activator.CreateInstance(type);
+					}
+					return true;
+				}
+			}
+			
+			public string ID {
+				get { return type.FullName; }
 			}
 			
-			public override string DisplayName {
-				get { return StringParser.Parse(displayName); }
+			public bool AllowHiding {
+				get { return true; }
 			}
 			
-			public override Task<bool> IsAvailableAsync(EditorRefactoringContext context, CancellationToken cancellationToken)
+			public bool IsVisible { get; set; }
+			
+			public Task<IContextAction[]> GetAvailableActionsAsync(EditorRefactoringContext context, CancellationToken cancellationToken)
 			{
 				ITextEditor editor = context.Editor;
 				// grab SelectionStart/SelectionLength while we're still on the main thread
@@ -62,32 +84,66 @@ namespace CSharpBinding.Refactoring
 				int selectionLength = editor.SelectionLength;
 				return Task.Run(
 					async delegate {
-						CreateContextAction();
-						if (contextAction == null)
-							return false;
+						if (!CreateCodeActionProvider())
+							return new IContextAction[0];
 						CSharpAstResolver resolver = await context.GetAstResolverAsync().ConfigureAwait(false);
 						var refactoringContext = new SDRefactoringContext(context.TextSource, resolver, context.CaretLocation, selectionStart, selectionLength, cancellationToken);
-						return contextAction.IsValid(refactoringContext);
+						return codeActionProvider.GetActions(refactoringContext)
+							.Select((action, index) => new CSharpContextActionWrapper(this, action, index)).ToArray();
 					}, cancellationToken);
 			}
 			
-			void CreateContextAction()
+			internal CodeAction GetCodeAction(RefactoringContext refactoringContext, int index, string description)
 			{
-				lock (this) {
-					if (!contextActionCreated) {
-						contextActionCreated = true;
-						contextAction = (NR5ContextAction)addIn.CreateObject(className);
+				if (!CreateCodeActionProvider())
+					return null;
+				var actions = codeActionProvider.GetActions(refactoringContext).ToList();
+				if (index < actions.Count) {
+					var action = actions[index];
+					if (action.Description == description)
+						return action;
 				}
+				return null;
 			}
 		}
 		
-			public override void Execute(EditorRefactoringContext context)
+		sealed class CSharpContextActionWrapper : IContextAction
 		{
-				AnalyticsMonitorService.TrackFeature(className);
+			readonly CSharpContextActionProviderWrapper provider;
+			readonly int index;
+			readonly string description;
+			
+			public CSharpContextActionWrapper(CSharpContextActionProviderWrapper provider, CodeAction codeAction, int index)
+			{
+				if (provider == null)
+					throw new ArgumentNullException("provider");
+				if (codeAction == null)
+					throw new ArgumentNullException("codeAction");
+				this.provider = provider;
+				this.description = codeAction.Description;
+				this.index = index;
+				// Don't maintain a reference to 'action', it indirectly references the compilation etc.
+			}
+			
+			public IContextActionProvider Provider {
+				get { return provider; }
+			}
+			
+			public string DisplayName {
+				get { return description; }
+			}
+			
+			public void Execute(EditorRefactoringContext context)
+			{
+				AnalyticsMonitorService.TrackFeature(provider.ID);
 				var resolver = context.GetAstResolverAsync().Result;
 				var refactoringContext = new SDRefactoringContext(context.Editor, resolver, context.CaretLocation);
-				CreateContextAction();
-				contextAction.Run(refactoringContext);
+				var action = provider.GetCodeAction(refactoringContext, index, description);
+				if (action != null) {
+					using (var script = refactoringContext.StartScript()) {
+						action.Run(script);
+					}
+				}
 			}
 		}
 	}

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Refactoring/InspectionManager.cs

@@ -18,6 +18,7 @@ using ICSharpCode.SharpDevelop.Parser;
 
 namespace CSharpBinding.Refactoring
 {
+	/*
 	/// <summary>
 	/// Performs code analysis in the background and creates text markers to show warnings.
 	/// </summary>
@@ -153,4 +154,5 @@ namespace CSharpBinding.Refactoring
 			cancellationTokenSource = null;
 		}
 	}
+	*/
 }

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/CodeEditorAdapter.cs

@@ -86,7 +86,7 @@ namespace ICSharpCode.AvalonEdit.AddIn
 			}
 		}
 		
-		public override IList<ICSharpCode.SharpDevelop.Refactoring.IContextActionsProvider> ContextActionProviders {
+		public override IList<ICSharpCode.SharpDevelop.Refactoring.IContextActionProvider> ContextActionProviders {
 			get { return ((CodeEditorView)TextEditor).ContextActionProviders; }
 		}
 	}

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/CodeEditorView.cs

@@ -84,7 +84,7 @@ namespace ICSharpCode.AvalonEdit.AddIn
 			hiddenDefinitionRenderer.Dispose();
 		}
 		
-		public IList<IContextActionsProvider> ContextActionProviders {
+		public IList<IContextActionProvider> ContextActionProviders {
 			get { return contextActionsRenderer.Providers; }
 		}
 		

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/ContextActions/ContextActionsRenderer.cs

@@ -23,7 +23,7 @@ namespace ICSharpCode.AvalonEdit.AddIn.ContextActions
 	public sealed class ContextActionsRenderer : IDisposable
 	{
 		readonly CodeEditorView editorView;
-		ObservableCollection<IContextActionsProvider> providers = new ObservableCollection<IContextActionsProvider>();
+		ObservableCollection<IContextActionProvider> providers = new ObservableCollection<IContextActionProvider>();
 		
 		ITextEditor Editor { get { return this.editorView.Adapter; } }
 		
@@ -62,7 +62,7 @@ namespace ICSharpCode.AvalonEdit.AddIn.ContextActions
 			ClosePopup();
 		}
 		
-		public IList<IContextActionsProvider> Providers {
+		public IList<IContextActionProvider> Providers {
 			get { return providers; }
 		}
 		

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/ContextActions/EditorActionsProvider.cs

@@ -29,20 +29,20 @@ namespace ICSharpCode.AvalonEdit.AddIn.ContextActions
 			return PropertyService.Get(PropertyServiceKey, new List<string>());
 		}
 		
-		static void SaveProviderVisibilities(IEnumerable<IContextActionsProvider> providers)
+		static void SaveProviderVisibilities(IEnumerable<IContextActionProvider> providers)
 		{
 			List<string> disabledProviders = providers.Where(p => !p.IsVisible).Select(p => p.ID).ToList();
 			PropertyService.Set(PropertyServiceKey, disabledProviders);
 		}
 		
-		readonly IList<IContextActionsProvider> providers;
+		readonly IList<IContextActionProvider> providers;
 		readonly EditorRefactoringContext editorContext;
 		
 		public EditorRefactoringContext EditorContext {
 			get { return editorContext; }
 		}
 		
-		public EditorActionsProvider(EditorRefactoringContext editorContext, IList<IContextActionsProvider> providers)
+		public EditorActionsProvider(EditorRefactoringContext editorContext, IList<IContextActionProvider> providers)
 		{
 			if (editorContext == null)
 				throw new ArgumentNullException("editorContext");
@@ -69,7 +69,7 @@ namespace ICSharpCode.AvalonEdit.AddIn.ContextActions
 		
 		public void SetVisible(IContextAction action, bool isVisible)
 		{
-			IContextActionsProvider provider;
+			IContextActionProvider provider;
 			if (providerForAction.TryGetValue(action, out provider)) {
 				provider.IsVisible = isVisible;
 			}
@@ -79,12 +79,12 @@ namespace ICSharpCode.AvalonEdit.AddIn.ContextActions
 		/// <summary>
 		/// For every returned action remembers its provider for so that SetVisible can work.
 		/// </summary>
-		Dictionary<IContextAction, IContextActionsProvider> providerForAction = new Dictionary<IContextAction, IContextActionsProvider>();
+		Dictionary<IContextAction, IContextActionProvider> providerForAction = new Dictionary<IContextAction, IContextActionProvider>();
 
 		/// <summary>
 		/// Gets actions available for current caret position in the editor.
 		/// </summary>
-		async Task<IEnumerable<IContextAction>> GetActionsAsync(IEnumerable<IContextActionsProvider> providers, CancellationToken cancellationToken)
+		async Task<IEnumerable<IContextAction>> GetActionsAsync(IEnumerable<IContextActionProvider> providers, CancellationToken cancellationToken)
 		{
 			if (ParserService.LoadSolutionProjectsThreadRunning)
 				return EmptyList<IContextAction>.Instance;

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/ContextActions/GoToEntityAction.cs

@@ -43,5 +43,9 @@ namespace ICSharpCode.AvalonEdit.AddIn.ContextActions
 		{
 			NavigationService.NavigateTo(this.Entity);
 		}
+		
+		IContextActionProvider IContextAction.Provider {
+			get { return null; }
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Refactoring/ContextActionAttribute.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // ProviderDescriptionAttribute.cs
 //  
 // Author:

src/Main/Base/Project/Src/Editor/AvalonEdit/AvalonEditTextEditorAdapter.cs

@@ -239,8 +239,8 @@ namespace ICSharpCode.SharpDevelop.Editor.AvalonEdit
 			return Enumerable.Empty<ICompletionItem>();
 		}
 		
-		public virtual IList<ICSharpCode.SharpDevelop.Refactoring.IContextActionsProvider> ContextActionProviders {
-			get { return EmptyList<ICSharpCode.SharpDevelop.Refactoring.IContextActionsProvider>.Instance; }
+		public virtual IList<ICSharpCode.SharpDevelop.Refactoring.IContextActionProvider> ContextActionProviders {
+			get { return EmptyList<ICSharpCode.SharpDevelop.Refactoring.IContextActionProvider>.Instance; }
 		}
 		
 		public virtual ITextEditor PrimaryView {

src/Main/Base/Project/Src/Editor/ITextEditor.cs

@@ -123,7 +123,7 @@ namespace ICSharpCode.SharpDevelop.Editor
 		/// <summary>
 		/// Gets the list of context action providers.
 		/// </summary>
-		IList<IContextActionsProvider> ContextActionProviders { get; }
+		IList<IContextActionProvider> ContextActionProviders { get; }
 	}
 	
 	public interface ITextEditorOptions : INotifyPropertyChanged

src/Main/Base/Project/Src/Refactoring/ContextAction.cs

@@ -14,7 +14,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 	/// Base class for implementing one context action.
 	/// Useful for implementing <see cref="IContextActionsProvider" /> that provides just one action - common scenario.
 	/// </summary>
-	public abstract class ContextAction : IContextActionsProvider, IContextAction
+	public abstract class ContextAction : IContextActionProvider, IContextAction
 	{
 		public virtual string ID {
 			get { return GetType().FullName; }
@@ -36,7 +36,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 		
 		public abstract void Execute(EditorRefactoringContext context);
 		
-		async Task<IContextAction[]> IContextActionsProvider.GetAvailableActionsAsync(EditorRefactoringContext context, CancellationToken cancellationToken)
+		async Task<IContextAction[]> IContextActionProvider.GetAvailableActionsAsync(EditorRefactoringContext context, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
 			if (await IsAvailableAsync(context, cancellationToken).ConfigureAwait(false))
@@ -44,5 +44,9 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			else
 				return new IContextAction[0];
 		}
+		
+		IContextActionProvider IContextAction.Provider {
+			get { return this; }
+		}
 	}
 }

src/Main/Base/Project/Src/Refactoring/IContextAction.cs

@@ -12,6 +12,11 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 	/// </summary>
 	public interface IContextAction
 	{
+		/// <summary>
+		/// Gets the provider that was used to create this action.
+		/// </summary>
+		IContextActionProvider Provider { get; }
+		
 		/// <summary>
 		/// Name displayed in the context actions popup.
 		/// </summary>

src/Main/Base/Project/Src/Refactoring/IContextActionsProvider.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 	/// <summary>
 	/// Provides a set of refactoring <see cref="ContextAction" />s.
 	/// </summary>
-	public interface IContextActionsProvider
+	public interface IContextActionProvider
 	{
 		/// <summary>
 		/// Unique identifier for the context actions provider; used to hide context actions