Implemented enum completion after "return".

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

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

@@ -222,7 +222,8 @@ namespace CSharpBinding
 			if (c.ClassType == ClassType.Enum) {
 				CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider();
 				cdp.ForceNewExpression = true;
-				CachedCompletionDataProvider cache = new CachedCompletionDataProvider(cdp);
+				ContextCompletionDataProvider cache = new ContextCompletionDataProvider(cdp);
+				cache.activationKey = charTyped;
 				cache.GenerateCompletionData(editor.FileName, editor.ActiveTextAreaControl.TextArea, charTyped);
 				ICompletionData[] completionData = cache.CompletionData;
 				Array.Sort(completionData);
@@ -236,13 +237,30 @@ namespace CSharpBinding
 					}
 				}
 				if (cache.DefaultIndex >= 0) {
-					if (charTyped != ' ') cache.InsertSpace = true;
+					if (charTyped != ' ') cdp.InsertSpace = true;
 					editor.ShowCompletionWindow(cache, charTyped);
 					return true;
 				}
 			}
 			return false;
 		}
+		
+		private class ContextCompletionDataProvider : CachedCompletionDataProvider
+		{
+			internal char activationKey;
+			
+			internal ContextCompletionDataProvider(ICompletionDataProvider baseProvider) : base(baseProvider)
+			{
+			}
+			
+			public override CompletionDataProviderKeyResult ProcessKey(char key)
+			{
+				if (key == '=' && activationKey == '=')
+					return CompletionDataProviderKeyResult.BeforeStartKey;
+				activationKey = '\0';
+				return base.ProcessKey(key);
+			}
+		}
 		#endregion
 		
 		bool IsInComment(SharpDevelopTextAreaControl editor)
@@ -276,6 +294,13 @@ namespace CSharpBinding
 					return ShowNewCompletion(editor);
 				case "case":
 					return DoCaseCompletion(editor);
+				case "return":
+					IMember m = GetCurrentMember(editor);
+					if (m != null) {
+						return ProvideContextCompletion(editor, m.ReturnType, ' ');
+					} else {
+						goto default;
+					}
 				default:
 					return base.HandleKeyword(editor, word);
 			}
@@ -293,6 +318,17 @@ namespace CSharpBinding
 			return false;
 		}
 		
+		IMember GetCurrentMember(SharpDevelopTextAreaControl editor)
+		{
+			ICSharpCode.TextEditor.Caret caret = editor.ActiveTextAreaControl.Caret;
+			NRefactoryResolver r = new NRefactoryResolver(SupportedLanguage.CSharp);
+			if (r.Initialize(editor.FileName, caret.Line + 1, caret.Column + 1)) {
+				return r.CallingMember;
+			} else {
+				return null;
+			}
+		}
+		
 		#region "case"-keyword completion
 		bool DoCaseCompletion(SharpDevelopTextAreaControl editor)
 		{

src/Libraries/ICSharpCode.TextEditor/Project/Src/Gui/CompletionWindow/CodeCompletionWindow.cs

@@ -151,17 +151,19 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 		
 		public override bool ProcessKeyEvent(char ch)
 		{
-			if (dataProvider.IsInsertionKey(ch)) {
+			switch (dataProvider.ProcessKey(ch)) {
-				if (ch == ' ' && dataProvider.InsertSpace) {
+				case CompletionDataProviderKeyResult.BeforeStartKey:
-					// increment start + end and process as normal space
+					// increment start + end and process as normal char
 					++startOffset;
-				} else {
+					goto case CompletionDataProviderKeyResult.NormalKey;
+				case CompletionDataProviderKeyResult.NormalKey:
+					++endOffset;
+					return base.ProcessKeyEvent(ch);
+				case CompletionDataProviderKeyResult.InsertionKey:
 					return InsertSelectedItem(ch);
-				}
+				default:
+					throw new InvalidOperationException("Invalid return value of dataProvider.ProcessKey");
 			}
-			dataProvider.InsertSpace = false;
-			++endOffset;
-			return base.ProcessKeyEvent(ch);
 		}
 		
 		protected override void CaretOffsetChanged(object sender, EventArgs e)
@@ -262,12 +264,7 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 					if (endOffset - startOffset > 0) {
 						control.Document.Remove(startOffset, endOffset - startOffset);
 					}
-					if (dataProvider.InsertSpace) {
+					result = dataProvider.InsertAction(data, control.ActiveTextAreaControl.TextArea, startOffset, ch);
-						control.Document.Insert(startOffset++, " ");
-					}
-					control.ActiveTextAreaControl.Caret.Position = control.Document.OffsetToPosition(startOffset);
-					
-					result = data.InsertAction(control.ActiveTextAreaControl.TextArea, ch);
 				} finally {
 					control.EndUpdate();
 				}

src/Libraries/ICSharpCode.TextEditor/Project/Src/Gui/CompletionWindow/ICompletionDataProvider.cs

@@ -29,21 +29,38 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 		int DefaultIndex {
 			get;
 		}
+		
 		/// <summary>
-		/// Gets/Sets if a space should be inserted in front of the completed expression.
+		/// Processes a keypress. Returns the action to be run with the key.
 		/// </summary>
-		bool InsertSpace {
+		CompletionDataProviderKeyResult ProcessKey(char key);
-			get;
+		
-			set;
-		}
 		/// <summary>
-		/// Gets if pressing 'key' should trigger the insertion of the currently selected element.
+		/// Executes the insertion. The provider should set the caret position and then
+		/// call data.InsertAction.
 		/// </summary>
-		bool IsInsertionKey(char key);
+		bool InsertAction(ICompletionData data, TextArea textArea, int insertionOffset, char key);
 		
 		/// <summary>
 		/// Generates the completion data. This method is called by the text editor control.
 		/// </summary>
 		ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped);
 	}
+	
+	public enum CompletionDataProviderKeyResult
+	{
+		/// <summary>
+		/// Normal key, used to choose 
+		/// </summary>
+		NormalKey,
+		/// <summary>
+		/// This key triggers insertion of the completed expression
+		/// </summary>
+		InsertionKey,
+		/// <summary>
+		/// Increment both start and end offset of completion region when inserting this
+		/// key. Used to insert space.
+		/// </summary>
+		BeforeStartKey
+	}
 }

src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs

@@ -158,6 +158,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (cu != null) {
 				callingClass = cu.GetInnermostClass(caretLine, caretColumn);
 			}
+			callingMember = GetCurrentMember();
 			return true;
 		}
 		
@@ -282,7 +283,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			lookupTableVisitor = new LookupTableVisitor(languageProperties.NameComparer);
 			
-			callingMember = GetCurrentMember();
 			if (callingMember != null) {
 				CompilationUnit cu = ParseCurrentMemberAsCompilationUnit(fileContent);
 				if (cu != null) {
@@ -498,8 +498,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		public TextReader ExtractCurrentMethod(string fileContent)
 		{
-			if (callingMember == null)
-				callingMember = GetCurrentMember();
 			if (callingMember == null)
 				return null;
 			return ExtractMethod(fileContent, callingMember, language, caretLine);

src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/AbstractCompletionDataProvider.cs

@@ -65,9 +65,28 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		/// <summary>
 		/// Gets if pressing 'key' should trigger the insertion of the currently selected element.
 		/// </summary>
-		public virtual bool IsInsertionKey(char key)
+		public virtual CompletionDataProviderKeyResult ProcessKey(char key)
 		{
-			return !char.IsLetterOrDigit(key) && key != '_';
+			CompletionDataProviderKeyResult res;
+			if (key == ' ' && insertSpace) {
+				res = CompletionDataProviderKeyResult.BeforeStartKey;
+			} else if (char.IsLetterOrDigit(key) || key == '_') {
+				res = CompletionDataProviderKeyResult.NormalKey;
+			} else {
+				res = CompletionDataProviderKeyResult.InsertionKey;
+			}
+			insertSpace = false;
+			return res;
+		}
+		
+		public virtual bool InsertAction(ICompletionData data, TextArea textArea, int insertionOffset, char key)
+		{
+			if (InsertSpace) {
+				textArea.Document.Insert(insertionOffset++, " ");
+			}
+			textArea.Caret.Position = textArea.Document.OffsetToPosition(insertionOffset);
+			
+			return data.InsertAction(textArea, key);
 		}
 		
 		/// <summary>
@@ -75,7 +94,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		/// </summary>
 		public abstract ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped);
 	}
-	
+
 	public abstract class AbstractCodeCompletionDataProvider : AbstractCompletionDataProvider
 	{
 		Hashtable insertedElements           = new Hashtable();

src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CachedCompletionDataProvider.cs

@@ -44,9 +44,14 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			}
 		}
 		
-		public override bool IsInsertionKey(char key)
+		public override CompletionDataProviderKeyResult ProcessKey(char key)
 		{
-			return baseProvider.IsInsertionKey(key);
+			return baseProvider.ProcessKey(key);
+		}
+		
+		public override bool InsertAction(ICompletionData data, TextArea textArea, int insertionOffset, char key)
+		{
+			return baseProvider.InsertAction(data, textArea, insertionOffset, key);
 		}
 		
 		public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
@@ -58,5 +63,15 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			}
 			return completionData;
 		}
+		
+		[Obsolete("Cannot use InsertSpace on CachedCompletionDataProvider, please set it on the underlying provider!")]
+		public new bool InsertSpace {
+			get {
+				return false;
+			}
+			set {
+				throw new NotSupportedException();
+			}
+		}
 	}
 }