implement proper conversion of FieldDeclaration

ICSharpCode.NRefactory.VB/Ast/AstNode.cs

@@ -702,6 +702,7 @@ namespace ICSharpCode.NRefactory.VB
 			public static readonly Role<VBTokenNode> LChevron = new Role<VBTokenNode>("LChevron", VBTokenNode.Null);
 			public static readonly Role<VBTokenNode> RChevron = new Role<VBTokenNode>("RChevron", VBTokenNode.Null);
 			public static readonly Role<VBTokenNode> Comma = new Role<VBTokenNode>("Comma", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> QuestionMark = new Role<VBTokenNode>("QuestionMark", VBTokenNode.Null);
 			public static readonly Role<VBTokenNode> Dot = new Role<VBTokenNode>("Dot", VBTokenNode.Null);
 			public static readonly Role<VBTokenNode> Semicolon = new Role<VBTokenNode>("Semicolon", VBTokenNode.Null);
 			public static readonly Role<VBTokenNode> Assign = new Role<VBTokenNode>("Assign", VBTokenNode.Null);

ICSharpCode.NRefactory.VB/Ast/Enums.cs

@@ -67,13 +67,6 @@ namespace ICSharpCode.NRefactory.VB.Ast
 		Ref
 	}
 	
-	public enum VarianceModifier
-	{
-		Invariant,
-		Covariant,
-		Contravariant
-	};
-	
 	public enum AssignmentOperatorType
 	{
 		None,

ICSharpCode.NRefactory.VB/Ast/Expressions/ObjectCreationExpression.cs

@@ -0,0 +1,20 @@
+// 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;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class ObjectCreationExpression : Expression
+	{
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}

ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs

@@ -17,7 +17,7 @@ namespace ICSharpCode.NRefactory.VB.Ast
 			set { SetChildByRole(Roles.Expression, value); }
 		}
 		
-		public AstType ReturnType {
+		public AstType Type {
 			get { return GetChildByRole(Roles.Type); }
 			set { SetChildByRole(Roles.Type, value); }
 		}
@@ -29,7 +29,7 @@ namespace ICSharpCode.NRefactory.VB.Ast
 				MatchAttributesAndModifiers(param, match) &&
 				Name.DoMatch(param.Name, match) &&
 				OptionalValue.DoMatch(param.OptionalValue, match) &&
-				ReturnType.DoMatch(param.ReturnType, match);
+				Type.DoMatch(param.Type, match);
 		}
 		
 		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)

ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs

@@ -5,6 +5,8 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
+using ICSharpCode.NRefactory.TypeSystem;
+
 namespace ICSharpCode.NRefactory.VB.Ast
 {
 	/// <summary>

ICSharpCode.NRefactory.VB/Ast/TypeMembers/ConstructorDeclaration.cs

@@ -5,10 +5,15 @@ using System;
 
 namespace ICSharpCode.NRefactory.VB.Ast
 {
+	public abstract class MemberDeclaration : AttributedNode
+	{
+		
+	}
+	
 	/// <summary>
 	/// Description of ConstructorDeclaration.
 	/// </summary>
-	public class ConstructorDeclaration : AttributedNode
+	public class ConstructorDeclaration : MemberDeclaration
 	{
 		public ConstructorDeclaration()
 		{

ICSharpCode.NRefactory.VB/Ast/TypeMembers/MethodDeclaration.cs

@@ -5,7 +5,7 @@ using System;
 
 namespace ICSharpCode.NRefactory.VB.Ast
 {
-	public class MethodDeclaration : AttributedNode
+	public class MethodDeclaration : MemberDeclaration
 	{
 		public MethodDeclaration()
 		{
@@ -69,4 +69,86 @@ namespace ICSharpCode.NRefactory.VB.Ast
 			return visitor.VisitMethodDeclaration(this, data);
 		}
 	}
+	
+	/// <remarks>
+	/// Attributes? VariableModifier+ VariableDeclarators StatementTerminator
+	/// </remarks>
+	public class FieldDeclaration : MemberDeclaration
+	{
+		public AstNodeCollection<VariableDeclarator> Variables {
+			get { return GetChildrenByRole(VariableDeclarator.VariableDeclaratorRole); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitFieldDeclaration(this, data);
+		}
+	}
+	
+	/// <remarks>
+	/// VariableIdentifiers As ObjectCreationExpression <br />
+    /// VariableIdentifiers ( As TypeName )? ( Equals Expression )?
+	/// </remarks>
+	public class VariableDeclarator : AstNode
+	{
+		public static readonly Role<VariableDeclarator> VariableDeclaratorRole = new Role<VariableDeclarator>("VariableDeclarator");
+		
+		public AstNodeCollection<VariableIdentifier> Identifiers {
+			get { return GetChildrenByRole(VariableIdentifier.VariableIdentifierRole); }
+		}
+		
+		public AstType Type {
+			get { return GetChildByRole(Roles.Type); }
+			set { SetChildByRole(Roles.Type, value); }
+		}
+		
+		public Expression Initializer {
+			get { return GetChildByRole(Roles.Expression); }
+			set { SetChildByRole(Roles.Expression, value); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitVariableDeclarator(this, data);
+		}
+	}
+	
+	/// <remarks>
+	/// Identifier IdentifierModifiers
+	/// </remarks>
+	public class VariableIdentifier : AstNode
+	{
+		public static readonly Role<VariableIdentifier> VariableIdentifierRole = new Role<VariableIdentifier>("VariableIdentifier");
+		
+		public Identifier Name {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public bool HasNullableSpecifier { get; set; }
+		
+		public AstNodeCollection<ArraySpecifier> ArraySpecifiers {
+			get { return GetChildrenByRole(ComposedType.ArraySpecifierRole); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitVariableIdentifier(this, data);
+		}
+	}
 }

ICSharpCode.NRefactory.VB/IAstVisitor.cs

@@ -34,6 +34,9 @@ namespace ICSharpCode.NRefactory.VB {
 		// TypeMember scope
 		S VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, T data);
 		S VisitMethodDeclaration(MethodDeclaration methodDeclaration, T data);
+		S VisitFieldDeclaration(FieldDeclaration fieldDeclaration, T data);
+		S VisitVariableDeclarator(VariableDeclarator variableDeclarator, T data);
+		S VisitVariableIdentifier(VariableIdentifier variableIdentifier, T data);
 		
 		// Expression scope
 		S VisitIdentifier(Identifier identifier, T data);

ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj

@@ -53,6 +53,7 @@
     <Compile Include="Ast\Expressions\GetXmlNamespaceExpression.cs" />
     <Compile Include="Ast\Expressions\InstanceExpression.cs" />
     <Compile Include="Ast\Expressions\MemberAccessExpression.cs" />
+    <Compile Include="Ast\Expressions\ObjectCreationExpression.cs" />
     <Compile Include="Ast\Expressions\ParenthesizedExpression.cs" />
     <Compile Include="Ast\Expressions\SimpleNameExpression.cs" />
     <Compile Include="Ast\Expressions\PrimitiveExpression.cs" />

ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs

@@ -82,7 +82,18 @@ namespace ICSharpCode.NRefactory.VB
 		
 		public object VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, object data)
 		{
-			throw new NotImplementedException();
+			StartNode(parameterDeclaration);
+			WriteModifiers(parameterDeclaration.ModifierTokens);
+			WriteIdentifier(parameterDeclaration.Name.Name);
+			if (!parameterDeclaration.Type.IsNull) {
+				WriteKeyword("As");
+				parameterDeclaration.Type.AcceptVisitor(this, data);
+			}
+			if (!parameterDeclaration.OptionalValue.IsNull) {
+				WriteToken("=", ParameterDeclaration.Roles.Assign);
+				parameterDeclaration.OptionalValue.AcceptVisitor(this, data);
+			}
+			return EndNode(parameterDeclaration);
 		}
 		
 		public object VisitVBTokenNode(VBTokenNode vBTokenNode, object data)
@@ -430,7 +441,11 @@ namespace ICSharpCode.NRefactory.VB
 		#region TypeName
 		public object VisitPrimitiveType(PrimitiveType primitiveType, object data)
 		{
-			throw new NotImplementedException();
+			StartNode(primitiveType);
+			
+			WriteKeyword(primitiveType.Keyword);
+			
+			return EndNode(primitiveType);
 		}
 		
 		public object VisitQualifiedType(QualifiedType qualifiedType, object data)
@@ -452,7 +467,15 @@ namespace ICSharpCode.NRefactory.VB
 		
 		public object VisitArraySpecifier(ArraySpecifier arraySpecifier, object data)
 		{
-			throw new NotImplementedException();
+			StartNode(arraySpecifier);
+			
+			LPar();
+			for (int i = 0; i < arraySpecifier.Dimensions; i++) {
+				WriteToken(",", ArraySpecifier.Roles.Comma);
+			}
+			RPar();
+			
+			return EndNode(arraySpecifier);
 		}
 		
 		public object VisitSimpleType(SimpleType simpleType, object data)
@@ -687,11 +710,14 @@ namespace ICSharpCode.NRefactory.VB
 			if (IsKeyword(identifier, containerStack.Peek())) {
 				if (lastWritten == LastWritten.KeywordOrIdentifier)
 					Space(); // this space is not strictly required, so we call Space()
-				formatter.WriteToken("@");
+				formatter.WriteToken("[");
 			} else if (lastWritten == LastWritten.KeywordOrIdentifier) {
 				formatter.Space(); // this space is strictly required, so we directly call the formatter
 			}
 			formatter.WriteIdentifier(identifier);
+			if (IsKeyword(identifier, containerStack.Peek())) {
+				formatter.WriteToken("]");
+			}
 			lastWritten = LastWritten.KeywordOrIdentifier;
 		}
 		
@@ -887,6 +913,13 @@ namespace ICSharpCode.NRefactory.VB
 			}
 		}
 		
+		void WriteArraySpecifiers(IEnumerable<ArraySpecifier> arraySpecifiers)
+		{
+			foreach (ArraySpecifier specifier in arraySpecifiers) {
+				specifier.AcceptVisitor(this, null);
+			}
+		}
+		
 		void WriteQualifiedIdentifier(IEnumerable<Identifier> identifiers)
 		{
 			bool first = true;
@@ -1074,5 +1107,48 @@ namespace ICSharpCode.NRefactory.VB
 			return sb.ToString();
 		}
 		#endregion
+		
+		public object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
+		{
+			StartNode(fieldDeclaration);
+			
+			WriteAttributes(fieldDeclaration.Attributes);
+			WriteModifiers(fieldDeclaration.ModifierTokens);
+			WriteCommaSeparatedList(fieldDeclaration.Variables);
+			NewLine();
+			
+			return EndNode(fieldDeclaration);
+		}
+		
+		public object VisitVariableDeclarator(VariableDeclarator variableDeclarator, object data)
+		{
+			StartNode(variableDeclarator);
+			
+			WriteCommaSeparatedList(variableDeclarator.Identifiers);
+			WriteKeyword("As");
+			if (variableDeclarator.Initializer is ObjectCreationExpression)
+				variableDeclarator.Initializer.AcceptVisitor(this, data);
+			else {
+				variableDeclarator.Type.AcceptVisitor(this, data);
+				if (!variableDeclarator.Initializer.IsNull) {
+					WriteToken("=", VariableDeclarator.Roles.Assign);
+					variableDeclarator.Initializer.AcceptVisitor(this, data);
+				}
+			}
+			
+			return EndNode(variableDeclarator);
+		}
+		
+		public object VisitVariableIdentifier(VariableIdentifier variableIdentifier, object data)
+		{
+			StartNode(variableIdentifier);
+			
+			WriteIdentifier(variableIdentifier.Name.Name);
+			if (variableIdentifier.HasNullableSpecifier)
+				WriteToken("?", VariableIdentifier.Roles.QuestionMark);
+			WriteArraySpecifiers(variableIdentifier.ArraySpecifiers);
+			
+			return EndNode(variableIdentifier);
+		}
 	}
 }

ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs

@@ -552,7 +552,13 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitFieldDeclaration(CSharp.FieldDeclaration fieldDeclaration, object data)
 		{
-			throw new NotImplementedException();
+			var decl = new FieldDeclaration();
+			
+			ConvertNodes(fieldDeclaration.Attributes, decl.Attributes);
+			decl.Modifiers = ConvertModifiers(fieldDeclaration.Modifiers, fieldDeclaration);
+			ConvertNodes(fieldDeclaration.Variables, decl.Variables);
+			
+			return EndNode(fieldDeclaration, decl);
 		}
 		
 		public AstNode VisitIndexerDeclaration(CSharp.IndexerDeclaration indexerDeclaration, object data)
@@ -593,17 +599,53 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitParameterDeclaration(CSharp.ParameterDeclaration parameterDeclaration, object data)
 		{
-			throw new NotImplementedException();
+			var param = new ParameterDeclaration();
+			
+			ConvertNodes(parameterDeclaration.Attributes, param.Attributes);
+			param.Modifiers = ConvertParamModifiers(parameterDeclaration.ParameterModifier);
+			param.Name = new Identifier(parameterDeclaration.Name, AstLocation.Empty);
+			param.Type = (AstType)parameterDeclaration.Type.AcceptVisitor(this, data);
+			param.OptionalValue = (Expression)parameterDeclaration.DefaultExpression.AcceptVisitor(this, data);
+			if (!param.OptionalValue.IsNull)
+				param.Modifiers |= Modifiers.Optional;
+			
+			return EndNode(parameterDeclaration, param);
+		}
+		
+		Modifiers ConvertParamModifiers(CSharp.ParameterModifier mods)
+		{
+			switch (mods) {
+				case ICSharpCode.NRefactory.CSharp.ParameterModifier.None:
+				case ICSharpCode.NRefactory.CSharp.ParameterModifier.This:
+					return Modifiers.None;
+				case ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref:
+					return Modifiers.ByRef;
+				case ICSharpCode.NRefactory.CSharp.ParameterModifier.Out:
+					return Modifiers.ByRef; // TODO verify this!
+				case ICSharpCode.NRefactory.CSharp.ParameterModifier.Params:
+					return Modifiers.ParamArray;
+				default:
+					throw new Exception("Invalid value for ParameterModifier");
+			}
 		}
 		
 		public AstNode VisitPropertyDeclaration(CSharp.PropertyDeclaration propertyDeclaration, object data)
 		{
-			throw new NotImplementedException();
+			return null;
 		}
 		
 		public AstNode VisitVariableInitializer(CSharp.VariableInitializer variableInitializer, object data)
 		{
-			throw new NotImplementedException();
+			var decl = new VariableDeclarator();
+			
+			// look for type in parent
+			decl.Type = (AstType)variableInitializer.Parent
+				.GetChildByRole(CSharp.VariableInitializer.Roles.Type)
+				.AcceptVisitor(this, data);
+			decl.Identifiers.Add(new VariableIdentifier() { Name = new Identifier(variableInitializer.Name, AstLocation.Empty) });
+			decl.Initializer = (Expression)variableInitializer.Initializer.AcceptVisitor(this, data);
+			
+			return EndNode(variableInitializer, decl);
 		}
 		
 		public AstNode VisitFixedFieldDeclaration(CSharp.FixedFieldDeclaration fixedFieldDeclaration, object data)
@@ -644,23 +686,83 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 				target = (AstType)memberType.Target.AcceptVisitor(this, data);
 			
 			var type = new QualifiedType(target, new Identifier(memberType.MemberName, AstLocation.Empty));
+			ConvertNodes(memberType.TypeArguments, type.TypeArguments);
 			
 			return EndNode(memberType, type);
 		}
 		
 		public AstNode VisitComposedType(CSharp.ComposedType composedType, object data)
 		{
-			throw new NotImplementedException();
+			var type = new ComposedType();
+			
+			ConvertNodes(composedType.ArraySpecifiers, type.ArraySpecifiers);
+			type.BaseType = (AstType)composedType.BaseType.AcceptVisitor(this, data);
+			type.HasNullableSpecifier = composedType.HasNullableSpecifier;
+			
+			return EndNode(composedType, type);
 		}
 		
 		public AstNode VisitArraySpecifier(CSharp.ArraySpecifier arraySpecifier, object data)
 		{
-			throw new NotImplementedException();
+			return EndNode(arraySpecifier, new ArraySpecifier(arraySpecifier.Dimensions));
 		}
 		
 		public AstNode VisitPrimitiveType(CSharp.PrimitiveType primitiveType, object data)
 		{
-			throw new NotImplementedException();
+			string typeName;
+			
+			switch (primitiveType.Keyword) {
+				case "object":
+					typeName = "Object";
+					break;
+				case "bool":
+					typeName = "Boolean";
+					break;
+				case "char":
+					typeName = "Char";
+					break;
+				case "sbyte":
+					typeName = "SByte";
+					break;
+				case "byte":
+					typeName = "Byte";
+					break;
+				case "short":
+					typeName = "Short";
+					break;
+				case "ushort":
+					typeName = "UShort";
+					break;
+				case "int":
+					typeName = "Integer";
+					break;
+				case "uint":
+					typeName = "UInteger";
+					break;
+				case "long":
+					typeName = "Long";
+					break;
+				case "ulong":
+					typeName = "ULong";
+					break;
+				case "float":
+					typeName = "Single";
+					break;
+				case "double":
+					typeName = "Double";
+					break;
+				case "decimal":
+					typeName = "Decimal";
+					break;
+				case "string":
+					typeName = "String";
+					break;
+				default:
+					typeName = "unknown";
+					break;
+			}
+			
+			return EndNode(primitiveType, new PrimitiveType(typeName));
 		}
 		
 		public AstNode VisitComment(CSharp.Comment comment, object data)
@@ -670,7 +772,17 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitTypeParameterDeclaration(CSharp.TypeParameterDeclaration typeParameterDeclaration, object data)
 		{
-			throw new NotImplementedException();
+			var param = new TypeParameterDeclaration() {
+				Variance = typeParameterDeclaration.Variance,
+				Name = typeParameterDeclaration.Name
+			};
+			
+			// TODO : fetch constraints from parent node
+			
+			// TODO : typeParameterDeclaration.Attributes get lost?
+			//ConvertNodes(typeParameterDeclaration.Attributes
+			
+			return EndNode(typeParameterDeclaration, param);
 		}
 		
 		public AstNode VisitConstraint(CSharp.Constraint constraint, object data)
@@ -712,6 +824,15 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 			if ((modifier & CSharp.Modifiers.Static) == CSharp.Modifiers.Static)
 				mod |= Modifiers.Shared;
 			
+			if ((modifier & CSharp.Modifiers.Public) == CSharp.Modifiers.Public)
+				mod |= Modifiers.Public;
+			if ((modifier & CSharp.Modifiers.Protected) == CSharp.Modifiers.Protected)
+				mod |= Modifiers.Protected;
+			if ((modifier & CSharp.Modifiers.Internal) == CSharp.Modifiers.Internal)
+				mod |= Modifiers.Friend;
+			if ((modifier & CSharp.Modifiers.Private) == CSharp.Modifiers.Private)
+				mod |= Modifiers.Private;
+			
 			return mod;
 		}