Implement C# forms designer loader.

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

@@ -8,6 +8,7 @@
 		<Identity name = "ICSharpCode.CSharpBinding"/>
 		<!-- The AvalonEdit dependency is necessary for the context action option page -->
 		<Dependency addin = "ICSharpCode.AvalonEdit" />
+		<Dependency addin = "ICSharpCode.FormsDesigner" requirePreload = "true"/>
 	</Manifest>
 	
 	<Runtime>
@@ -321,4 +322,11 @@
 		<CSharpCodeActionProvider class = "ICSharpCode.NRefactory.CSharp.Refactoring.UseVarKeywordAction" />
 		<Class class="CSharpBinding.Refactoring.MoveTypeToFileContextAction" />
 	</Path>
+	
+	<Path name = "/SharpDevelop/Workbench/DisplayBindings">
+		<DisplayBinding id    = "CSharpFormsDesigner"
+		                type  = "Secondary"
+		                class = "CSharpBinding.FormsDesigner.FormsDesignerSecondaryDisplayBinding"
+		                fileNamePattern = "\.cs$"/>
+	</Path>
 </AddIn>

src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.csproj

@@ -54,6 +54,7 @@
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Design" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xaml">
@@ -77,6 +78,11 @@
     <Compile Include="Src\Completion\OverrideToStringCompletionData.cs" />
     <Compile Include="Src\Completion\SegmentTrackingOutputFormatter.cs" />
     <Compile Include="Src\FormattingStrategy\CSharpFormatter.cs" />
+    <Compile Include="Src\FormsDesigner\CSharpDesignerLoader.cs" />
+    <Compile Include="Src\FormsDesigner\CSharpDesignerLoaderProvider.cs" />
+    <Compile Include="Src\FormsDesigner\CSharpFormsDesignerLoaderContext.cs" />
+    <Compile Include="Src\FormsDesigner\ICSharpDesignerLoaderContext.cs" />
+    <Compile Include="Src\FormsDesigner\SecondaryDisplayBinding.cs" />
     <Compile Include="Src\Parser\FoldingVisitor.cs" />
     <Compile Include="Src\Refactoring\AbstractInlineRefactorDialog.cs" />
     <Compile Include="Src\Refactoring\CSharpCodeGenerator.cs" />
@@ -197,6 +203,11 @@
       <Name>ICSharpCode.SharpDevelop.Widgets</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\DisplayBindings\FormsDesigner\Project\FormsDesigner.csproj">
+      <Project>{9E951B9F-6AC2-4537-9D0B-0AE7C026D5A1}</Project>
+      <Name>FormsDesigner</Name>
+      <Private>False</Private>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Page Include="Src\Refactoring\InsertCtorDialog.xaml" />
@@ -206,5 +217,8 @@
     <Page Include="Src\Refactoring\OverrideToStringMethodDialog.xaml" />
     <Page Include="Src\Refactoring\SearchForIssuesDialog.xaml" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Src\FormsDesigner" />
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>

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

@@ -3,6 +3,9 @@
 
 using System;
 using System.Threading.Tasks;
+using ICSharpCode.Core;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.SharpDevelop;
 using CSharpBinding.Parser;
 using CSharpBinding.Refactoring;
 using ICSharpCode.NRefactory.CSharp;
@@ -51,5 +54,23 @@ namespace CSharpBinding
 						return new CSharpAstResolver(compilation, new SyntaxTree(), new CSharpUnresolvedFile { FileName = ec.FileName });
 				});
 		}
+		
+		/// <summary>
+		/// Retrieves the declaration for the specified entity.
+		/// Returns null if the entity is not defined in C# source code.
+		/// </summary>
+		public static EntityDeclaration GetDeclaration(this IEntity entity, out CSharpFullParseInformation parseInfo)
+		{
+			if (entity == null || string.IsNullOrEmpty(entity.Region.FileName)) {
+				parseInfo = null;
+				return null;
+			}
+			parseInfo = SD.ParserService.Parse(FileName.Create(entity.Region.FileName),
+			                                   parentProject: entity.ParentAssembly.GetProject())
+				as CSharpFullParseInformation;
+			if (parseInfo == null)
+				return null;
+			return parseInfo.SyntaxTree.GetNodeAt<EntityDeclaration>(entity.Region.Begin);
+		}
 	}
 }

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormsDesigner/CSharpDesignerLoader.cs

@@ -0,0 +1,139 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.Diagnostics;
+using System.Linq;
+using System.Windows.Forms;
+using ICSharpCode.Core;
+using ICSharpCode.FormsDesigner;
+using ICSharpCode.NRefactory.CSharp;
+using ICSharpCode.NRefactory.CSharp.Resolver;
+using ICSharpCode.NRefactory.Editor;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.SharpDevelop;
+using Microsoft.CSharp;
+using CSharpBinding.Parser;
+
+namespace CSharpBinding.FormsDesigner
+{
+	public class CSharpDesignerLoader : AbstractCodeDomDesignerLoader
+	{
+		readonly CodeDomProvider codeDomProvider = new CSharpCodeProvider();
+		readonly ICSharpDesignerLoaderContext context;
+		
+		public CSharpDesignerLoader(ICSharpDesignerLoaderContext context)
+		{
+			this.context = context;
+		}
+		
+		protected override void Write(CodeCompileUnit unit)
+		{
+			throw new NotImplementedException();
+		}
+		
+		protected override CodeDomProvider CodeDomProvider {
+			get {
+				return codeDomProvider;
+			}
+		}
+		
+		ITextSourceVersion lastTextContentVersion;
+		
+		protected override bool IsReloadNeeded()
+		{
+			return base.IsReloadNeeded() || context.DesignerCodeFileDocument.Version.Equals(lastTextContentVersion);
+		}
+		
+		IUnresolvedTypeDefinition primaryPart;
+		
+		// Steps to load the designer:
+		// - Parse main file
+		// - Find other files containing parts of the form
+		// - Parse all files and look for fields (for controls) and InitializeComponents method
+		// - Create CodeDom objects for fields and InitializeComponents statements
+		// - If debug build and Ctrl pressed, output CodeDom to console
+		// - Return CodeDom objects to the .NET designer
+		protected override CodeCompileUnit Parse()
+		{
+			SD.Log.Debug("CSharpDesignerLoader.Parse()");
+			
+			lastTextContentVersion = context.DesignerCodeFileDocument.Version;
+			var primaryParseInfo = context.GetPrimaryFileParseInformation();
+			var compilation = context.GetCompilation();
+			
+			// Find designer class
+			ITypeDefinition designerClass = null;
+			IMethod initializeComponents = null;
+			foreach (var utd in primaryParseInfo.UnresolvedFile.TopLevelTypeDefinitions) {
+				var td = utd.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).GetDefinition();
+				if (td != null && FormsDesignerSecondaryDisplayBinding.IsDesignable(td)) {
+					primaryPart = utd;
+					designerClass = td;
+					initializeComponents = FormsDesignerSecondaryDisplayBinding.GetInitializeComponents(td);
+					break;
+				}
+			}
+			
+			if (initializeComponents == null) {
+				throw new FormsDesignerLoadException("The InitializeComponent method was not found. Designer cannot be loaded.");
+			}
+			Debug.Assert(primaryPart != null);
+			Debug.Assert(designerClass != null);
+			
+			bool isFirstClassInFile = primaryParseInfo.UnresolvedFile.TopLevelTypeDefinitions[0] == primaryPart;
+			
+			// TODO: translate
+			const string missingReferenceMessage = "Your project is missing a reference to '${Name}' - please add it using 'Project > Add Reference'.";
+			if (compilation.FindType(typeof(System.Drawing.Point)).Kind == TypeKind.Unknown) {
+				throw new FormsDesignerLoadException(StringParser.Parse(missingReferenceMessage, new StringTagPair("Name", "System.Drawing")));
+			}
+			if (compilation.FindType(typeof(System.Windows.Forms.Form)).Kind == TypeKind.Unknown) {
+				throw new FormsDesignerLoadException(StringParser.Parse(missingReferenceMessage, new StringTagPair("Name" , "System.Windows.Forms")));
+			}
+			
+			CodeDomConvertVisitor cv = new CodeDomConvertVisitor();
+			cv.UseFullyQualifiedTypeNames = true;
+			
+			CSharpFullParseInformation designerParseInfo;
+			MethodDeclaration initializeComponentsDeclaration = initializeComponents.GetDeclaration(out designerParseInfo) as MethodDeclaration;
+			if (initializeComponentsDeclaration == null)
+				throw new FormsDesignerLoadException("Could not find source code for InitializeComponents");
+			var resolver = designerParseInfo.GetResolver(compilation);
+			var codeMethod = (CodeMemberMethod) cv.Convert(initializeComponentsDeclaration, resolver);
+			var codeClass = new CodeTypeDeclaration(designerClass.Name);
+			codeClass.Attributes = MemberAttributes.Public;
+			codeClass.BaseTypes.AddRange(designerClass.DirectBaseTypes.Select(cv.Convert).ToArray());
+			codeClass.Members.Add(codeMethod);
+			
+			foreach (var field in designerClass.Fields) {
+				var codeField = new CodeMemberField(cv.Convert(field.Type), field.Name);
+				codeClass.Members.Add(codeField);
+			}
+			var codeNamespace = new CodeNamespace(designerClass.Namespace);
+			codeNamespace.Types.Add(codeClass);
+			var codeUnit = new CodeCompileUnit();
+			codeUnit.Namespaces.Add(codeNamespace);
+			
+			// output generated CodeDOM to the console :
+			#if DEBUG
+			if ((Control.ModifierKeys & Keys.Control) == Keys.Control) {
+				CodeDomVerboseOutputGenerator outputGenerator = new CodeDomVerboseOutputGenerator();
+				outputGenerator.GenerateCodeFromMember(codeMethod, Console.Out, null);
+				this.CodeDomProvider.GenerateCodeFromCompileUnit(codeUnit, Console.Out, null);
+			}
+			#endif
+			
+			LoggingService.Debug("NRefactoryDesignerLoader.Parse() finished");
+			
+			if (!isFirstClassInFile) {
+				MessageService.ShowWarning("The form must be the first class in the file in order for form resources be compiled correctly.\n" +
+				                           "Please move other classes below the form class definition or move them to other files.");
+			}
+			
+			return codeUnit;
+		}
+	}
+}

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormsDesigner/CSharpDesignerLoaderProvider.cs

@@ -0,0 +1,47 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Design.Serialization;
+using System.Linq;
+using ICSharpCode.FormsDesigner;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.Workbench;
+using CSharpBinding.Parser;
+
+namespace CSharpBinding.FormsDesigner
+{
+	public class CSharpDesignerLoaderProvider : IDesignerLoaderProvider
+	{
+		public DesignerLoader CreateLoader(FormsDesignerViewContent viewContent)
+		{
+			return new CSharpDesignerLoader(new CSharpFormsDesignerLoaderContext(viewContent));
+		}
+		
+		public IReadOnlyList<OpenedFile> GetSourceFiles(FormsDesignerViewContent viewContent, out OpenedFile designerCodeFile)
+		{
+			// get new initialize components
+			var parsedFile = SD.ParserService.ParseFile(viewContent.PrimaryFileName, viewContent.PrimaryFileContent);
+			var compilation = SD.ParserService.GetCompilationForFile(viewContent.PrimaryFileName);
+			foreach (var utd in parsedFile.TopLevelTypeDefinitions) {
+				var td = utd.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).GetDefinition();
+				if (FormsDesignerSecondaryDisplayBinding.IsDesignable(td)) {
+					var initializeComponents = FormsDesignerSecondaryDisplayBinding.GetInitializeComponents(td);
+					if (initializeComponents != null) {
+						string designerFileName = initializeComponents.Region.FileName;
+						if (designerFileName != null) {
+							designerCodeFile = SD.FileService.GetOrCreateOpenedFile(designerFileName);
+							return td.Parts
+								.Select(p => SD.FileService.GetOrCreateOpenedFile(p.UnresolvedFile.FileName))
+								.Distinct().ToList();
+						}
+					}
+				}
+			}
+			
+			throw new FormsDesignerLoadException("Could not find InitializeComponent method in any part of the open class.");
+		}
+	}
+}

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormsDesigner/CSharpFormsDesignerLoaderContext.cs

@@ -0,0 +1,47 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.FormsDesigner;
+using ICSharpCode.NRefactory.Editor;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.SharpDevelop;
+using CSharpBinding.Parser;
+
+namespace CSharpBinding.FormsDesigner
+{
+	class CSharpFormsDesignerLoaderContext : ICSharpDesignerLoaderContext
+	{
+		readonly FormsDesignerViewContent viewContent;
+		
+		public CSharpFormsDesignerLoaderContext(FormsDesignerViewContent viewContent)
+		{
+			this.viewContent = viewContent;
+		}
+		
+		public IDocument PrimaryFileDocument {
+			get {
+				return viewContent.PrimaryFileDocument;
+			}
+		}
+		
+		public IDocument DesignerCodeFileDocument {
+			get {
+				return viewContent.DesignerCodeFileDocument;
+			}
+		}
+		
+		public CSharpFullParseInformation GetPrimaryFileParseInformation()
+		{
+			return SD.ParserService.Parse(viewContent.PrimaryFileName, viewContent.PrimaryFileDocument)
+				as CSharpFullParseInformation;
+		}
+		
+		public ICompilation GetCompilation()
+		{
+			return SD.ParserService.GetCompilationForFile(viewContent.PrimaryFileName);
+		}
+	}
+}
+
+

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormsDesigner/ICSharpDesignerLoaderContext.cs

@@ -0,0 +1,21 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.NRefactory.Editor;
+using ICSharpCode.NRefactory.TypeSystem;
+using CSharpBinding.Parser;
+
+namespace CSharpBinding.FormsDesigner
+{
+	/// <summary>
+	/// Description of ICSharpDesignerLoaderContext.
+	/// </summary>
+	public interface ICSharpDesignerLoaderContext
+	{
+		//IDocument PrimaryFileDocument { get; }
+		IDocument DesignerCodeFileDocument { get; }
+		CSharpFullParseInformation GetPrimaryFileParseInformation();
+		ICompilation GetCompilation();
+	}
+}

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormsDesigner/SecondaryDisplayBinding.cs

@@ -2,19 +2,15 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
-using System.IO;
 using System.Linq;
 using ICSharpCode.Core;
-using ICSharpCode.NRefactory;
+using ICSharpCode.FormsDesigner;
 using ICSharpCode.NRefactory.TypeSystem;
-using ICSharpCode.NRefactory.TypeSystem.Implementation;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Editor;
-using ICSharpCode.SharpDevelop.Gui;
-using ICSharpCode.SharpDevelop.Parser;
 using ICSharpCode.SharpDevelop.Workbench;
 
-namespace ICSharpCode.FormsDesigner
+namespace CSharpBinding.FormsDesigner
 {
 	public class FormsDesignerSecondaryDisplayBinding : ISecondaryDisplayBinding
 	{
@@ -59,17 +55,19 @@ namespace ICSharpCode.FormsDesigner
 			return false;
 		}
 
+		public static bool IsDesignable(ITypeDefinition td)
+		{
+			return GetInitializeComponents(td) != null && BaseClassIsFormOrControl(td);
+		}
+		
 		public static bool IsDesignable(IUnresolvedFile parsedFile, ICompilation compilation)
 		{
 			if (parsedFile == null)
 				return false;
 			foreach (var utd in parsedFile.TopLevelTypeDefinitions) {
 				var td = utd.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).GetDefinition();
-				if (td != null) {
+				if (IsDesignable(td)) {
-					IMethod method = GetInitializeComponents(td);
+					return true;
-					if (method != null) {
-						return BaseClassIsFormOrControl(td);
-					}
 				}
 			}
 			return false;
@@ -77,58 +75,27 @@ namespace ICSharpCode.FormsDesigner
 		
 		public bool CanAttachTo(IViewContent viewContent)
 		{
-			if (viewContent is ITextEditorProvider) {
+			ITextEditor textEditor = viewContent.GetService<ITextEditor>();
+			if (textEditor == null)
+				return false;
 			FileName fileName = viewContent.PrimaryFileName;
 			if (fileName == null)
 				return false;
 			
-				ITextEditor textEditor = viewContent.GetService<ITextEditor>();
-				string fileExtension = Path.GetExtension(fileName).ToLowerInvariant();
-				
-				switch (fileExtension) {
-					case ".cs":
-//					case ".vb":
 			var parsedFile = SD.ParserService.ParseFile(fileName, textEditor.Document);
 			var compilation = SD.ParserService.GetCompilationForFile(fileName);
-						if (IsDesignable(parsedFile, compilation))
+			return IsDesignable(parsedFile, compilation);
-							return true;
-						break;
-				}
-			}
-			return false;
 		}
 		
 		public IViewContent[] CreateSecondaryViewContent(IViewContent viewContent)
 		{
-			return new IViewContent[0];
-			/*
 			if (viewContent.SecondaryViewContents.Any(c => c is FormsDesignerViewContent)) {
 				return new IViewContent[0];
 			}
 			
-			string fileExtension = String.Empty;
+			return new IViewContent[] {
-			string fileName      = viewContent.PrimaryFileName;
+				new FormsDesignerViewContent(viewContent, new CSharpDesignerLoaderProvider())
-			
+			};
-			fileExtension = Path.GetExtension(fileName).ToLowerInvariant();
-			
-			IDesignerLoaderProvider loader;
-			IDesignerGenerator generator;
-			
-			switch (fileExtension) {
-				case ".cs":
-//					loader    = new NRefactoryDesignerLoaderProvider(SupportedLanguage.CSharp);
-//					generator = new CSharpDesignerGenerator();
-					throw new NotImplementedException();
-					break;
-				case ".vb":
-					//loader    = new NRefactoryDesignerLoaderProvider(SupportedLanguage.VBNet);
-					//generator = new VBNetDesignerGenerator();
-					throw new NotImplementedException();
-					break;
-				default:
-					throw new ApplicationException("Cannot create content for " + fileExtension);
-			}
-			return new IViewContent[] { new FormsDesignerViewContent(viewContent, loader, generator) }; */
 		}
 	}
 }

src/AddIns/BackendBindings/WixBinding/Project/Src/Gui/WixDialogDesignerLoaderProvider.cs

@@ -17,8 +17,9 @@ namespace ICSharpCode.WixBinding
 			return new WixDialogDesignerLoader((IWixDialogDesigner)viewContent);
 		}
 
-		public IReadOnlyList<OpenedFile> GetSourceFiles(FormsDesignerViewContent viewContent)
+		public IReadOnlyList<OpenedFile> GetSourceFiles(FormsDesignerViewContent viewContent, out OpenedFile designerCodeFile)
 		{
+			designerCodeFile = viewContent.PrimaryFile;
 			return new[] { viewContent.PrimaryFile };
 		}
 	}

src/AddIns/DisplayBindings/FormsDesigner/Project/FormsDesigner.addin

@@ -13,13 +13,6 @@
 		<Import assembly = ":ICSharpCode.SharpDevelop"/>
 	</Runtime>
 	
-	<Path name = "/SharpDevelop/Workbench/DisplayBindings">
-		<DisplayBinding id    = "FormsDesigner"
-		                type  = "Secondary"
-		                class = "ICSharpCode.FormsDesigner.FormsDesignerSecondaryDisplayBinding"
-		                fileNamePattern = "\.(cs|vb)$"/>
-	</Path>
-	
 	<Path name = "/SharpDevelop/FormsDesigner/ContextMenus/SelectionMenu">
 		<MenuItem id          = "ViewCode"
 		          label       = "${res:SharpDevelop.FormsDesigner.ContextMenus.ViewCodeCommand}"

src/AddIns/DisplayBindings/FormsDesigner/Project/FormsDesigner.csproj

@@ -78,6 +78,7 @@
     <Compile Include="Src\DesignerGenerator\CSharpDesignerGenerator.cs" />
     <Compile Include="Src\DesignerGenerator\IDesignerGenerator.cs" />
     <Compile Include="Src\DesignerLoader\AbstractCodeDomDesignerLoader.cs" />
+    <Compile Include="Src\DesignerLoader\CodeDOMVerboseOutputGenerator.cs" />
     <Compile Include="Src\DesignerLoader\NRefactoryDesignerLoader.cs" />
     <Compile Include="Src\DesignerSourceCodeStorage.cs" />
     <Compile Include="Src\Gui\ImageResourceEditorDialog.cs" />
@@ -96,7 +97,6 @@
       <DependentUpon>LocalizationModelOptionsPanel.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Src\SecondaryDisplayBinding.cs" />
     <Compile Include="Src\DesignerViewContent.cs" />
     <Compile Include="Src\FormKeyHandler.cs" />
     <Compile Include="Src\Gui\AddComponentsDialog.cs">

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

@@ -14,7 +14,6 @@ using ICSharpCode.FormsDesigner.Services;
 
 namespace ICSharpCode.FormsDesigner
 {
-	/*
 	/// <summary>
 	/// An abstract base class for CodeDOM designer loaders.
 	/// </summary>
@@ -23,7 +22,6 @@ namespace ICSharpCode.FormsDesigner
 		bool loading;
 		IDesignerLoaderHost designerLoaderHost = null;
 		ITypeResolutionService typeResolutionService = null;
-		readonly IDesignerGenerator generator;
 		
 		public override bool Loading {
 			get { return base.Loading || loading; }
@@ -37,22 +35,6 @@ namespace ICSharpCode.FormsDesigner
 			get { return this.designerLoaderHost; }
 		}
 		
-		protected override CodeDomProvider CodeDomProvider {
-			get { return this.generator.CodeDomProvider; }
-		}
-		
-		protected IDesignerGenerator Generator {
-			get { return this.generator; }
-		}
-		
-		protected AbstractCodeDomDesignerLoader(IDesignerGenerator generator)
-		{
-			if (generator == null) {
-				throw new ArgumentNullException("generator", "Generator cannot be null");
-			}
-			this.generator = generator;
-		}
-		
 		public override void Dispose()
 		{
 			try {
@@ -173,5 +155,4 @@ namespace ICSharpCode.FormsDesigner
 			MessageService.ShowError(sb.ToString());
 		}
 	}
-	*/
 }

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

@@ -0,0 +1,356 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Security.Permissions;
+
+namespace ICSharpCode.FormsDesigner
+{
+	[PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
+	[PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
+	public class CodeDomVerboseOutputGenerator : System.CodeDom.Compiler.CodeGenerator
+	{
+		#region System.CodeDom.Compiler.CodeGenerator abstract class implementation
+		protected override string NullToken {
+			get {
+				return "[NULL]";
+			}
+		}
+
+		protected override void OutputType(CodeTypeReference typeRef)
+		{
+			Output.Write("[CodeTypeReference: {0}", typeRef.BaseType);
+			if (typeRef.ArrayRank > 0) {
+				Output.Write(" Rank:" + typeRef.ArrayRank);
+			}
+			Output.Write("]");
+		}
+		
+		protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e)
+		{
+			Output.Write("[CodeArrayCreateExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e)
+		{
+			Output.Write("[CodeBaseReferenceExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateCastExpression(CodeCastExpression e)
+		{
+			Output.Write("[CodeCastExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateDelegateCreateExpression(CodeDelegateCreateExpression e)
+		{
+			Output.Write("[CodeDelegateCreateExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateFieldReferenceExpression(CodeFieldReferenceExpression e)
+		{
+			Output.Write("[CodeFieldReferenceExpression: Name={0}, Target=", e.FieldName);
+			this.GenerateExpression(e.TargetObject);
+			Output.Write("]");
+		}
+		
+		protected override void GenerateMethodReferenceExpression(CodeMethodReferenceExpression e)
+		{
+			Output.Write("[CodeMethodReferenceExpression: Name={0}, Target=", e.MethodName);
+			this.GenerateExpression(e.TargetObject);
+			Output.Write("]");
+		}
+		
+		protected override void GenerateEventReferenceExpression(CodeEventReferenceExpression e)
+		{
+			Output.Write("[CodeEventReferenceExpression: Name={0}, Target=", e.EventName);
+			this.GenerateExpression(e.TargetObject);
+			Output.Write("]");
+		}
+		
+		protected override void GenerateArgumentReferenceExpression(CodeArgumentReferenceExpression e)
+		{
+			Output.Write("[CodeArgumentReferenceExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateVariableReferenceExpression(CodeVariableReferenceExpression e)
+		{
+			Output.Write("[CodeVariableReferenceExpression: Name={0}]", e.VariableName);
+		}
+		
+		protected override void GenerateIndexerExpression(CodeIndexerExpression e)
+		{
+			Output.Write("[CodeIndexerExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
+		{
+			Output.Write("[CodeArrayIndexerExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateSnippetExpression(CodeSnippetExpression e)
+		{
+			Output.Write("[CodeSnippetExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateMethodInvokeExpression(CodeMethodInvokeExpression e)
+		{
+			Output.Write("[CodeMethodInvokeExpression: Method=");
+			GenerateMethodReferenceExpression(e.Method);
+			Output.Write(", Parameters=");
+			bool first = true;
+			foreach (CodeExpression expr in e.Parameters) {
+				if (first) first = false; else Output.Write(", ");
+				this.GenerateExpression(expr);
+			}
+			Output.Write("]");
+		}
+		
+		protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
+		{
+			Output.Write("[CodeDelegateInvokeExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateObjectCreateExpression(CodeObjectCreateExpression e)
+		{
+			Output.Write("[CodeObjectCreateExpression: Type={0}, Parameters=", e.CreateType.BaseType);
+			bool first = true;
+			foreach (CodeExpression expr in e.Parameters) {
+				if (first) first = false; else Output.Write(", ");
+				this.GenerateExpression(expr);
+			}
+			Output.Write("]");
+		}
+		
+		protected override void GeneratePropertyReferenceExpression(CodePropertyReferenceExpression e)
+		{
+			Output.Write("[CodePropertyReferenceExpression: Name={0}, Target=", e.PropertyName);
+			this.GenerateExpression(e.TargetObject);
+			Output.Write("]");
+		}
+		
+		protected override void GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e)
+		{
+			Output.Write("[CodePropertySetValueReferenceExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateThisReferenceExpression(CodeThisReferenceExpression e)
+		{
+			Output.Write("[CodeThisReferenceExpression]");
+		}
+		
+		protected override void GenerateExpressionStatement(CodeExpressionStatement e)
+		{
+			Output.Write("[CodeExpressionStatement:");
+			base.GenerateExpression(e.Expression);
+			Output.WriteLine("]");
+		}
+		
+		protected override void GenerateIterationStatement(CodeIterationStatement e)
+		{
+			Output.WriteLine("[CodeIterationStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e)
+		{
+			Output.WriteLine("[CodeThrowExceptionStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateComment(CodeComment e)
+		{
+			Output.WriteLine("[CodeComment: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateMethodReturnStatement(CodeMethodReturnStatement e)
+		{
+			Output.WriteLine("[CodeMethodReturnStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateConditionStatement(CodeConditionStatement e)
+		{
+			Output.WriteLine("[GenerateConditionStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e)
+		{
+			Output.WriteLine("[CodeTryCatchFinallyStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateAssignStatement(CodeAssignStatement e)
+		{
+			Output.Write("[CodeAssignStatement: Left=");
+			base.GenerateExpression(e.Left);
+			Output.Write(", Right=");
+			base.GenerateExpression(e.Right);
+			Output.WriteLine("]");
+		}
+		
+		protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
+		{
+			Output.WriteLine("[CodeAttachEventStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateRemoveEventStatement(CodeRemoveEventStatement e)
+		{
+			Output.WriteLine("[CodeRemoveEventStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateGotoStatement(CodeGotoStatement e)
+		{
+			Output.WriteLine("[CodeGotoStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateLabeledStatement(CodeLabeledStatement e)
+		{
+			Output.WriteLine("[CodeLabeledStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateVariableDeclarationStatement(CodeVariableDeclarationStatement e)
+		{
+			Output.WriteLine("[CodeVariableDeclarationStatement: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateLinePragmaStart(CodeLinePragma e)
+		{
+			Output.WriteLine("[CodeLinePragma: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateLinePragmaEnd(CodeLinePragma e)
+		{
+			Output.WriteLine("[CodeLinePragma: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateEvent(CodeMemberEvent e, CodeTypeDeclaration c)
+		{
+			Output.WriteLine("[CodeMemberEvent: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateField(CodeMemberField e)
+		{
+			Output.Write("[CodeMemberField: Name={0}, Type=", e.Name);
+			Output.Write(e.Type.BaseType);
+			Output.WriteLine("]");
+		}
+		
+		protected override void GenerateSnippetMember(CodeSnippetTypeMember e)
+		{
+			Output.WriteLine("[CodeSnippetTypeMember: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateEntryPointMethod(CodeEntryPointMethod e, CodeTypeDeclaration c)
+		{
+			Output.WriteLine("[CodeEntryPointMethod: {0}]", e.ToString());
+		}
+		
+		public void PublicGenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o)
+		{
+			((ICodeGenerator)this).GenerateCodeFromStatement(e, w, o);
+		}
+		
+		protected override void GenerateMethod(CodeMemberMethod e, CodeTypeDeclaration c)
+		{
+			Output.WriteLine("[CodeMemberMethod: Name={0}, Parameterns={1}]", e.Name, e.Parameters.Count);
+			++Indent;
+			GenerateStatements(e.Statements);
+			--Indent;
+		}
+		
+		protected override void GenerateProperty(CodeMemberProperty e, CodeTypeDeclaration c)
+		{
+			Output.WriteLine("[CodeMemberProperty : {0}]", e.ToString());
+		}
+		
+		protected override void GenerateConstructor(CodeConstructor e, CodeTypeDeclaration c)
+		{
+			Output.WriteLine("[CodeConstructor : {0}]", e.ToString());
+			++Indent;
+			GenerateStatements(e.Statements);
+			--Indent;
+		}
+		
+		protected override void GenerateTypeConstructor(CodeTypeConstructor e)
+		{
+			Output.WriteLine("[CodeTypeConstructor : {0}]", e.ToString());
+		}
+		
+		protected override void GenerateTypeStart(CodeTypeDeclaration e)
+		{
+			Output.WriteLine("[CodeTypeDeclaration : {0}]", e.ToString());
+		}
+		
+		protected override void GenerateTypeEnd(CodeTypeDeclaration e)
+		{
+			Output.WriteLine("[CodeTypeDeclaration: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateNamespaceStart(CodeNamespace e)
+		{
+			Output.WriteLine("[CodeNamespaceStart: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateNamespaceEnd(CodeNamespace e)
+		{
+			Output.WriteLine("[CodeNamespaceEnd: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateNamespaceImport(CodeNamespaceImport e)
+		{
+			Output.WriteLine("[CodeNamespaceImport: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateAttributeDeclarationsStart(CodeAttributeDeclarationCollection attributes)
+		{
+			Output.WriteLine("[CodeAttributeDeclarationCollection: {0}]", attributes.ToString());
+		}
+		
+		protected override void GenerateAttributeDeclarationsEnd(CodeAttributeDeclarationCollection attributes)
+		{
+			Output.WriteLine("[CodeAttributeDeclarationCollection: {0}]", attributes.ToString());
+		}
+		
+		protected override void GeneratePrimitiveExpression(CodePrimitiveExpression e)
+		{
+			if (e.Value == null) {
+				Output.WriteLine("[CodePrimitiveExpression: null]");
+			} else {
+				Output.Write("[CodePrimitiveExpression: ");
+				base.GeneratePrimitiveExpression(e);
+				Output.WriteLine(" (" + e.Value.GetType().Name + ")]");
+			}
+		}
+		
+		protected override bool Supports(GeneratorSupport support)
+		{
+			return true;
+		}
+		
+		protected override bool IsValidIdentifier(string value)
+		{
+			return true;
+		}
+		
+		protected override string CreateEscapedIdentifier(string value)
+		{
+			return value;
+		}
+		
+		protected override string CreateValidIdentifier(string value)
+		{
+			return value;
+		}
+		
+		protected override string GetTypeOutput(CodeTypeReference value)
+		{
+			return value.ToString();
+		}
+		
+		protected override string QuoteSnippetString(string value)
+		{
+			return "\"" + value + "\"";
+		}
+		
+		#endregion
+	}
+}

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

@@ -15,23 +15,9 @@ namespace ICSharpCode.FormsDesigner
 		
 		/// <summary>
 		/// Gets the source files involved when designing.
-		/// The first file in the resulting list is the main code file.
 		/// </summary>
-		IReadOnlyList<OpenedFile> GetSourceFiles(FormsDesignerViewContent viewContent);
+		/// <param name="viewContent"></param>
+		/// <param name="designerCodeFile">The file that contains the InitializeComponents() implementation</param>
+		IReadOnlyList<OpenedFile> GetSourceFiles(FormsDesignerViewContent viewContent, out OpenedFile designerCodeFile);
 	}
-	/*
-	public class NRefactoryDesignerLoaderProvider : IDesignerLoaderProvider
-	{
-		readonly SupportedLanguage language;
-		
-		public NRefactoryDesignerLoaderProvider(SupportedLanguage language)
-		{
-			this.language = language;
-		}
-		
-		public DesignerLoader CreateLoader(IDesignerGenerator generator)
-		{
-			return new NRefactoryDesignerLoader(language, generator);
-		}
-	}*/
 }

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/DesignerViewContent.cs

@@ -189,9 +189,9 @@ namespace ICSharpCode.FormsDesigner
 					this.sourceCodeStorage.LoadFile(file, stream);
 					
 					LoggingService.Debug("Forms designer: Determining designer source files for " + file.FileName);
-					IReadOnlyList<OpenedFile> sourceFiles = loaderProvider.GetSourceFiles(this);
+					OpenedFile newDesignerCodeFile;
-					OpenedFile newDesignerCodeFile = sourceFiles.FirstOrDefault();
+					IReadOnlyList<OpenedFile> sourceFiles = loaderProvider.GetSourceFiles(this, out newDesignerCodeFile);
-					if (newDesignerCodeFile == null) {
+					if (sourceFiles == null || newDesignerCodeFile == null) {
 						throw new FormsDesignerLoadException("The designer source files could not be determined.");
 					}
 					

src/AddIns/Misc/Reports/ICSharpCode.Reports.Addin/ICSharpCode.ReportDesigner.addin

@@ -211,6 +211,6 @@
 
 	<!-- Tell SharpDevelop to look for the file template (EmptyReport.xft) in the AddIn directory -->
 	<Path name = "/SharpDevelop/BackendBindings/Templates">
-		<Directory id = "ICSharpCode.Reports" path = "." />
+		<TemplateFile id = "ICSharpCode.Reports" path = "." />
 	</Path>
 </AddIn>

src/AddIns/Misc/Reports/ICSharpCode.Reports.Addin/Project/Services/TypeResolutionService.cs

@@ -4,15 +4,9 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Design;
-using System.Diagnostics;
-using System.IO;
 using System.Reflection;
 
 using ICSharpCode.Core;
-using ICSharpCode.SharpDevelop;
-using ICSharpCode.SharpDevelop.Dom;
-using ICSharpCode.SharpDevelop.Project;
-using Microsoft.Win32;
 
 namespace ICSharpCode.Reports.Addin
 {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs

@@ -144,7 +144,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return result.ToArray();
 		}
 		
-		CodeTypeReference Convert(IType type)
+		public CodeTypeReference Convert(IType type)
 		{
 			if (type.Kind == TypeKind.Array) {
 				ArrayType a = (ArrayType)type;

src/Libraries/NRefactory/ICSharpCode.NRefactory/TypeSystem/TypeSystemExtensions.cs

@@ -656,6 +656,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 							yield return attr;
 					}
 				}
+				yield break;
 			}
 			IMember member = entity as IMember;
 			if (member != null) {
@@ -671,6 +672,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 							yield return attr;
 					}
 				} while (member.IsOverride && (member = InheritanceHelper.GetBaseMember(member)) != null);
+				yield break;
 			}
 			throw new NotSupportedException("Unknown entity type");
 		}

src/Main/Base/Project/Designer/TypeResolutionService.cs

@@ -3,17 +3,14 @@
 
 using System;
 using System.Collections.Generic;
-using System.ComponentModel.Design;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
-using System.Windows.Documents;
 using ICSharpCode.Core;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Gui;
-using ICSharpCode.SharpDevelop.Gui.XmlForms;
 using ICSharpCode.SharpDevelop.Project;
 using Microsoft.Win32;