Improved C# -> Boo converter.

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

src/AddIns/BackendBindings/Boo/BooBinding.sln

@@ -1,5 +1,5 @@
 Microsoft Visual Studio Solution File, Format Version 9.00
-# SharpDevelop 2.0.0.676
+# SharpDevelop 2.0.0.851
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryToBooConverter", "NRefactoryToBooConverter\Project\NRefactoryToBooConverter.csproj", "{DBCF20A1-BA13-4582-BFA9-74DE4D987B73}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryToBooConverter.Tests", "NRefactoryToBooConverter\Test\NRefactoryToBooConverter.Tests.csproj", "{C9DE556D-325C-4544-B29F-16A9EB7C9830}"
@@ -24,6 +24,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WinFormsUI", "..\..\..\Libr
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FormDesigner", "..\..\DisplayBindings\FormDesigner\Project\FormDesigner.csproj", "{7D7E92DF-ACEB-4B69-92C8-8AC7A703CD57}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.framework.dll", "..\..\..\Libraries\NUnit.Framework\nunit.framework.dll.csproj", "{83DD7E12-A705-4DBA-9D71-09C8973D9382}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -78,5 +80,9 @@ Global
 		{7D7E92DF-ACEB-4B69-92C8-8AC7A703CD57}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{7D7E92DF-ACEB-4B69-92C8-8AC7A703CD57}.Release|Any CPU.Build.0 = Release|Any CPU
 		{7D7E92DF-ACEB-4B69-92C8-8AC7A703CD57}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{83DD7E12-A705-4DBA-9D71-09C8973D9382}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{83DD7E12-A705-4DBA-9D71-09C8973D9382}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{83DD7E12-A705-4DBA-9D71-09C8973D9382}.Release|Any CPU.Build.0 = Release|Any CPU
+		{83DD7E12-A705-4DBA-9D71-09C8973D9382}.Release|Any CPU.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 EndGlobal

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitor.cs

@@ -113,11 +113,6 @@ namespace NRefactoryToBooConverter
 			} else if (currentType != null && currentType.IsStatic) {
 				if (!(node is TypeDeclaration))
 					r |= B.TypeMemberModifiers.Static;
-			} else {
-				if ((m & (Modifier.Abstract | Modifier.Virtual | Modifier.Override)) == 0) {
-					if (node is MethodDeclaration || node is PropertyDeclaration)
-						r |= B.TypeMemberModifiers.Final;
-				}
 			}
 			if ((m & Modifier.Override) != 0)
 				r |= B.TypeMemberModifiers.Override;

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConverterSettings.cs

@@ -20,6 +20,7 @@ namespace NRefactoryToBooConverter
 		public const string DefaultNameGenerationPrefix = "converterGeneratedName";
 		public string NameGenerationPrefix = DefaultNameGenerationPrefix;
 		public bool SimplifyTypeNames = true;
+		public bool RemoveRedundantTypeReferences = true;
 		
 		static StringComparer GetComparer(string fileName)
 		{

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/NRefactoryToBooConverter.csproj

@@ -48,6 +48,7 @@
     <Compile Include="VariableResolver.cs" />
     <Compile Include="ConverterSettings.cs" />
     <Compile Include="BooPrinterVisitorWithComments.cs" />
+    <Compile Include="RemoveRedundantTypeReferencesVisitor.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\..\Libraries\NRefactory\Project\NRefactory.csproj">

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/Parser.cs

@@ -46,6 +46,9 @@ namespace NRefactoryToBooConverter
 			Module m = Converter.Convert(parser.CompilationUnit, settings);
 			if (m != null && cu != null) {
 				cu.Modules.Add(m);
+				if (settings.RemoveRedundantTypeReferences) {
+					cu.Accept(new RemoveRedundantTypeReferencesVisitor());
+				}
 			}
 			return m;
 		}

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/RemoveRedundantTypeReferencesVisitor.cs

@@ -0,0 +1,132 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt">2002-2005 AlphaSierraPapa</copyright>
+//     <license see="prj:///doc/license.txt">GNU General Public License</license>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using Boo.Lang.Compiler;
+using Boo.Lang.Compiler.Ast;
+using Boo.Lang.Compiler.Ast.Visitors;
+
+namespace NRefactoryToBooConverter
+{
+	/// <summary>
+	/// Prettifies the Boo code by removing type declarations that aren't required in Boo.
+	/// </summary>
+	public class RemoveRedundantTypeReferencesVisitor : DepthFirstTransformer
+	{
+		bool IsVoid(TypeReference typeRef)
+		{
+			SimpleTypeReference str = typeRef as SimpleTypeReference;
+			return str != null && (str.Name == "void" || str.Name == "System.Void");
+		}
+		
+		public override void OnMethod(Method node)
+		{
+			base.OnMethod(node);
+			if (IsVoid(node.ReturnType))
+				node.ReturnType = null;
+		}
+		
+		Stack<List<Field>> fieldStack = new Stack<List<Field>>();
+		
+		void EnterTypeDefinition(TypeDefinition node)
+		{
+			List<Field> list = new List<Field>();
+			fieldStack.Push(list);
+			foreach (TypeMember member in node.Members) {
+				if (member is Field)
+					list.Add((Field)member);
+			}
+		}
+		
+		bool SearchField(string name)
+		{
+			foreach (List<Field> list in fieldStack) {
+				foreach (Field field in list) {
+					if (field.Name == name)
+						return true;
+				}
+			}
+			return false;
+		}
+		
+		public override void OnClassDefinition(ClassDefinition node)
+		{
+			EnterTypeDefinition(node);
+			base.OnClassDefinition(node);
+			fieldStack.Pop();
+		}
+		
+		public override void OnStructDefinition(StructDefinition node)
+		{
+			EnterTypeDefinition(node);
+			base.OnStructDefinition(node);
+			fieldStack.Pop();
+		}
+		
+		public override void OnModule(Module node)
+		{
+			EnterTypeDefinition(node);
+			base.OnModule(node);
+			fieldStack.Pop();
+		}
+		
+		public override void OnField(Field node)
+		{
+			if (node.Type != null) {
+				TypeReference initializerType = GetInferredType(node.Initializer);
+				if (node.Type.Matches(initializerType)) {
+					node.Type = null;
+				}
+			}
+			base.OnField(node);
+		}
+		
+		public override void OnDeclarationStatement(DeclarationStatement node)
+		{
+			if (node.Declaration.Type != null && !SearchField(node.Declaration.Name)) {
+				TypeReference initializerType = GetInferredType(node.Initializer);
+				if (node.Declaration.Type.Matches(initializerType)) {
+					node.Declaration.Type = null;
+				}
+			}
+			base.OnDeclarationStatement(node);
+		}
+		
+		TypeReference GetInferredType(Expression expr)
+		{
+			switch (expr.NodeType) {
+				case NodeType.TypeofExpression:
+					return new SimpleTypeReference("type");
+				case NodeType.BoolLiteralExpression:
+					return new SimpleTypeReference("bool");
+				case NodeType.IntegerLiteralExpression:
+					if (((IntegerLiteralExpression)expr).IsLong)
+						break;
+					return new SimpleTypeReference("int");
+				case NodeType.StringLiteralExpression:
+					return new SimpleTypeReference("string");
+				case NodeType.CharLiteralExpression:
+					return new SimpleTypeReference("char");
+				case NodeType.DoubleLiteralExpression:
+					if (((DoubleLiteralExpression)expr).IsSingle)
+						break;
+					return new SimpleTypeReference("double");
+				case NodeType.CastExpression:
+					return ((CastExpression)expr).Type;
+				case NodeType.TryCastExpression:
+					return ((TryCastExpression)expr).Type;
+				case NodeType.MethodInvocationExpression:
+					MethodInvocationExpression mie = (MethodInvocationExpression)expr;
+					if (mie.Target.NodeType == NodeType.ReferenceExpression)
+						return new SimpleTypeReference(((ReferenceExpression)mie.Target).Name);
+					break;
+			}
+			return null;
+		}
+	}
+}

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/ComplexTests.cs

@@ -17,7 +17,7 @@ namespace NRefactoryToBooConverter.Tests
 		public void MovingLocals()
 		{
 			TestInClass("public void Run() { if (a) { int b = 1; } else { int b = 2; } }",
-			            "public final def Run() as System.Void:\n" +
+			            "public def Run() as System.Void:\n" +
 			            "\tb as System.Int32\n" +
 			            "\tif a:\n" +
 			            "\t\tb = 1\n" +
@@ -29,7 +29,7 @@ namespace NRefactoryToBooConverter.Tests
 		public void RenamingLocals()
 		{
 			TestInClass("public void Run() { if (a) { int b = 1; } else { double b = 2; } }",
-			            "public final def Run() as System.Void:\n" +
+			            "public def Run() as System.Void:\n" +
 			            "\tif a:\n" +
 			            "\t\tb as System.Int32 = 1\n" +
 			            "\telse:\n" +

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/MemberTests.cs

@@ -89,37 +89,37 @@ namespace NRefactoryToBooConverter.Tests
 		[Test]
 		public void Method()
 		{
-			TestInClass("void Main() {}", "private final def Main() as System.Void:\n\tpass");
+			TestInClass("void Main() {}", "private def Main() as System.Void:\n\tpass");
 		}
 		
 		[Test]
 		public void MethodWithAttribute()
 		{
-			TestInClass("[Test] void Main() {}", "[Test]\nprivate final def Main() as System.Void:\n\tpass");
+			TestInClass("[Test] void Main() {}", "[Test]\nprivate def Main() as System.Void:\n\tpass");
 		}
 		
 		[Test]
 		public void MethodWithParameters()
 		{
-			TestInClass("void Main(int a, MyType b) {}", "private final def Main(a as System.Int32, b as MyType) as System.Void:\n\tpass");
+			TestInClass("void Main(int a, MyType b) {}", "private def Main(a as System.Int32, b as MyType) as System.Void:\n\tpass");
 		}
 		
 		[Test]
 		public void MethodWithRefParameters()
 		{
-			TestInClass("void Main(ref int a, out MyType b) {}", "private final def Main(ref a as System.Int32, ref b as MyType) as System.Void:\n\tpass");
+			TestInClass("void Main(ref int a, out MyType b) {}", "private def Main(ref a as System.Int32, ref b as MyType) as System.Void:\n\tpass");
 		}
 		
 		[Test]
 		public void MethodWithParamsParameters()
 		{
-			TestInClass("void Main(int a, params string[] args) {}", "private final def Main(a as System.Int32, *args as (System.String)) as System.Void:\n\tpass");
+			TestInClass("void Main(int a, params string[] args) {}", "private def Main(a as System.Int32, *args as (System.String)) as System.Void:\n\tpass");
 		}
 		
 		[Test]
 		public void MethodWithReturnType()
 		{
-			TestInClass("MyType Main() {}", "private final def Main() as MyType:\n\tpass");
+			TestInClass("MyType Main() {}", "private def Main() as MyType:\n\tpass");
 		}
 		
 		[Test]

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/NRefactoryToBooConverter.Tests.csproj

@@ -48,6 +48,7 @@
     <Compile Include="ExpressionTests.cs" />
     <Compile Include="StatementTests.cs" />
     <Compile Include="ComplexTests.cs" />
+    <Compile Include="RemoveRedundantTypeReferencesTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Project\NRefactoryToBooConverter.csproj">

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/RemoveRedundantTypeReferencesTest.cs

@@ -0,0 +1,61 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt">2002-2005 AlphaSierraPapa</copyright>
+//     <license see="prj:///doc/license.txt">GNU General Public License</license>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using NUnit.Framework;
+
+namespace NRefactoryToBooConverter.Tests
+{
+	[TestFixture]
+	public class RemoveRedundantTypeReferencesTest : TestHelper
+	{
+		protected override void ApplySettings(ConverterSettings settings)
+		{
+			base.ApplySettings(settings);
+			settings.SimplifyTypeNames = true;
+			settings.RemoveRedundantTypeReferences = true;
+		}
+		
+		[Test]
+		public void VoidMethod()
+		{
+			TestInClass("private void Main() {}", "private def Main():\n\tpass");
+		}
+		
+		[Test]
+		public void ConstructorCall()
+		{
+			TestStatement("MyClass m = new MyClass(4);", "m = MyClass(4)");
+		}
+		
+		[Test]
+		public void Cast()
+		{
+			TestStatement("MyClass m = (MyClass)variable;", "m = cast(MyClass, variable)");
+			TestStatement("MyClass m = variable as MyClass;", "m = (variable as MyClass)");
+		}
+		
+		[Test]
+		public void PrimitiveAssignment()
+		{
+			TestStatement("string text = \"Text!\";", "text = 'Text!'");
+			TestStatement("int a = 5;", "a = 5");
+		}
+		
+		[Test]
+		public void FieldAndLocalVariable()
+		{
+			TestInClass("private int var = 3;\n" +
+			            "private void Main() {\n" +
+			            "  int var = 5;\n" +
+			            "}",
+			            "private var = 3\n" +
+			            "private def Main():\n" +
+			            "\tvar as int = 5");
+		}
+	}
+}

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/TestHelper.cs

@@ -15,10 +15,16 @@ namespace NRefactoryToBooConverter.Tests
 {
 	public class TestHelper
 	{
+		protected virtual void ApplySettings(ConverterSettings settings)
+		{
+			settings.SimplifyTypeNames = false;
+			settings.RemoveRedundantTypeReferences = false;
+		}
+		
 		protected string Convert(string program)
 		{
 			ConverterSettings settings = new ConverterSettings("prog.cs");
-			settings.SimplifyTypeNames = false;
+			ApplySettings(settings);
 			Module module = Parser.ParseModule(new CompileUnit(), new StringReader(program), settings);
 			return GetStringFromModule(module, settings);
 		}
@@ -26,7 +32,7 @@ namespace NRefactoryToBooConverter.Tests
 		protected string ConvertVB(string program)
 		{
 			ConverterSettings settings = new ConverterSettings("prog.vb");
-			settings.SimplifyTypeNames = false;
+			ApplySettings(settings);
 			Module module = Parser.ParseModule(new CompileUnit(), new StringReader(program), settings);
 			return GetStringFromModule(module, settings);
 		}
@@ -76,12 +82,20 @@ namespace NRefactoryToBooConverter.Tests
 		
 		protected void TestStatement(string input, string output)
 		{
-			TestInClass("public void Method() {\n" + input + "\n}", "public final def Method() as System.Void:\n\t" + output.Replace("\n", "\n\t"));
+			ConverterSettings dummySet = new ConverterSettings("dummy.cs");
+			ApplySettings(dummySet);
+			if (dummySet.RemoveRedundantTypeReferences) {
+				TestInClass("public void Method() {\n" + input + "\n}", "public def Method():\n\t" + output.Replace("\n", "\n\t"));
+			} else if (dummySet.SimplifyTypeNames) {
+				TestInClass("public void Method() {\n" + input + "\n}", "public def Method() as void:\n\t" + output.Replace("\n", "\n\t"));
+			} else {
+				TestInClass("public void Method() {\n" + input + "\n}", "public def Method() as System.Void:\n\t" + output.Replace("\n", "\n\t"));
+			}
 		}
 		
 		protected void TestStatementVB(string input, string output)
 		{
-			TestInClassVB("Public Sub Method()\n" + input + "\nEnd Sub", "public final def Method() as System.Void:\n\t" + output.Replace("\n", "\n\t"));
+			TestInClassVB("Public Sub Method()\n" + input + "\nEnd Sub", "public def Method() as System.Void:\n\t" + output.Replace("\n", "\n\t"));
 		}
 		
 		protected void TestExpr(string input, string output)

src/AddIns/BackendBindings/Boo/StandaloneConverter/Main.cs

@@ -60,6 +60,9 @@ namespace StandaloneConverter
 						case "--version":
 							Console.WriteLine("Version " + typeof(MainClass).Assembly.GetName().Version.ToString());
 							return 0;
+						case "--keepredundanttypereferences":
+							removeRedundantTypeReferences = false;
+							break;
 						case "--noprimitivenames":
 							simplifyTypeNames = false;
 							break;
@@ -112,6 +115,8 @@ namespace StandaloneConverter
 			Console.WriteLine("Switches:");
 			Console.WriteLine(" --overwrite or --force (short: -f)");
 			Console.WriteLine("    Overwrite existing .boo files.");
+			Console.WriteLine(" --keepredundanttypereferences");
+			Console.WriteLine("    Don't remove type declarations like 'as void' or in local variable declarations where the type is clearly inferred.");
 			Console.WriteLine(" --noPrimitiveNames");
 			Console.WriteLine("    Use the fully type names (System.Int32) instead of the short names (int).");
 			Console.WriteLine(" --help (short: -? or /?)");
@@ -119,11 +124,13 @@ namespace StandaloneConverter
 		}
 		
 		bool simplifyTypeNames = true;
+		bool removeRedundantTypeReferences = true;
 		
 		ConverterSettings ApplySettings(string fileName, CompilerErrorCollection errors, CompilerWarningCollection warnings)
 		{
 			ConverterSettings settings = new ConverterSettings(fileName, errors, warnings);
 			settings.SimplifyTypeNames = simplifyTypeNames;
+			settings.RemoveRedundantTypeReferences = removeRedundantTypeReferences;
 			return settings;
 		}
 		

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

@@ -118,7 +118,11 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			MethodDeclaration method = node as MethodDeclaration;
 			if (method != null) {
 				method.Body.Children.Clear();
-				method.Body.AddChild(new ReturnStatement(CreateMethodCall(method)));
+				if (method.TypeReference.SystemType == "System.Void") {
+					method.Body.AddChild(new StatementExpression(CreateMethodCall(method)));
+				} else {
+					method.Body.AddChild(new ReturnStatement(CreateMethodCall(method)));
+				}
 			}
 			PropertyDeclaration property = node as PropertyDeclaration;
 			if (property != null) {