From c08710e903ab4b30d8ccfd60d08df7aa1b84f1be Mon Sep 17 00:00:00 2001 From: Siegfried Pammer Date: Tue, 10 May 2011 06:17:09 +0200 Subject: [PATCH] implement AddressOfExpression, InstanceExpression, ParenthesizedExpression and SimpleNameExpression --- ILSpy.sln | 2 +- .../Ast/Expressions/AddressOfExpression.cs | 31 ++++++++++ .../Ast/Expressions/InstanceExpression.cs | 61 +++++++++++++++++++ .../Expressions/ParenthesizedExpression.cs | 34 +++++++++++ .../Ast/Expressions/SimpleNameExpression.cs | 9 ++- .../ICSharpCode.NRefactory.VB/IAstVisitor.cs | 3 + .../ICSharpCode.NRefactory.VB.csproj | 3 + .../OutputVisitor/OutputVisitor.cs | 55 ++++++++++++++++- .../Visitors/CSharpToVBConverterVisitor.cs | 14 ++++- 9 files changed, 204 insertions(+), 8 deletions(-) create mode 100644 NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/AddressOfExpression.cs create mode 100644 NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/InstanceExpression.cs create mode 100644 NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/ParenthesizedExpression.cs diff --git a/ILSpy.sln b/ILSpy.sln index b2937a8eb..04d671515 100644 --- a/ILSpy.sln +++ b/ILSpy.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 11.00 # Visual Studio 2010 -# SharpDevelop 4.1.0.7372-alpha +# SharpDevelop 4.1.0.7466-alpha Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "doc", "doc", "{F45DB999-7E72-4000-B5AD-3A7B485A0896}" ProjectSection(SolutionItems) = postProject doc\Command Line.txt = doc\Command Line.txt diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/AddressOfExpression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/AddressOfExpression.cs new file mode 100644 index 000000000..81eaca812 --- /dev/null +++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/AddressOfExpression.cs @@ -0,0 +1,31 @@ +// 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 AddressOfExpression : Expression + { + public AddressOfExpression() + { + } + + public Expression Expression { + get { return GetChildByRole(Roles.Expression); } + set { SetChildByRole(Roles.Expression, value); } + } + + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) + { + var expr = other as AddressOfExpression; + return expr != null && + Expression.DoMatch(expr.Expression, match); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitAddressOfExpression(this, data); + } + } +} diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/InstanceExpression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/InstanceExpression.cs new file mode 100644 index 000000000..80e376524 --- /dev/null +++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/InstanceExpression.cs @@ -0,0 +1,61 @@ +// 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 +{ + /// + /// Description of InstanceExpression. + /// + public class InstanceExpression : Expression + { + AstLocation location; + + public InstanceExpression(InstanceExpressionType type, AstLocation location) + { + this.Type = type; + this.location = location; + } + + public override AstLocation StartLocation { + get { return location; } + } + + public override AstLocation EndLocation { + get { + switch (Type) { + case InstanceExpressionType.Me: + return new AstLocation(location.Line, location.Column + "Me".Length); + case InstanceExpressionType.MyBase: + return new AstLocation(location.Line, location.Column + "MyBase".Length); + case InstanceExpressionType.MyClass: + return new AstLocation(location.Line, location.Column + "MyClass".Length); + default: + throw new Exception("Invalid value for InstanceExpressionType"); + } + } + } + + public InstanceExpressionType Type { get; set; } + + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) + { + var expr = other as InstanceExpression; + return expr != null && + Type == expr.Type; + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitInstanceExpression(this, data); + } + } + + public enum InstanceExpressionType + { + Me, + MyBase, + MyClass + } +} diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/ParenthesizedExpression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/ParenthesizedExpression.cs new file mode 100644 index 000000000..492426b66 --- /dev/null +++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/ParenthesizedExpression.cs @@ -0,0 +1,34 @@ +// 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 +{ + /// + /// Description of ParenthesizedExpression. + /// + public class ParenthesizedExpression : Expression + { + public ParenthesizedExpression() + { + } + + public Expression Expression { + get { return GetChildByRole(Roles.Expression); } + set { SetChildByRole(Roles.Expression, value); } + } + + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) + { + var expr = other as ParenthesizedExpression; + return expr != null && + Expression.DoMatch(expr.Expression, match); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitParenthesizedExpression(this, data); + } + } +} diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/SimpleNameExpression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/SimpleNameExpression.cs index 257b8e744..e3493784a 100644 --- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/SimpleNameExpression.cs +++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/SimpleNameExpression.cs @@ -6,17 +6,22 @@ using System; namespace ICSharpCode.NRefactory.VB.Ast { /// - /// Description of IdentifierExpression. + /// Description of SimpleNameExpression. /// public class SimpleNameExpression : Expression { public Identifier Identifier { get; set; } + public AstNodeCollection TypeArguments { + get { return GetChildrenByRole (Roles.TypeArgument); } + } + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) { var node = other as SimpleNameExpression; return node != null - && Identifier.DoMatch(node.Identifier, match); + && Identifier.DoMatch(node.Identifier, match) + && TypeArguments.DoMatch(node.TypeArguments, match); } public override S AcceptVisitor(IAstVisitor visitor, T data) diff --git a/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs index eb96f229d..5c482efa5 100644 --- a/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs +++ b/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs @@ -35,6 +35,9 @@ namespace ICSharpCode.NRefactory.VB { S VisitXmlLiteralString(XmlLiteralString xmlLiteralString, T data); S VisitSimpleNameExpression(SimpleNameExpression identifierExpression, T data); S VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, T data); + S VisitInstanceExpression(InstanceExpression instanceExpression, T data); + S VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, T data); + S VisitAddressOfExpression(AddressOfExpression addressOfExpression, T data); // TypeName S VisitPrimitiveType(PrimitiveType primitiveType, T data); diff --git a/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj b/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj index a14f01550..f6deb3479 100644 --- a/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj +++ b/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj @@ -47,7 +47,10 @@ + + + diff --git a/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs index e16957fe8..d498e5429 100644 --- a/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs +++ b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs @@ -249,9 +249,14 @@ namespace ICSharpCode.NRefactory.VB throw new NotImplementedException(); } - public object VisitSimpleNameExpression(SimpleNameExpression identifierExpression, object data) + public object VisitSimpleNameExpression(SimpleNameExpression simpleNameExpression, object data) { - throw new NotImplementedException(); + StartNode(simpleNameExpression); + + simpleNameExpression.Identifier.AcceptVisitor(this, data); + WriteTypeArguments(simpleNameExpression.TypeArguments); + + return EndNode(simpleNameExpression); } public object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) @@ -259,6 +264,49 @@ namespace ICSharpCode.NRefactory.VB throw new NotImplementedException(); } + public object VisitInstanceExpression(InstanceExpression instanceExpression, object data) + { + StartNode(instanceExpression); + + switch (instanceExpression.Type) { + case InstanceExpressionType.Me: + WriteKeyword("Me"); + break; + case InstanceExpressionType.MyBase: + WriteKeyword("MyBase"); + break; + case InstanceExpressionType.MyClass: + WriteKeyword("MyClass"); + break; + default: + throw new Exception("Invalid value for InstanceExpressionType"); + } + + return EndNode(instanceExpression); + } + + public object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) + { + StartNode(parenthesizedExpression); + + LPar(); + parenthesizedExpression.Expression.AcceptVisitor(this, data); + RPar(); + + return EndNode(parenthesizedExpression); + } + + public object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) + { + StartNode(addressOfExpression); + + WriteKeyword("AddressOf"); + addressOfExpression.Expression.AcceptVisitor(this, data); + + return EndNode(addressOfExpression); + } + + #region TypeName public object VisitPrimitiveType(PrimitiveType primitiveType, object data) { throw new NotImplementedException(); @@ -295,7 +343,9 @@ namespace ICSharpCode.NRefactory.VB return EndNode(simpleType); } + #endregion + #region Pattern Matching public object VisitAnyNode(AnyNode anyNode, object data) { throw new NotImplementedException(); @@ -330,6 +380,7 @@ namespace ICSharpCode.NRefactory.VB { throw new NotImplementedException(); } + #endregion #region StartNode/EndNode void StartNode(AstNode node) diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs index 4a3cc0609..401bc5163 100644 --- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs +++ b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs @@ -60,7 +60,9 @@ namespace ICSharpCode.NRefactory.VB.Visitors public AstNode VisitBaseReferenceExpression(CSharp.BaseReferenceExpression baseReferenceExpression, object data) { - throw new NotImplementedException(); + InstanceExpression result = new InstanceExpression(InstanceExpressionType.MyBase, ConvertLocation(baseReferenceExpression.StartLocation)); + + return EndNode(baseReferenceExpression, result); } public AstNode VisitBinaryOperatorExpression(CSharp.BinaryOperatorExpression binaryOperatorExpression, object data) @@ -145,7 +147,11 @@ namespace ICSharpCode.NRefactory.VB.Visitors public AstNode VisitParenthesizedExpression(CSharp.ParenthesizedExpression parenthesizedExpression, object data) { - throw new NotImplementedException(); + var result = new ParenthesizedExpression(); + + result.Expression = (Expression)parenthesizedExpression.Expression.AcceptVisitor(this, data); + + return EndNode(parenthesizedExpression, result); } public AstNode VisitPointerReferenceExpression(CSharp.PointerReferenceExpression pointerReferenceExpression, object data) @@ -170,7 +176,9 @@ namespace ICSharpCode.NRefactory.VB.Visitors public AstNode VisitThisReferenceExpression(CSharp.ThisReferenceExpression thisReferenceExpression, object data) { - throw new NotImplementedException(); + InstanceExpression result = new InstanceExpression(InstanceExpressionType.Me, ConvertLocation(thisReferenceExpression.StartLocation)); + + return EndNode(thisReferenceExpression, result); } public AstNode VisitTypeOfExpression(CSharp.TypeOfExpression typeOfExpression, object data)