worked on codedom ast codegenerator. codedom code generation is now more in line with the .net codedom formsdesigner output.

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

src/AddIns/DisplayBindings/FormDesigner/Project/Src/FormDesigner/DesignerGenerator/CodeDOMGenerator.cs

@@ -66,11 +66,16 @@ namespace ICSharpCode.FormDesigner
 			CodeGeneratorOptions options = codeDOMGeneratorUtility.CreateCodeGeneratorOptions;
 			options.IndentString = "\t\t\t";
 			
+			ICSharpCode.NRefactory.Parser.CodeDOMVerboseOutputGenerator outputGenerator = new ICSharpCode.NRefactory.Parser.CodeDOMVerboseOutputGenerator();
+			
+			Console.WriteLine("<<<<START.");
 			foreach (CodeStatement statement in statements) {
 				if (!(statement is CodeVariableDeclarationStatement)) {
 					// indentation isn't generated when calling GenerateCodeFromStatement
 					writer.Write(options.IndentString);
 					try {
+						outputGenerator.PublicGenerateCodeFromStatement(statement, Console.Out, options);
+						
 						codeProvider.GenerateCodeFromStatement(statement, writer, options);
 					} catch (Exception e) {
 						codeProvider.GenerateCodeFromStatement(new CodeCommentStatement("TODO: Error while generating statement : " + e.Message),
@@ -81,6 +86,7 @@ namespace ICSharpCode.FormDesigner
 			}
 			designerResourceService.SerializationEnded(true);
 			session.Dispose();
+			Console.WriteLine("<<<<END.");
 		}
 	}
 }

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

@@ -38,7 +38,7 @@ namespace ICSharpCode.FormDesigner
 		}
 	}
 	
-	public class NRefactoryDesignerLoader : CodeDomDesignerLoader
+	public class NRefactoryDesignerLoader : CodeDomDesignerLoader, ICodeDomDesignerReload
 	{
 		bool                  loading               = false;
 		IDesignerLoaderHost   designerLoaderHost    = null;
@@ -77,6 +77,7 @@ namespace ICSharpCode.FormDesigner
 		
 		protected override ITypeResolutionService TypeResolutionService {
 			get {
+				Console.WriteLine("type resolution service");
 				return typeResolutionService;
 			}
 		}
@@ -92,8 +93,17 @@ namespace ICSharpCode.FormDesigner
 			this.textEditorControl = textEditorControl;
 		}
 		
+		#region System.ComponentModel.Design.Serialization.ICodeDomDesignerReload interface implementation
+		public bool ShouldReloadDesigner(CodeCompileUnit newTree) 
+		{
+			Console.Write("AskReload");
+			return  IsReloadNeeded();
+		}
+		#endregion
+		
 		protected override CodeCompileUnit Parse()
 		{
+			Console.Write("ParseCompileUnit");
 			isReloadNeeded = false;
 			ICSharpCode.NRefactory.Parser.IParser p = ICSharpCode.NRefactory.Parser.ParserFactory.CreateParser(language, new StringReader(TextContent));
 			p.Parse();
@@ -101,7 +111,9 @@ namespace ICSharpCode.FormDesigner
 			CodeDOMVisitor visitor = new CodeDOMVisitor();
 			visitor.Visit(p.CompilationUnit, null);
 			
-//			// output generated CodeDOM to the console :
+			// output generated CodeDOM to the console :
+			CodeDOMVerboseOutputGenerator outputGenerator = new CodeDOMVerboseOutputGenerator();
+			outputGenerator.GenerateCodeFromMember(visitor.codeCompileUnit.Namespaces[0].Types[0], Console.Out, null);
 //			provider.GenerateCodeFromCompileUnit(visitor.codeCompileUnit, Console.Out, null);
 			
 			return visitor.codeCompileUnit;

src/AddIns/DisplayBindings/FormDesigner/Project/Src/FormDesigner/DesignerLoader/XmlDesignerLoader.cs

@@ -45,6 +45,7 @@ namespace ICSharpCode.FormDesigner
 				return textEditorControl.Document.TextContent;
 			}
 		}
+		
 		public XmlDesignerLoader(TextEditorControl textEditorControl)
 		{
 			this.textEditorControl = textEditorControl;

src/AddIns/DisplayBindings/FormDesigner/Project/Src/FormDesigner/FormDesignerViewContent.cs

@@ -16,6 +16,7 @@ using System.Drawing;
 using System.Drawing.Design;
 using System.Reflection;
 using System.Windows.Forms;
+using System.Windows.Forms.Design;
 using System.Drawing.Printing;
 using System.ComponentModel;
 using System.ComponentModel.Design;
@@ -151,8 +152,10 @@ namespace ICSharpCode.FormDesigner
 			designSurface = new DesignSurface(serviceContainer);
 			eventBindingService.ServiceProvider = designSurface;
 			designerResourceService.Host = Host;
+			serviceContainer.AddService(typeof(IDesignerHost), Host);
 			
 			designSurface.BeginLoad(loader);
+			loader.Flush();
 			
 			designSurface.Flush();
 			
@@ -175,7 +178,7 @@ namespace ICSharpCode.FormDesigner
 		{
 			Initialize();
 			bool dirty = viewContent.IsDirty;
-//	TODO:		
+//	TODO:
 //			loader.TextContent = Document.TextContent;
 			
 			try {

src/AddIns/DisplayBindings/FormDesigner/Project/Src/FormDesigner/Services/DefaultServiceContainer.cs

@@ -102,7 +102,7 @@ namespace ICSharpCode.FormDesigner.Services
 //				Console.WriteLine("request missing service : {0} from Assembly {1} is not aviable.", serviceType, serviceType.Assembly.FullName);
 ////				Console.ReadLine();
 //			} else {
-//				Console.WriteLine("get service : {0} from Assembly {1}.", serviceType, serviceType.Assembly.FullName);
+////				Console.WriteLine("get service : {0} from Assembly {1}.", serviceType, serviceType.Assembly.FullName);
 //			}
 			return serviceContainer.GetService(serviceType);
 		}

src/Libraries/NRefactory/Project/NRefactory.csproj

@@ -188,6 +188,7 @@
     <Compile Include="Src\Parser\Visitors\PrefixFieldsVisitor.cs" />
     <Compile Include="Src\Parser\Visitors\VBNetToCSharpConvertVisitor.cs" />
     <Compile Include="Src\Parser\AST\General\TypeLevel\OperatorDeclaration.cs" />
+    <Compile Include="Src\Output\CodeDOM\CodeDOMVerboseOutputGenerator.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="Src\Lexer\CSharp\KeywordList.txt" />

src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs

@@ -654,8 +654,7 @@ namespace ICSharpCode.NRefactory.Parser
 		public override object Visit(IdentifierExpression expression, object data)
 		{
 			if (IsField(expression.Identifier)) {
-				return new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
-				                                        expression.Identifier);
+				return new CodeVariableReferenceExpression(expression.Identifier);
 			}
 			return new CodeVariableReferenceExpression(expression.Identifier);
 		}

src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMVerboseOutputGenerator.cs

@@ -0,0 +1,320 @@
+using System;
+using System.IO;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+
+namespace ICSharpCode.NRefactory.Parser
+{
+	/// <summary>
+	/// Description of CodeDOMVerboseOutputGenerator.
+	/// </summary>
+	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.ToString());
+		}
+		
+		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 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: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateMethodReferenceExpression(CodeMethodReferenceExpression e) 
+		{
+			Output.Write("[CodeMethodReferenceExpression: {0}]", e.ToString());
+		}
+		
+		protected override void GenerateEventReferenceExpression(CodeEventReferenceExpression e) 
+		{
+			Output.Write("[CodeEventReferenceExpression: {0}]", e.ToString());
+		}
+		
+		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);
+			foreach (CodeExpression expr in e.Parameters) {
+				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.WriteLine("[CodeExpressionStatement: {0}]", e.ToString());
+			
+		}
+		
+		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());
+		}
+		
+		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 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/Main/Base/Project/Src/Project/MSBuildEngine.cs

@@ -82,8 +82,9 @@ namespace ICSharpCode.SharpDevelop.Project
 			
 			public void FlushText()
 			{
-				if (engine.MessageView != null)
+				if (engine.MessageView != null) {
 					engine.MessageView.AppendText(textToWrite.ToString());
+				}
 				textToWrite.Length = 0;
 			}
 			

src/Main/Base/Project/Src/Project/MSBuildProject.cs

@@ -295,14 +295,15 @@ namespace ICSharpCode.SharpDevelop.Project
 		
 		public static CompilerResults RunMSBuild(string fileName, string target)
 		{
+			Console.WriteLine("Run : " + fileName);
 			WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
 //			BeforeBuild();
 			MSBuildEngine engine = new MSBuildEngine();
 			engine.MessageView = TaskService.BuildMessageViewCategory;
-			if (target == null)
+			if (target == null) {
 				return engine.Run(fileName);
-			else
-				return engine.Run(fileName, new string[] { target });
+			}
+			return engine.Run(fileName, new string[] { target });
 //			AfterBuild();
 		}