From 024348d187ec88f6ae4a8646fe5e00011a0e15df Mon Sep 17 00:00:00 2001 From: Siegfried Pammer Date: Thu, 30 Jun 2011 10:30:43 +0200 Subject: [PATCH] implement NamedArgumentExpression and FieldInitializerExpression --- .../Ast/Expressions/Expression.cs | 78 ++++++++++++++++++- ICSharpCode.NRefactory.VB/IAstVisitor.cs | 2 + .../OutputVisitor/OutputVisitor.cs | 75 +++++++++++++++++- .../Visitors/CSharpToVBConverterVisitor.cs | 42 +++++++++- 4 files changed, 186 insertions(+), 11 deletions(-) diff --git a/ICSharpCode.NRefactory.VB/Ast/Expressions/Expression.cs b/ICSharpCode.NRefactory.VB/Ast/Expressions/Expression.cs index 212db02c34..a98a632aea 100644 --- a/ICSharpCode.NRefactory.VB/Ast/Expressions/Expression.cs +++ b/ICSharpCode.NRefactory.VB/Ast/Expressions/Expression.cs @@ -170,7 +170,7 @@ namespace ICSharpCode.NRefactory.VB.Ast } } - /// + /// /// Target(Arguments) /// public class InvocationExpression : Expression @@ -205,7 +205,7 @@ namespace ICSharpCode.NRefactory.VB.Ast public InvocationExpression (Expression target, params Expression[] arguments) : this (target, (IEnumerable)arguments) { - } + } protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { @@ -214,7 +214,7 @@ namespace ICSharpCode.NRefactory.VB.Ast } } - /// + /// /// Operator Expression /// public class UnaryOperatorExpression : Expression @@ -280,4 +280,76 @@ namespace ICSharpCode.NRefactory.VB.Ast /// Unary plus (+a) Plus } + + /// + /// Represents a named argument passed to a method or attribute. + /// + 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(IAstVisitor 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); + } + } + + /// + /// [ Key ] .Identifier = Expression + /// + 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(IAstVisitor 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); + } + } } diff --git a/ICSharpCode.NRefactory.VB/IAstVisitor.cs b/ICSharpCode.NRefactory.VB/IAstVisitor.cs index bbe2331b67..fb54df1e79 100644 --- a/ICSharpCode.NRefactory.VB/IAstVisitor.cs +++ b/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); diff --git a/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs b/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs index 2632900946..8a19ea6f98 100644 --- a/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs +++ b/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(); + } } } diff --git a/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs index b8fce019ef..598f1e5065 100644 --- a/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs +++ b/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)