implement AddressOfExpression, InstanceExpression, ParenthesizedExpression and SimpleNameExpression

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

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<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitAddressOfExpression(this, data);
+		}
+	}
+}

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
+{
+	/// <summary>
+	/// Description of InstanceExpression.
+	/// </summary>
+	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<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitInstanceExpression(this, data);
+		}
+	}
+	
+	public enum InstanceExpressionType
+	{
+		Me,
+		MyBase,
+		MyClass
+	}
+}

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
+{
+	/// <summary>
+	/// Description of ParenthesizedExpression.
+	/// </summary>
+	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<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitParenthesizedExpression(this, data);
+		}
+	}
+}

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

@@ -6,17 +6,22 @@ using System;
 namespace ICSharpCode.NRefactory.VB.Ast
 {
 	/// <summary>
-	/// Description of IdentifierExpression.
+	/// Description of SimpleNameExpression.
 	/// </summary>
 	public class SimpleNameExpression : Expression
 	{
 		public Identifier Identifier { get; set; }
 		
+		public AstNodeCollection<AstType> 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<T, S>(IAstVisitor<T, S> visitor, T data)

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);

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

@@ -47,7 +47,10 @@
     <Compile Include="Ast\AstNode.cs" />
     <Compile Include="Ast\AstNodeCollection.cs" />
     <Compile Include="Ast\Enums.cs" />
+    <Compile Include="Ast\Expressions\AddressOfExpression.cs" />
     <Compile Include="Ast\Expressions\Expression.cs" />
+    <Compile Include="Ast\Expressions\InstanceExpression.cs" />
+    <Compile Include="Ast\Expressions\ParenthesizedExpression.cs" />
     <Compile Include="Ast\Expressions\SimpleNameExpression.cs" />
     <Compile Include="Ast\Expressions\PrimitiveExpression.cs" />
     <Compile Include="Ast\Expressions\XmlIdentifier.cs" />

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)

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)