Fixed "partial" context.

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -898,36 +898,35 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				if (!IsLineEmptyUpToEol ())
 					return null;
 				var overrideCls = CSharpParsedFile.GetInnermostTypeDefinition (location);
-								
 				if (overrideCls != null && (overrideCls.Kind == TypeKind.Class || overrideCls.Kind == TypeKind.Struct)) {
 					string modifiers = document.GetText (firstMod, wordStart - firstMod);
 					return GetOverrideCompletionData (overrideCls, modifiers);
 				}
 				return null;
-//				case "partial":
+			case "partial":
-//					// Look for modifiers, in order to find the beginning of the declaration
+				// Look for modifiers, in order to find the beginning of the declaration
-//					firstMod = wordStart;
+				firstMod = wordStart;
-//					i = wordStart;
+				i = wordStart;
-//					for (int n = 0; n < 3; n++) {
+				for (int n = 0; n < 3; n++) {
-//						string mod = GetPreviousToken (ref i, true);
+					string mod = GetPreviousToken (ref i, true);
-//						if (mod == "public" || mod == "protected" || mod == "private" || mod == "internal" || mod == "sealed") {
+					if (mod == "public" || mod == "protected" || mod == "private" || mod == "internal" || mod == "sealed") {
-//							firstMod = i;
+						firstMod = i;
-//						} else if (mod == "static") {
+					} else if (mod == "static") {
-//							// static methods are not overridable
+						// static methods are not overridable
-//							return null;
+						return null;
-//						} else
+					} else
-//							break;
+						break;
-//					}
+				}
-//					if (!IsLineEmptyUpToEol ())
+				if (!IsLineEmptyUpToEol ())
-//						return null;
+					return null;
-//					
+				
-//					overrideCls = NRefactoryResolver.GetTypeAtCursor (Document.CompilationUnit, Document.FileName, new TextLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset));
+				overrideCls = CSharpParsedFile.GetInnermostTypeDefinition (location);
-//					if (overrideCls != null && (overrideCls.ClassType == ClassType.Class || overrideCls.ClassType == ClassType.Struct)) {
+				if (overrideCls != null && (overrideCls.Kind == TypeKind.Class || overrideCls.Kind == TypeKind.Struct)) {
-//						string modifiers = document.GetTextBetween (firstMod, wordStart);
+					string modifiers = document.GetText (firstMod, wordStart - firstMod);
-//						return GetPartialCompletionData (completionContext, overrideCls, modifiers);
+					return GetPartialCompletionData (overrideCls, modifiers);
-//					}
+				}
-//					return null;
+				return null;
-//					
+				
 			case "public":
 			case "protected":
 			case "private":
@@ -1125,6 +1124,79 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return wrapper.Result;
 		}
 		
+		IEnumerable<ICompletionData> GetPartialCompletionData (ITypeDefinition type, string modifiers)
+		{
+			var wrapper = new CompletionDataWrapper (this);
+			var partialType = GetTypeFromContext (type);
+			if (partialType != null) {
+				int declarationBegin = offset;
+				int j = declarationBegin;
+				for (int i = 0; i < 3; i++) {
+					switch (GetPreviousToken (ref j, true)) {
+					case "public":
+					case "protected":
+					case "private":
+					case "internal":
+					case "sealed":
+					case "override":
+						declarationBegin = j;
+						break;
+					case "static":
+						return null; // don't add override completion for static members
+					}
+				}
+				
+				var methods = new List<IMethod> ();
+				// gather all partial methods without implementation
+				foreach (var part in partialType.GetParts ()) 
+					foreach (var method in part.Methods) {
+						if (method.IsPartial && method.BodyRegion.IsEmpty) {
+							methods.Add (method);
+						}
+					}
+
+				// now filter all methods that are implemented in the compound class
+				foreach (var part in partialType.GetParts ()) {
+					if (part == type)
+						continue;
+					for (int i = 0; i < methods.Count; i++) {
+						var curMethod = methods[i];
+						var method = GetImplementation (partialType, curMethod);
+						if (method != null && !method.BodyRegion.IsEmpty) {
+							methods.RemoveAt (i);
+							i--;
+							continue;
+						}
+					}
+				}
+
+				foreach (var method in methods) {
+					wrapper.Add (factory.CreateNewOverrideCompletionData (declarationBegin, type, method));
+				}
+				
+			}
+			return wrapper.Result;
+		}
+		
+		IMethod GetImplementation (ITypeDefinition type, IMethod method)
+		{
+			foreach (var cur in type.Methods) {
+				if (cur.Name == method.Name && cur.Parameters.Count == method.Parameters.Count && !cur.BodyRegion.IsEmpty) {
+					bool equal = true;
+					for (int i = 0; i < cur.Parameters.Count; i++) {
+						if (!cur.Parameters[i].Type.Resolve (ctx).Equals (method.Parameters[i].Type.Resolve (ctx))) {
+							equal = false;
+							break;
+						}
+					}
+					if (equal)
+						return cur;
+				}
+			}
+			return null;
+		}
+		
+		
 		static string GetNameWithParamCount (IMember member)
 		{
 			var e = member as IMethod;

ICSharpCode.NRefactory.CSharp/Parser/TypeSystemConvertVisitor.cs

@@ -710,6 +710,9 @@ namespace ICSharpCode.NRefactory.CSharp
 			m.IsShadowing = (modifiers & Modifiers.New) != 0;
 			m.IsStatic = (modifiers & Modifiers.Static) != 0;
 			m.IsVirtual = (modifiers & Modifiers.Virtual) != 0;
+			m.IsPartial = (modifiers & Modifiers.Partial) != 0;
+			
+			
 		}
 		
 		static Accessibility? GetAccessibility(Modifiers modifiers)

ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs

@@ -483,6 +483,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return false; }
 			}
 			
+			bool IMember.IsPartial {
+				get { return false; }
+			}
+			
 			EntityType IEntity.EntityType {
 				get { return EntityType.Operator; }
 			}

ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/CodeCompletionBugTests.cs

@@ -3593,5 +3593,27 @@ void TestMethod ()
 			Assert.IsNotNull (provider.Find ("TF1"));
 		}
 		
+
+		[Test()]
+		public void TestPartialCompletionData ()
+		{
+			var provider = CreateProvider (
+@"
+public partial class TestMe
+{
+	partial void MyMethod ();
+	partial void Implemented ();
+}
+
+public partial class TestMe
+{
+	$partial $
+
+	partial void Implemented () { }
+}");
+			Assert.IsNotNull (provider, "provider not found.");
+			Assert.IsNotNull (provider.Find ("MyMethod"), "method 'MyMethod' not found.");
+			Assert.IsNull (provider.Find ("Implemented"), "method 'Implemented'  found.");
+		}		
 	}
 }

ICSharpCode.NRefactory/TypeSystem/IMember.cs

@@ -73,6 +73,13 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		bool IsOverridable {
 			get;
 		}
+		
+		/// <summary>
+		/// Gets if the member is partial. Returns true when the member is "partial".
+		/// </summary>
+		bool IsPartial {
+			get;
+		}
 	}
 	
 	#if WITH_CONTRACTS

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractMember.cs

@@ -53,6 +53,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		const ushort FlagVirtual   = 0x0010;
 		const ushort FlagOverride  = 0x0020;
 		const ushort FlagStatic    = 0x0040;
+		const ushort FlagPartial   = 0x0080;
+		
 		// Flags of form 0xY000 are reserved for use in derived classes (DefaultMethod etc.)
 		
 		protected override void FreezeInternal()
@@ -144,6 +146,15 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
+		public bool IsPartial {
+			get { return flags[FlagPartial]; }
+			set {
+				CheckBeforeMutation();
+				flags[FlagPartial] = value;
+			}
+		}
+		
+		
 		public bool IsOverridable {
 			get {
 				return (IsAbstract || IsVirtual || IsOverride) && !IsSealed;

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs

@@ -166,6 +166,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return memberDefinition.IsProtectedAndInternal; }
 		}
 		
+		public bool IsPartial {
+			get { return memberDefinition.IsPartial; }
+		}
+		
 		public IProjectContent ProjectContent {
 			get { return memberDefinition.ProjectContent; }
 		}