implement NamedArgumentExpression and FieldInitializerExpression

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

@@ -170,7 +170,7 @@ namespace ICSharpCode.NRefactory.VB.Ast
 		}
 	}
 	
-		/// <summary>
+	/// <summary>
 	/// Target(Arguments)
 	/// </summary>
 	public class InvocationExpression : Expression
@@ -205,7 +205,7 @@ namespace ICSharpCode.NRefactory.VB.Ast
 		
 		public InvocationExpression (Expression target, params Expression[] arguments) : this (target, (IEnumerable<Expression>)arguments)
 		{
-		}	
+		}
 		
 		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
 		{
@@ -214,7 +214,7 @@ namespace ICSharpCode.NRefactory.VB.Ast
 		}
 	}
 	
-		/// <summary>
+	/// <summary>
 	/// Operator Expression
 	/// </summary>
 	public class UnaryOperatorExpression : Expression
@@ -280,4 +280,76 @@ namespace ICSharpCode.NRefactory.VB.Ast
 		/// <summary>Unary plus (+a)</summary>
 		Plus
 	}
+	
+	/// <summary>
+	/// Represents a named argument passed to a method or attribute.
+	/// </summary>
+	public class NamedArgumentExpression : Expression
+	{
+		public Identifier Identifier {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public VBTokenNode AssignToken {
+			get { return GetChildByRole (Roles.Assign); }
+		}
+		
+		public Expression Expression {
+			get { return GetChildByRole (Roles.Expression); }
+			set { SetChildByRole (Roles.Expression, value); }
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitNamedArgumentExpression(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			NamedArgumentExpression o = other as NamedArgumentExpression;
+			return o != null && this.Identifier.DoMatch(o.Identifier, match) && this.Expression.DoMatch(o.Expression, match);
+		}
+	}
+	
+	/// <summary>
+	/// [ Key ] .Identifier = Expression
+	/// </summary>
+	public class FieldInitializerExpression : Expression
+	{
+		public bool IsKey { get; set; }
+		
+		public VBTokenNode KeyToken {
+			get { return GetChildByRole (Roles.Keyword); }
+		}
+		
+		public VBTokenNode DotToken {
+			get { return GetChildByRole (Roles.Dot); }
+		}
+		
+		public Identifier Identifier {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public VBTokenNode AssignToken {
+			get { return GetChildByRole (Roles.Assign); }
+		}
+		
+		public Expression Expression {
+			get { return GetChildByRole (Roles.Expression); }
+			set { SetChildByRole (Roles.Expression, value); }
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitFieldInitializerExpression(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			FieldInitializerExpression o = other as FieldInitializerExpression;
+			return o != null && this.IsKey == o.IsKey && this.Identifier.DoMatch(o.Identifier, match) && this.Expression.DoMatch(o.Expression, match);
+		}
+	}
 }

NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs

@@ -65,6 +65,8 @@ namespace ICSharpCode.NRefactory.VB {
 		S VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, T data);
 		S VisitObjectCreationExpression(ObjectCreationExpression objectCreationExpression, T data);
 		S VisitCastExpression(CastExpression castExpression, T data);
+		S VisitFieldInitializerExpression(FieldInitializerExpression fieldInitializerExpression, T data);
+		S VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, T data);
 		
 		// Statement scope
 		S VisitLabelDeclarationStatement(LabelDeclarationStatement labelDeclarationStatement, T data);

NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs

@@ -431,7 +431,14 @@ namespace ICSharpCode.NRefactory.VB
 		
 		public object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data)
 		{
-			throw new NotImplementedException();
+			StartNode(typeOfIsExpression);
+			
+			WriteKeyword("TypeOf");
+			typeOfIsExpression.TypeOfExpression.AcceptVisitor(this, data);
+			WriteKeyword("Is");
+			typeOfIsExpression.Type.AcceptVisitor(this, data);
+			
+			return EndNode(typeOfIsExpression);
 		}
 		
 		public object VisitGetXmlNamespaceExpression(GetXmlNamespaceExpression getXmlNamespaceExpression, object data)
@@ -1382,12 +1389,44 @@ namespace ICSharpCode.NRefactory.VB
 		
 		public object VisitTryStatement(TryStatement tryStatement, object data)
 		{
-			throw new NotImplementedException();
+			StartNode(tryStatement);
+			WriteKeyword("Try");
+			NewLine();
+			Indent();
+			tryStatement.Body.AcceptVisitor(this, data);
+			Unindent();
+			foreach (var clause in tryStatement.CatchBlocks) {
+				clause.AcceptVisitor(this, data);
+			}
+			if (!tryStatement.FinallyBlock.IsNull) {
+				WriteKeyword("Finally");
+				NewLine();
+				Indent();
+				tryStatement.FinallyBlock.AcceptVisitor(this, data);
+				Unindent();
+			}
+			WriteKeyword("End");
+			WriteKeyword("Try");
+			return EndNode(tryStatement);
 		}
 		
 		public object VisitCatchBlock(CatchBlock catchBlock, object data)
 		{
-			throw new NotImplementedException();
+			StartNode(catchBlock);
+			WriteKeyword("Catch");
+			catchBlock.ExceptionVariable.AcceptVisitor(this, data);
+			if (!catchBlock.ExceptionType.IsNull) {
+				WriteKeyword("As");
+				catchBlock.ExceptionType.AcceptVisitor(this, data);
+			}
+			NewLine();
+			Indent();
+			foreach (var stmt in catchBlock) {
+				stmt.AcceptVisitor(this, data);
+				NewLine();
+			}
+			Unindent();
+			return EndNode(catchBlock);
 		}
 		
 		public object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
@@ -1622,7 +1661,10 @@ namespace ICSharpCode.NRefactory.VB
 			WriteKeyword("New");
 			objectCreationExpression.Type.AcceptVisitor(this, data);
 			WriteCommaSeparatedListInParenthesis(objectCreationExpression.Arguments, false);
-			objectCreationExpression.Initializer.AcceptVisitor(this, data);
+			if (!objectCreationExpression.Initializer.IsNull) {
+				Space();
+				objectCreationExpression.Initializer.AcceptVisitor(this, data);
+			}
 			
 			return EndNode(objectCreationExpression);
 		}
@@ -1773,5 +1815,30 @@ namespace ICSharpCode.NRefactory.VB
 			
 			return EndNode(unaryOperatorExpression);
 		}
+		
+		public object VisitFieldInitializerExpression(FieldInitializerExpression fieldInitializerExpression, object data)
+		{
+			StartNode(fieldInitializerExpression);
+			
+			if (fieldInitializerExpression.IsKey) {
+				WriteKeyword("Key");
+				Space();
+			}
+			
+			WriteToken(".", FieldInitializerExpression.Roles.Dot);
+			fieldInitializerExpression.Identifier.AcceptVisitor(this, data);
+			
+			Space();
+			WriteToken("=", FieldInitializerExpression.Roles.Assign);
+			Space();
+			fieldInitializerExpression.Expression.AcceptVisitor(this, data);
+			
+			return EndNode(fieldInitializerExpression);
+		}
+		
+		public object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data)
+		{
+			throw new NotImplementedException();
+		}
 	}
 }

NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs

@@ -130,6 +130,8 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 			var op = BinaryOperatorType.None;
 			var right = (Expression)binaryOperatorExpression.Right.AcceptVisitor(this, data);
 			
+			// TODO obj <> Nothing is wrong; correct would be obj IsNot Nothing
+			
 			switch (binaryOperatorExpression.Operator) {
 				case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.BitwiseAnd:
 					op = BinaryOperatorType.BitwiseAnd;
@@ -272,7 +274,12 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitIsExpression(CSharp.IsExpression isExpression, object data)
 		{
-			throw new NotImplementedException();
+			var expr = new TypeOfIsExpression() {
+				Type = (AstType)isExpression.Type.AcceptVisitor(this, data),
+				TypeOfExpression = (Expression)isExpression.Expression.AcceptVisitor(this, data)
+			};
+			
+			return EndNode(isExpression, expr);
 		}
 		
 		public AstNode VisitLambdaExpression(CSharp.LambdaExpression lambdaExpression, object data)
@@ -293,7 +300,22 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitNamedArgumentExpression(CSharp.NamedArgumentExpression namedArgumentExpression, object data)
 		{
-			throw new NotImplementedException();
+			Expression expr;
+			
+			if (namedArgumentExpression.Parent is CSharp.ArrayInitializerExpression) {
+				expr = new FieldInitializerExpression {
+					IsKey = true,
+					Identifier = namedArgumentExpression.Identifier,
+					Expression = (Expression)namedArgumentExpression.Expression.AcceptVisitor(this, data)
+				};
+			} else {
+				expr = new NamedArgumentExpression {
+					Identifier = namedArgumentExpression.Identifier,
+					Expression = (Expression)namedArgumentExpression.Expression.AcceptVisitor(this, data)
+				};
+			}
+			
+			return EndNode(namedArgumentExpression, expr);
 		}
 		
 		public AstNode VisitNullReferenceExpression(CSharp.NullReferenceExpression nullReferenceExpression, object data)
@@ -779,12 +801,24 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitTryCatchStatement(CSharp.TryCatchStatement tryCatchStatement, object data)
 		{
-			throw new NotImplementedException();
+			var stmt = new TryStatement();
+			
+			stmt.Body = (BlockStatement)tryCatchStatement.TryBlock.AcceptVisitor(this, data);
+			stmt.FinallyBlock = (BlockStatement)tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
+			ConvertNodes(tryCatchStatement.CatchClauses, stmt.CatchBlocks);
+			
+			return EndNode(tryCatchStatement, stmt);
 		}
 		
 		public AstNode VisitCatchClause(CSharp.CatchClause catchClause, object data)
 		{
-			throw new NotImplementedException();
+			var clause = new CatchBlock();
+			
+			clause.ExceptionType = (AstType)catchClause.Type.AcceptVisitor(this, data);
+			clause.ExceptionVariable = catchClause.VariableName;
+			ConvertNodes(catchClause.Body.Statements, clause.Statements);
+			
+			return EndNode(catchClause, clause);
 		}
 		
 		public AstNode VisitUncheckedStatement(CSharp.UncheckedStatement uncheckedStatement, object data)