- refactored AST; removed XmlLiteralExpression

- added VB Options to Tests

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/vbnet@6040 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitor.cs

@@ -275,17 +275,17 @@ namespace NRefactoryToBooConverter
 			throw new NotImplementedException();
 		}
 		
-		public object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data)
+		public object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data)
+		public object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public object VisitXmlLiteralExpression(XmlLiteralExpression xmlLiteralExpression, object data)
+		public object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data)
 		{
 			throw new NotImplementedException();
 		}

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Project/VBNetToCSharpConverter.cs

@@ -76,6 +76,13 @@ namespace CSharpBinding
 			
 			IProjectContent pc = ParserService.GetProjectContent(sourceItem.Project) ?? ParserService.CurrentProjectContent;
 			VBNetToCSharpConvertVisitor visitor = new VBNetToCSharpConvertVisitorWithMyFormsSupport(pc, ParserService.GetParseInformation(sourceItem.FileName), sourceItem.Project.RootNamespace);
+						
+			// set project options
+			visitor.OptionInfer = (project.GetEvaluatedProperty("OptionInfer") ?? "Off")
+				.Equals("On", StringComparison.OrdinalIgnoreCase);
+			visitor.OptionStrict = (project.GetEvaluatedProperty("OptionStrict") ?? "Off")
+				.Equals("On", StringComparison.OrdinalIgnoreCase);
+			
 			compilationUnit.AcceptVisitor(visitor, null);
 		}
 		

src/Libraries/NRefactory/NRefactoryASTGenerator/AST/Expressions.cs

@@ -403,7 +403,7 @@ namespace NRefactoryASTGenerator.Ast
 
 	abstract class XmlExpression : Expression { }
 
-	class XmlLiteralExpression : Expression {
+	class XmlDocumentExpression : XmlExpression {
 		List<XmlExpression> expressions;
 	}
 	

src/Libraries/NRefactory/Project/Src/Ast/Generated.cs

@@ -5564,6 +5564,32 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 		}
 	}
 	
+	public class XmlDocumentExpression : XmlExpression {
+		
+		List<XmlExpression> expressions;
+		
+		public List<XmlExpression> Expressions {
+			get {
+				return expressions;
+			}
+			set {
+				expressions = value ?? new List<XmlExpression>();
+			}
+		}
+		
+		public XmlDocumentExpression() {
+			expressions = new List<XmlExpression>();
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitXmlDocumentExpression(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[XmlDocumentExpression Expressions={0}]", GetCollectionString(Expressions));
+		}
+	}
+	
 	public class XmlElementExpression : XmlExpression {
 		
 		Expression content;
@@ -5673,32 +5699,6 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 		}
 	}
 	
-	public class XmlLiteralExpression : Expression {
-		
-		List<XmlExpression> expressions;
-		
-		public List<XmlExpression> Expressions {
-			get {
-				return expressions;
-			}
-			set {
-				expressions = value ?? new List<XmlExpression>();
-			}
-		}
-		
-		public XmlLiteralExpression() {
-			expressions = new List<XmlExpression>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitXmlLiteralExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[XmlLiteralExpression Expressions={0}]", GetCollectionString(Expressions));
-		}
-	}
-	
 	public class XmlMemberAccessExpression : Expression {
 		
 		Expression targetObject;

src/Libraries/NRefactory/Project/Src/IAstVisitor.cs

@@ -265,12 +265,12 @@ namespace ICSharpCode.NRefactory {
 		
 		object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data);
 		
+		object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data);
+		
 		object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data);
 		
 		object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data);
 		
-		object VisitXmlLiteralExpression(XmlLiteralExpression xmlLiteralExpression, object data);
-		
 		object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data);
 		
 		object VisitYieldStatement(YieldStatement yieldStatement, object data);

src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG

@@ -1772,10 +1772,8 @@ SimpleNonInvocationExpression<out Expression pexpr>
 
 XmlLiteralExpression<out Expression pexpr>
 (.
-	XmlLiteralExpression expr = new XmlLiteralExpression();
+	List<XmlExpression> exprs = new List<XmlExpression>();
-	List<XmlExpression> exprs = expr.Expressions;
 	XmlExpression currentExpression = null;
-	pexpr = expr;
 .)
 	=
 	(
@@ -1783,6 +1781,13 @@ XmlLiteralExpression<out Expression pexpr>
 	|
 		XmlElement<out currentExpression> (. exprs.Add(currentExpression); .) { XmlContentExpression<exprs> }
 	)
+	(.
+		if (exprs.Count > 1) {
+			pexpr = new XmlDocumentExpression() { Expressions = exprs };
+		} else {
+			pexpr = exprs[0];
+		}
+	.)
 .
 
 XmlContentExpression<List<XmlExpression> exprs> =

src/Libraries/NRefactory/Project/Src/PrettyPrinter/CSharp/CSharpOutputVisitor.cs

@@ -537,8 +537,8 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
 		
 		public override object TrackedVisitOptionDeclaration(OptionDeclaration optionDeclaration, object data)
 		{
-			if ((optionDeclaration.OptionType == OptionType.Explicit || optionDeclaration.OptionType == OptionType.Strict)
+			if (((optionDeclaration.OptionType == OptionType.Explicit || optionDeclaration.OptionType == OptionType.Strict)
-			    && optionDeclaration.OptionValue == true)
+			     && optionDeclaration.OptionValue == true) || optionDeclaration.OptionType == OptionType.Infer)
 			{
 				// Explicit On/Strict On is what C# does, do not report an error
 			} else {

src/Libraries/NRefactory/Project/Src/Visitors/AbstractASTVisitor.cs

@@ -1262,6 +1262,16 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+			Debug.Assert((xmlDocumentExpression != null));
+			Debug.Assert((xmlDocumentExpression.Expressions != null));
+			foreach (XmlExpression o in xmlDocumentExpression.Expressions) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			return null;
+		}
+		
 		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
 			Debug.Assert((xmlElementExpression != null));
 			Debug.Assert((xmlElementExpression.Content != null));
@@ -1282,16 +1292,6 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
 		}
 		
-		public virtual object VisitXmlLiteralExpression(XmlLiteralExpression xmlLiteralExpression, object data) {
-			Debug.Assert((xmlLiteralExpression != null));
-			Debug.Assert((xmlLiteralExpression.Expressions != null));
-			foreach (XmlExpression o in xmlLiteralExpression.Expressions) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
 		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
 			Debug.Assert((xmlMemberAccessExpression != null));
 			Debug.Assert((xmlMemberAccessExpression.TargetObject != null));

src/Libraries/NRefactory/Project/Src/Visitors/AbstractAstTransformer.cs

@@ -2258,6 +2258,23 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+			Debug.Assert((xmlDocumentExpression != null));
+			Debug.Assert((xmlDocumentExpression.Expressions != null));
+			for (int i = 0; i < xmlDocumentExpression.Expressions.Count; i++) {
+				XmlExpression o = xmlDocumentExpression.Expressions[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (XmlExpression)nodeStack.Pop();
+				if (o == null)
+					xmlDocumentExpression.Expressions.RemoveAt(i--);
+				else
+					xmlDocumentExpression.Expressions[i] = o;
+			}
+			return null;
+		}
+		
 		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
 			Debug.Assert((xmlElementExpression != null));
 			Debug.Assert((xmlElementExpression.Content != null));
@@ -2303,23 +2320,6 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
-		public virtual object VisitXmlLiteralExpression(XmlLiteralExpression xmlLiteralExpression, object data) {
-			Debug.Assert((xmlLiteralExpression != null));
-			Debug.Assert((xmlLiteralExpression.Expressions != null));
-			for (int i = 0; i < xmlLiteralExpression.Expressions.Count; i++) {
-				XmlExpression o = xmlLiteralExpression.Expressions[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (XmlExpression)nodeStack.Pop();
-				if (o == null)
-					xmlLiteralExpression.Expressions.RemoveAt(i--);
-				else
-					xmlLiteralExpression.Expressions[i] = o;
-			}
-			return null;
-		}
-		
 		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
 			Debug.Assert((xmlMemberAccessExpression != null));
 			Debug.Assert((xmlMemberAccessExpression.TargetObject != null));

src/Libraries/NRefactory/Project/Src/Visitors/NodeTrackingAstVisitor.cs

@@ -906,6 +906,13 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return result;
 		}
 		
+		public sealed override object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+			this.BeginVisit(xmlDocumentExpression);
+			object result = this.TrackedVisitXmlDocumentExpression(xmlDocumentExpression, data);
+			this.EndVisit(xmlDocumentExpression);
+			return result;
+		}
+		
 		public sealed override object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
 			this.BeginVisit(xmlElementExpression);
 			object result = this.TrackedVisitXmlElementExpression(xmlElementExpression, data);
@@ -920,13 +927,6 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return result;
 		}
 		
-		public sealed override object VisitXmlLiteralExpression(XmlLiteralExpression xmlLiteralExpression, object data) {
-			this.BeginVisit(xmlLiteralExpression);
-			object result = this.TrackedVisitXmlLiteralExpression(xmlLiteralExpression, data);
-			this.EndVisit(xmlLiteralExpression);
-			return result;
-		}
-		
 		public sealed override object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
 			this.BeginVisit(xmlMemberAccessExpression);
 			object result = this.TrackedVisitXmlMemberAccessExpression(xmlMemberAccessExpression, data);
@@ -1441,6 +1441,10 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return base.VisitXmlContentExpression(xmlContentExpression, data);
 		}
 		
+		public virtual object TrackedVisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+			return base.VisitXmlDocumentExpression(xmlDocumentExpression, data);
+		}
+		
 		public virtual object TrackedVisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
 			return base.VisitXmlElementExpression(xmlElementExpression, data);
 		}
@@ -1449,10 +1453,6 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return base.VisitXmlEmbeddedExpression(xmlEmbeddedExpression, data);
 		}
 		
-		public virtual object TrackedVisitXmlLiteralExpression(XmlLiteralExpression xmlLiteralExpression, object data) {
-			return base.VisitXmlLiteralExpression(xmlLiteralExpression, data);
-		}
-		
 		public virtual object TrackedVisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
 			return base.VisitXmlMemberAccessExpression(xmlMemberAccessExpression, data);
 		}

src/Libraries/NRefactory/Project/Src/Visitors/NotImplementedAstVisitor.cs

@@ -518,6 +518,10 @@ namespace ICSharpCode.NRefactory.Visitors {
 			throw new global::System.NotImplementedException("XmlContentExpression");
 		}
 		
+		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+			throw new global::System.NotImplementedException("XmlDocumentExpression");
+		}
+		
 		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
 			throw new global::System.NotImplementedException("XmlElementExpression");
 		}
@@ -526,10 +530,6 @@ namespace ICSharpCode.NRefactory.Visitors {
 			throw new global::System.NotImplementedException("XmlEmbeddedExpression");
 		}
 		
-		public virtual object VisitXmlLiteralExpression(XmlLiteralExpression xmlLiteralExpression, object data) {
-			throw new global::System.NotImplementedException("XmlLiteralExpression");
-		}
-		
 		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
 			throw new global::System.NotImplementedException("XmlMemberAccessExpression");
 		}

src/Libraries/NRefactory/Project/Src/Visitors/VBNetConstructsConvertVisitor.cs

@@ -36,6 +36,10 @@ namespace ICSharpCode.NRefactory.Visitors
 		/// </summary>
 		public bool AddDefaultValueInitializerToLocalVariableDeclarations = true;
 		
+		public bool OptionInfer { get; set; }
+		
+		public bool OptionStrict { get; set; }
+		
 		Dictionary<string, string> usings;
 		List<UsingDeclaration> addedUsings;
 		TypeDeclaration currentTypeDeclaration;
@@ -492,16 +496,33 @@ namespace ICSharpCode.NRefactory.Visitors
 		
 		public override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
 		{
-			if (AddDefaultValueInitializerToLocalVariableDeclarations && (localVariableDeclaration.Modifier & Modifiers.Static) == 0) {
+			for (int i = 0; i < localVariableDeclaration.Variables.Count; i++) {
-				for (int i = 0; i < localVariableDeclaration.Variables.Count; i++) {
+				VariableDeclaration decl = localVariableDeclaration.Variables[i];
-					VariableDeclaration decl = localVariableDeclaration.Variables[i];
+				if (AddDefaultValueInitializerToLocalVariableDeclarations &&
-					if (decl.FixedArrayInitialization.IsNull && decl.Initializer.IsNull) {
+				    (localVariableDeclaration.Modifier & Modifiers.Static) == 0 &&
-						TypeReference type = localVariableDeclaration.GetTypeForVariable(i);
+				    decl.FixedArrayInitialization.IsNull && decl.Initializer.IsNull) {
-						decl.Initializer = ExpressionBuilder.CreateDefaultValueForType(type);
+					TypeReference type = localVariableDeclaration.GetTypeForVariable(i);
-					}
+					decl.Initializer = ExpressionBuilder.CreateDefaultValueForType(type);
+				}
+				if (decl.TypeReference.IsNull) {
+					if (OptionInfer && !(decl.Initializer is PrimitiveExpression && (decl.Initializer as PrimitiveExpression).Value == null))
+						decl.TypeReference = new TypeReference("var", true);
+					else if (OptionStrict)
+						decl.TypeReference = new TypeReference("System.Object", true);
+					else
+						decl.TypeReference = new TypeReference("dynamic", true);
 				}
 			}
 			return base.VisitLocalVariableDeclaration(localVariableDeclaration, data);
 		}
+		
+		public override object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data)
+		{
+			if (optionDeclaration.OptionType == OptionType.Infer)
+				OptionInfer = optionDeclaration.OptionValue;
+			if (optionDeclaration.OptionType == OptionType.Strict)
+				OptionStrict = optionDeclaration.OptionValue;
+			return base.VisitOptionDeclaration(optionDeclaration, data);
+		}
 	}
 }

src/Libraries/NRefactory/Test/NRefactoryTests.csproj

@@ -66,7 +66,7 @@
     <Compile Include="Parser\Expressions\QueryExpressionTests.cs" />
     <Compile Include="Output\SnippetConversion.cs" />
     <Compile Include="Parser\Expressions\QueryExpressionVBTests.cs" />
-    <Compile Include="Parser\Expressions\XmlLiteralExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\XmlExpressionTests.cs" />
     <Compile Include="Parser\Expressions\XmlMemberAccessExpressionTests.cs" />
     <Compile Include="Parser\GlobalScope\AttributeSectionTests.cs" />
     <Compile Include="Output\CSharp\CSharpOutputTest.cs" />

src/Libraries/NRefactory/Test/Output/CSharp/VBNetToCSharpConverterTest.cs

@@ -57,7 +57,7 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 				}
 			}
 			b.AppendLine("}");
-			TestProgram("Class tmp1 \n" + input + "\nEnd Class", b.ToString());
+			TestProgram("Option Strict On \n Class tmp1 \n" + input + "\nEnd Class", b.ToString());
 		}
 		
 		public void TestStatement(string input, string expectedOutput)
@@ -76,7 +76,7 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 			}
 			b.AppendLine("  }");
 			b.AppendLine("}");
-			TestProgram("Class tmp1 \n Sub tmp2() \n" + input + "\n End Sub \n End Class", b.ToString());
+			TestProgram("Option Strict On \n Option Infer On \n Class tmp1 \n Sub tmp2() \n" + input + "\n End Sub \n End Class", b.ToString());
 		}
 		
 		[Test]
@@ -778,5 +778,19 @@ static bool InitStaticVariableHelper(Microsoft.VisualBasic.CompilerServices.Stat
 		{
 			TestStatement("Dim x As Integer = CInt(obj)", "int x = Convert.ToInt32(obj);");
 		}
+		
+		[Test, Ignore]
+		public void XmlElement()
+		{
+			TestStatement("Dim xml = <Test />",
+			              @"var xml = new XElement(""Test"");");
+		}
+		
+		[Test, Ignore]
+		public void XmlComment()
+		{
+			TestStatement("Dim xml = <!-- test -->",
+			              @"var xml = new XComment("" test "");");
+		}
 	}
 }

src/Libraries/NRefactory/Test/Parser/Expressions/XmlExpressionTests.cs

@@ -14,7 +14,7 @@ using ICSharpCode.NRefactory.Ast;
 namespace ICSharpCode.NRefactory.Tests.Ast
 {
 	[TestFixture]
-	public class XmlLiteralExpressionTests
+	public class XmlExpressionTests
 	{
 		#region C#
 		
@@ -26,10 +26,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetSimpleCommentTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<!-- test -->");
+			XmlContentExpression content = ParseUtilVBNet.ParseExpression<XmlContentExpression>("<!-- test -->");
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlContentExpression);
-			XmlContentExpression content = xle.Expressions[0] as XmlContentExpression;
 			Assert.AreEqual(XmlContentType.Comment, content.Type);
 			Assert.AreEqual(" test ", content.Content);
 			Assert.AreEqual(new Location(1,1), content.StartLocation);
@@ -39,10 +36,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetSimplePreprocessingInstructionTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<?xml version='1.0'?>");
+			XmlContentExpression content = ParseUtilVBNet.ParseExpression<XmlContentExpression>("<?xml version='1.0'?>");
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlContentExpression);
-			XmlContentExpression content = xle.Expressions[0] as XmlContentExpression;
 			Assert.AreEqual(XmlContentType.ProcessingInstruction, content.Type);
 			Assert.AreEqual("xml version='1.0'", content.Content);
 			Assert.AreEqual(new Location(1,1), content.StartLocation);
@@ -52,10 +46,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetSimpleCDataTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<![CDATA[<simple> <cdata>]]>");
+			XmlContentExpression content = ParseUtilVBNet.ParseExpression<XmlContentExpression>("<![CDATA[<simple> <cdata>]]>");
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlContentExpression);
-			XmlContentExpression content = xle.Expressions[0] as XmlContentExpression;
 			Assert.AreEqual(XmlContentType.CData, content.Type);
 			Assert.AreEqual("<simple> <cdata>", content.Content);
 			Assert.AreEqual(new Location(1,1), content.StartLocation);
@@ -65,10 +56,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetSimpleEmptyElementTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test />");
+			XmlElementExpression element = ParseUtilVBNet.ParseExpression<XmlElementExpression>("<Test />");
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlElementExpression);
-			XmlElementExpression element = xle.Expressions[0] as XmlElementExpression;
 			Assert.IsFalse(element.NameIsExpression);
 			Assert.AreEqual("Test", element.XmlName);
 			Assert.IsEmpty(element.Attributes);
@@ -80,10 +68,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetSimpleEmptyElementWithAttributeTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test id='0' />");
+			XmlElementExpression element = ParseUtilVBNet.ParseExpression<XmlElementExpression>("<Test id='0' />");
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlElementExpression);
-			XmlElementExpression element = xle.Expressions[0] as XmlElementExpression;
 			Assert.IsFalse(element.NameIsExpression);
 			Assert.AreEqual("Test", element.XmlName);
 			Assert.IsNotEmpty(element.Attributes);
@@ -104,11 +89,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetSimpleEmptyElementWithAttributesTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test id='0' name=<%= name %> <%= contentData %> />");
+			XmlElementExpression element = ParseUtilVBNet.ParseExpression<XmlElementExpression>("<Test id='0' name=<%= name %> <%= contentData %> />");			Assert.IsFalse(element.NameIsExpression);
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlElementExpression);
-			XmlElementExpression element = xle.Expressions[0] as XmlElementExpression;
-			Assert.IsFalse(element.NameIsExpression);
 			Assert.AreEqual("Test", element.XmlName);
 			Assert.IsNotEmpty(element.Attributes);
 			Assert.AreEqual(3, element.Attributes.Count);
@@ -158,13 +139,10 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetElementWithAttributeTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test id='0'>\n" +
+			XmlElementExpression element = ParseUtilVBNet.ParseExpression<XmlElementExpression>("<Test id='0'>\n" +
 			                                                                                "	<Item />\n" +
 			                                                                                "	<Item />\n" +
 			                                                                                "</Test>");
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlElementExpression);
-			XmlElementExpression element = xle.Expressions[0] as XmlElementExpression;
 			Assert.IsFalse(element.NameIsExpression);
 			Assert.AreEqual("Test", element.XmlName);
 			
@@ -196,15 +174,12 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetElementWithMixedContentTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test id='0'>\n" +
+			XmlElementExpression element = ParseUtilVBNet.ParseExpression<XmlElementExpression>("<Test id='0'>\n" +
 			                                                                                "	<!-- test -->\n" +
 			                                                                                "	<Item />\n" +
 			                                                                                "	<Item />\n" +
 			                                                                                "	<![CDATA[<cdata> section]]>\n" +
 			                                                                                "</Test>");
-			Assert.IsNotEmpty(xle.Expressions);
-			Assert.IsTrue(xle.Expressions[0] is XmlElementExpression);
-			XmlElementExpression element = xle.Expressions[0] as XmlElementExpression;
 			Assert.IsFalse(element.NameIsExpression);
 			Assert.AreEqual("Test", element.XmlName);
 			
@@ -240,15 +215,15 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBNetProcessingInstructionAndCommentAtEndTest()
 		{
-			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test />\n" +
+			XmlDocumentExpression document = ParseUtilVBNet.ParseExpression<XmlDocumentExpression>("<Test />\n" +
 			                                                                                "<!-- test -->\n" +
 			                                                                                "<?target some text?>");
-			Assert.IsNotEmpty(xle.Expressions);
+			Assert.IsNotEmpty(document.Expressions);
-			Assert.AreEqual(3, xle.Expressions.Count);
+			Assert.AreEqual(3, document.Expressions.Count);
 			
-			CheckElement(xle.Expressions[0], "Test", new Location(1,1), new Location(9,1));			
+			CheckElement(document.Expressions[0], "Test", new Location(1,1), new Location(9,1));			
-			CheckContent(xle.Expressions[1], " test ", XmlContentType.Comment, new Location(1,2), new Location(14,2));
+			CheckContent(document.Expressions[1], " test ", XmlContentType.Comment, new Location(1,2), new Location(14,2));
-			CheckContent(xle.Expressions[2], "target some text", XmlContentType.ProcessingInstruction, new Location(1,3), new Location(21,3));
+			CheckContent(document.Expressions[2], "target some text", XmlContentType.ProcessingInstruction, new Location(1,3), new Location(21,3));
 		}
 		#endregion