Fixed SD2-1143: #Develop doesn't show 'Source / Design' tabs for VB froms created with VS 2005.

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

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/BooDesignerLoader.cs

@@ -111,7 +111,7 @@ namespace Grunwald.BooBinding.Designer
 			Module mainModule = Parse(textEditorControl.FileName, lastTextContent);
 			
 			IClass formClass;
-			List<IClass> parts = NRefactoryDesignerLoader.FindFormClassParts(parseInfo, out formClass);
+			IList<IClass> parts = NRefactoryDesignerLoader.FindFormClassParts(parseInfo, out formClass);
 			
 			IMethod initMethod = FormsDesignerSecondaryDisplayBinding.GetInitializeComponents(formClass);
 			

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/DesignerLoader/NRefactoryDesignerLoader.cs

@@ -127,7 +127,7 @@ namespace ICSharpCode.FormsDesigner
 		
 		string lastTextContent;
 		
-		public static List<IClass> FindFormClassParts(ParseInformation parseInfo, out IClass formClass)
+		public static IList<IClass> FindFormClassParts(ParseInformation parseInfo, out IClass formClass)
 		{
 			#if DEBUG
 			if ((Control.ModifierKeys & (Keys.Alt | Keys.Control)) == (Keys.Alt | Keys.Control)) {
@@ -147,14 +147,11 @@ namespace ICSharpCode.FormsDesigner
 			
 			// Initialize designer for formClass
 			formClass = formClass.GetCompoundClass();
-			List<IClass> parts;
 			if (formClass is CompoundClass) {
-				parts = (formClass as CompoundClass).Parts;
+				return (formClass as CompoundClass).GetParts();
 			} else {
-				parts = new List<IClass>();
+				return new IClass[] { formClass };
-				parts.Add(formClass);
 			}
-			return parts;
 		}
 		
 		// Steps to load the designer:
@@ -173,7 +170,7 @@ namespace ICSharpCode.FormsDesigner
 			ParseInformation parseInfo = ParserService.GetParseInformation(textEditorControl.FileName);
 			
 			IClass formClass;
-			List<IClass> parts = FindFormClassParts(parseInfo, out formClass);
+			IList<IClass> parts = FindFormClassParts(parseInfo, out formClass);
 			
 			List<KeyValuePair<string, CompilationUnit>> compilationUnits = new List<KeyValuePair<string, CompilationUnit>>();
 			bool foundInitMethod = false;

src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/NRefactoryResourceResolver.cs

@@ -236,7 +236,7 @@ namespace Hornung.ResourceToolkit.Resolver
 					if (resourceClass != null) {
 						CompoundClass cc = resourceClass.GetCompoundClass() as CompoundClass;
 						
-						foreach (IClass c in (cc == null ? new IClass[] { resourceClass } : (IEnumerable<IClass>)cc.Parts)) {
+						foreach (IClass c in (cc == null ? new IClass[] { resourceClass } : cc.GetParts())) {
 							if (c.CompilationUnit != null && c.CompilationUnit.FileName != null) {
 								
 								#if DEBUG

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

@@ -66,7 +66,7 @@ namespace ICSharpCode.SharpDevelop.Gui.ClassBrowser
 					
 					if (node != null) {
 						CompoundClass cc = c as CompoundClass;
-						if (cc != null && cc.Parts.Count > 0) {
+						if (cc != null) {
 							node.Class = cc; // update members after part has been removed
 						} else {
 							path.Nodes.Remove(node);

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

@@ -56,7 +56,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 		{
 			CompoundClass cc = c as CompoundClass;
 			if (cc != null) {
-				return cc.Parts;
+				return cc.GetParts();
 			} else {
 				return new IClass[] {c};
 			}

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

@@ -314,7 +314,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			List<string> list = new List<string>();
 			CompoundClass cc = c as CompoundClass;
 			if (cc != null) {
-				foreach (IClass part in cc.Parts) {
+				foreach (IClass part in cc.GetParts()) {
 					string fileName = part.CompilationUnit.FileName;
 					if (fileName != null)
 						list.Add(fileName);

src/Main/Base/Project/Src/TextEditor/Gui/Editor/QuickClassBrowserPanel.cs

@@ -339,7 +339,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				IClass currentPart = c;
 				if (c.IsPartial) {
 					CompoundClass cc = c.GetCompoundClass() as CompoundClass;
-					if (cc != null && cc.Parts.Count > 0) {
+					if (cc != null) {
 						partialMode = true;
 						c = cc;
 					}

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

@@ -170,11 +170,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 				return (modifiers & ModifierEnum.New) == ModifierEnum.New;
 			}
 		}
-		public bool IsPartial {
-			get {
-				return (modifiers & ModifierEnum.Partial) == ModifierEnum.Partial;
-			}
-		}
 		public bool IsSynthetic {
 			get {
 				return (modifiers & ModifierEnum.Synthetic) == ModifierEnum.Synthetic;

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

@@ -15,14 +15,20 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// </summary>
 	public class CompoundClass : DefaultClass
 	{
-		List<IClass> parts = new List<IClass>();
+		/// <summary>
+		/// The parts this class is based on.
+		/// Requires manual locking!
+		/// </summary>
+		internal List<IClass> parts = new List<IClass>();
 		
 		/// <summary>
-		/// Gets the parts this class is based on.
+		/// Gets the parts this class is based on. This method is thread-safe and
+		/// returns a copy of the list!
 		/// </summary>
-		public List<IClass> Parts {
+		public IList<IClass> GetParts()
-			get {
+		{
-				return parts;
+			lock (this) {
+				return parts.ToArray();
 			}
 		}
 		
@@ -38,7 +44,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// <summary>
 		/// Re-calculate information from class parts (Modifier, Base classes, Type parameters etc.)
 		/// </summary>
-		public void UpdateInformationFromParts()
+		internal void UpdateInformationFromParts()
 		{
 			// Common for all parts:
 			this.ClassType = parts[0].ClassType;
@@ -47,8 +53,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 			
 			ModifierEnum modifier = ModifierEnum.None;
 			const ModifierEnum defaultClassVisibility = ModifierEnum.Internal;
+			
 			this.BaseTypes.Clear();
-			this.TypeParameters.Clear();
 			this.Attributes.Clear();
 			foreach (IClass part in parts) {
 				if ((part.Modifiers & ModifierEnum.VisibilityMask) != defaultClassVisibility) {
@@ -61,9 +67,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 						this.BaseTypes.Add(rt);
 					}
 				}
-				foreach (ITypeParameter typeParam in part.TypeParameters) {
-					this.TypeParameters.Add(typeParam);
-				}
 				foreach (IAttribute attribute in part.Attributes) {
 					this.Attributes.Add(attribute);
 				}
@@ -74,6 +77,23 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.Modifiers = modifier;
 		}
 		
+		/// <summary>
+		/// Type parameters are same on all parts
+		/// </summary>
+		public override IList<ITypeParameter> TypeParameters {
+			get {
+				lock (this) {
+					// Locking for the time of getting the reference to the sub-list is sufficient:
+					// Classes used for parts never change, instead the whole part is replaced with
+					// a new IClass instance.
+					return parts[0].TypeParameters;
+				}
+			}
+			set {
+				throw new NotSupportedException();
+			}
+		}
+		
 		/// <summary>
 		/// CompoundClass has a normal return type even though IsPartial is set.
 		/// </summary>
@@ -84,51 +104,61 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public override List<IClass> InnerClasses {
 			get {
-				List<IClass> l = new List<IClass>();
+				lock (this) {
-				foreach (IClass part in parts) {
+					List<IClass> l = new List<IClass>();
-					l.AddRange(part.InnerClasses);
+					foreach (IClass part in parts) {
+						l.AddRange(part.InnerClasses);
+					}
+					return l;
 				}
-				return l;
 			}
 		}
 		
 		public override List<IField> Fields {
 			get {
-				List<IField> l = new List<IField>();
+				lock (this) {
-				foreach (IClass part in parts) {
+					List<IField> l = new List<IField>();
-					l.AddRange(part.Fields);
+					foreach (IClass part in parts) {
+						l.AddRange(part.Fields);
+					}
+					return l;
 				}
-				return l;
 			}
 		}
 		
 		public override List<IProperty> Properties {
 			get {
-				List<IProperty> l = new List<IProperty>();
+				lock (this) {
-				foreach (IClass part in parts) {
+					List<IProperty> l = new List<IProperty>();
-					l.AddRange(part.Properties);
+					foreach (IClass part in parts) {
+						l.AddRange(part.Properties);
+					}
+					return l;
 				}
-				return l;
 			}
 		}
 		
 		public override List<IMethod> Methods {
 			get {
-				List<IMethod> l = new List<IMethod>();
+				lock (this) {
-				foreach (IClass part in parts) {
+					List<IMethod> l = new List<IMethod>();
-					l.AddRange(part.Methods);
+					foreach (IClass part in parts) {
+						l.AddRange(part.Methods);
+					}
+					return l;
 				}
-				return l;
 			}
 		}
 		
 		public override List<IEvent> Events {
 			get {
-				List<IEvent> l = new List<IEvent>();
+				lock (this) {
-				foreach (IClass part in parts) {
+					List<IEvent> l = new List<IEvent>();
-					l.AddRange(part.Events);
+					foreach (IClass part in parts) {
+						l.AddRange(part.Events);
+					}
+					return l;
 				}
-				return l;
 			}
 		}
 	}

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

@@ -121,6 +121,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public bool IsPartial {
+			get {
+				return (this.Modifiers & ModifierEnum.Partial) == ModifierEnum.Partial;
+			}
+			set {
+				if (value)
+					this.Modifiers |= ModifierEnum.Partial;
+				else
+					this.Modifiers &= ~ModifierEnum.Partial;
+				defaultReturnType = null; // re-create default return type
+			}
+		}
+		
 		public IClass GetCompoundClass()
 		{
 			return this.DefaultReturnType.GetUnderlyingClass() ?? this;

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

@@ -131,5 +131,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 		bool HasExtensionMethods {
 			get;
 		}
+		
+		bool IsPartial {
+			get;
+			set;
+		}
 	}
 }

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

@@ -70,10 +70,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get;
 		}
 
-		bool IsPartial {
-			get;
-		}
-
 		bool IsReadonly {
 			get;
 		}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/LanguageProperties.cs

@@ -114,7 +114,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 		
 		/// <summary>
-		/// Gets if namespaces can be imported (i.e. Imports System, Dim a As Collections.ArrayList)
+		/// Gets if namespaces are imported (i.e. Imports System, Dim a As Collections.ArrayList)
 		/// </summary>
 		public virtual bool ImportNamespaces {
 			get {
@@ -140,6 +140,16 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		/// <summary>
+		/// Gets if the language allows partial classes where the partial modifier is not
+		/// used on any part.
+		/// </summary>
+		public virtual bool ImplicitPartialClasses {
+			get {
+				return false;
+			}
+		}
+		
 		/// <summary>
 		/// Allow invoking an object constructor outside of ExpressionContext.ObjectCreation.
 		/// Used for Boo, which creates instances like this: 'self.Size = Size(10, 20)'

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ProjectContent/DefaultProjectContent.cs

@@ -305,29 +305,44 @@ namespace ICSharpCode.SharpDevelop.Dom
 		protected void AddClassToNamespaceListInternal(IClass addClass)
 		{
 			string fullyQualifiedName = addClass.FullyQualifiedName;
-			if (addClass.IsPartial) {
+			IClass existingClass = GetClassInternal(fullyQualifiedName, addClass.TypeParameters.Count, language);
-				LoggingService.Debug("Adding partial class " + addClass.Name + " from " + Path.GetFileName(addClass.CompilationUnit.FileName));
+			if (existingClass != null && existingClass.TypeParameters.Count == addClass.TypeParameters.Count) {
-				CompoundClass compound = GetClassInternal(fullyQualifiedName, addClass.TypeParameters.Count, language) as CompoundClass;
+				//LoggingService.Debug("Adding partial class " + addClass.Name + " from " + Path.GetFileName(addClass.CompilationUnit.FileName));
+				CompoundClass compound = existingClass as CompoundClass;
 				if (compound != null) {
+					// mark the class as partial
+					// (VB allows specifying the 'partial' modifier only on one part)
+					addClass.IsPartial = true;
+					
 					// possibly replace existing class (look for CU with same filename)
 					lock (compound) {
-						for (int i = 0; i < compound.Parts.Count; i++) {
+						for (int i = 0; i < compound.parts.Count; i++) {
-							if (compound.Parts[i].CompilationUnit.FileName == addClass.CompilationUnit.FileName) {
+							if (compound.parts[i].CompilationUnit.FileName == addClass.CompilationUnit.FileName) {
-								compound.Parts[i] = addClass;
+								compound.parts[i] = addClass;
 								compound.UpdateInformationFromParts();
-								LoggingService.Debug("Replaced old part!");
+								//LoggingService.Debug("Replaced old part!");
 								return;
 							}
 						}
-						compound.Parts.Add(addClass);
+						compound.parts.Add(addClass);
 						compound.UpdateInformationFromParts();
 					}
-					LoggingService.Debug("Added new part!");
+					//LoggingService.Debug("Added new part!");
 					return;
-				} else {
+				} else if (addClass.IsPartial || language.ImplicitPartialClasses) {
-					addClass = new CompoundClass(addClass);
+					// Merge existing non-partial class with addClass
-					LoggingService.Debug("Compound created!");
+					
+					// Ensure partial modifier is set everywhere:
+					addClass.IsPartial = true;
+					existingClass.IsPartial = true;
+					
+					addClass = compound = new CompoundClass(addClass);
+					compound.parts.Add(existingClass);
+					compound.UpdateInformationFromParts();
 				}
+			} else if (addClass.IsPartial) {
+				addClass = new CompoundClass(addClass);
+				//LoggingService.Debug("Compound created!");
 			}
 			
 			IClass oldDictionaryClass;
@@ -471,8 +486,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 				CompoundClass compound = GetClassInternal(fullyQualifiedName, @class.TypeParameters.Count, language) as CompoundClass;
 				if (compound == null) return;
 				lock (compound) {
-					compound.Parts.Remove(@class);
+					compound.parts.Remove(@class);
-					if (compound.Parts.Count > 0) {
+					if (compound.parts.Count > 0) {
 						compound.UpdateInformationFromParts();
 						return;
 					} else {