finished XML Literals in Parser + Unit Tests

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

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Lexer.cs

@@ -97,11 +97,15 @@ namespace ICSharpCode.NRefactory.Parser.VB
 							while ((peek = ReaderPeek(step)) != -1 && XmlConvert.IsWhitespaceChar((char)peek))
 								step++;
 
-							if (ReaderPeek(step) == '<' && ReaderPeek(step + 1) == '!') {
+							if (ReaderPeek(step) == '<' && (ReaderPeek(step + 1) == '!' || ReaderPeek(step + 1) == '?')) {
+								char lastCh = '\0';
 								for (int i = 0; i < step + 2; i++)
-									ReaderRead();
+									lastCh = (char)ReaderRead();
 								
-								return ReadXmlCommentOrCData(Col - 1, Line);
+								if (lastCh == '!')
+									return ReadXmlCommentOrCData(Col - 2, Line);
+								else
+									return ReadXmlProcessingInstruction(Col - 2, Line);
 							}
 							
 							break;
@@ -166,7 +170,8 @@ namespace ICSharpCode.NRefactory.Parser.VB
 										continue;
 									return new Token(Tokens.Identifier, x, y, ReadXmlIdent(ch));
 								} else {
-									return new Token(Tokens.XmlContent, x, y, ReadXmlContent(ch));
+									string content = ReadXmlContent(ch);
+									return new Token(Tokens.XmlContent, startLocation, new Location(Col, Line), content, null, LiteralFormat.None);
 								}
 						}
 						#endregion
@@ -350,8 +355,9 @@ namespace ICSharpCode.NRefactory.Parser.VB
 								info.inXmlCloseTag = true;
 								return new Token(Tokens.XmlOpenEndTag, new Location(x, y), new Location(Col, Line));
 							}
+							// should we allow <%= at start of an expression? not valid with vbc ...
 							if (ReaderPeek() == '%' && ReaderPeek(1) == '=') {
-								// TODO : suspend xml mode tracking
+								inXmlMode = false;
 								ReaderRead(); ReaderRead();
 								return new Token(Tokens.XmlStartInlineVB, new Location(x, y), new Location(Col, Line));
 							}

src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/Test/XmlModeLexerTests.cs

@@ -188,14 +188,15 @@ namespace VBParserExperiment
 			                                                                        <Data />
 			                                                                      </Test>
 			                                                                      <!-- eof -->
-			                                                                      <!-- hey, wait! -->")));
+			                                                                      <!-- hey, wait! -->
+			                                                                      <?target some data?>")));
 			
 			CheckHead(lexer);
 			
 			CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign,
 			            Tokens.XmlComment, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag,
 			            Tokens.XmlContent, Tokens.XmlComment, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTagEmptyElement,
-			            Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlComment, Tokens.XmlComment);
+			            Tokens.XmlContent, Tokens.XmlOpenEndTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlComment, Tokens.XmlComment, Tokens.XmlProcessingInstruction);
 			
 			CheckFoot(lexer);
 		}

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

@@ -1800,7 +1800,7 @@ XmlContentExpression<List<XmlExpression> exprs> =
 .
 
 XmlNestedContent<out XmlExpression expr>
-	(. XmlExpression tmpExpr = null; .)
+	(. XmlExpression tmpExpr = null; Location start = la.Location; .)
 =
 	(
 		XmlContent (. tmpExpr = new XmlContentExpression(t.val, XmlContentType.Text); .)
@@ -1810,7 +1810,13 @@ XmlNestedContent<out XmlExpression expr>
 		| XmlStartInlineVB (. Expression innerExpression; .) Expr<out innerExpression> XmlEndInlineVB (. tmpExpr = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression }; .)
 		| XmlElement<out tmpExpr>
 	)
-	(. expr = tmpExpr; .)
+	(.
+		if (tmpExpr.StartLocation.IsEmpty)
+			tmpExpr.StartLocation = start;
+		if (tmpExpr.EndLocation.IsEmpty)
+			tmpExpr.EndLocation = t.EndLocation;
+		expr = tmpExpr;
+	.)
 .
 
 XmlElement<out XmlExpression expr>
@@ -1826,13 +1832,16 @@ XmlElement<out XmlExpression expr>
 	(. expr = el; .)
 .
 
-XmlAttribute<List<XmlExpression> attrs> =
-	Identifier (. string name = t.val; .) "="
-	(. string literalValue = null; Expression expressionValue = null; .)
-	( LiteralString (. literalValue = t.literalValue.ToString(); .) | XmlStartInlineVB Expr<out expressionValue> XmlEndInlineVB )
-	(. attrs.Add(new XmlAttribute() { Name = name, ExpressionValue = expressionValue, LiteralValue = literalValue }); .)
-	| XmlStartInlineVB (. Expression innerExpression; .) Expr<out innerExpression> XmlEndInlineVB
-	(. attrs.Add(new XmlEmbeddedExpression() { InlineVBExpression = innerExpression }); .)
+XmlAttribute<List<XmlExpression> attrs>
+	(. Location start = la.Location; .)
+=
+		Identifier (. string name = t.val; .) "="
+		(. string literalValue = null; Expression expressionValue = null; .)
+		( LiteralString (. literalValue = t.literalValue.ToString(); .) | XmlStartInlineVB Expr<out expressionValue> XmlEndInlineVB )
+		(. attrs.Add(new XmlAttribute() { Name = name, ExpressionValue = expressionValue, LiteralValue = literalValue, StartLocation = start, EndLocation = t.EndLocation }); .)
+	|
+		XmlStartInlineVB (. Expression innerExpression; .) Expr<out innerExpression> XmlEndInlineVB
+		(. attrs.Add(new XmlEmbeddedExpression() { InlineVBExpression = innerExpression, StartLocation = start, EndLocation = t.EndLocation }); .)
 .
 
 ConditionalExpression<out Expression expr>

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

@@ -76,6 +76,202 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual(new Location(1,1), element.StartLocation);
 			Assert.AreEqual(new Location(9,1), element.EndLocation);
 		}
+		
+		[Test]
+		public void VBNetSimpleEmptyElementWithAttributeTest()
+		{
+			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<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);
+			Assert.AreEqual(1, element.Attributes.Count);
+			Assert.IsTrue(element.Attributes[0] is XmlAttribute);
+			XmlAttribute attribute = element.Attributes[0] as XmlAttribute;
+			Assert.AreEqual("id", attribute.Name);
+			Assert.IsTrue(attribute.IsLiteralValue);
+			Assert.IsTrue(attribute.ExpressionValue.IsNull);
+			Assert.AreEqual("0", attribute.LiteralValue);
+			Assert.AreEqual(new Location(7,1), attribute.StartLocation);
+			Assert.AreEqual(new Location(13,1), attribute.EndLocation);
+			Assert.IsEmpty(element.Children);
+			Assert.AreEqual(new Location(1,1), element.StartLocation);
+			Assert.AreEqual(new Location(16,1), element.EndLocation);
+		}
+		
+		[Test]
+		public void VBNetSimpleEmptyElementWithAttributesTest()
+		{
+			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test id='0' name=<%= name %> <%= contentData %> />");
+			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);
+			
+			Assert.IsTrue(element.Attributes[0] is XmlAttribute);
+			XmlAttribute attribute = element.Attributes[0] as XmlAttribute;
+			Assert.AreEqual("id", attribute.Name);
+			Assert.IsTrue(attribute.IsLiteralValue);
+			Assert.IsTrue(attribute.ExpressionValue.IsNull);
+			Assert.AreEqual("0", attribute.LiteralValue);
+			Assert.AreEqual(new Location(7,1), attribute.StartLocation);
+			Assert.AreEqual(new Location(13,1), attribute.EndLocation);
+			
+			Assert.IsTrue(element.Attributes[1] is XmlAttribute);
+			XmlAttribute attribute2 = element.Attributes[1] as XmlAttribute;
+			Assert.AreEqual("name", attribute2.Name);
+			Assert.IsFalse(attribute2.IsLiteralValue);
+			Assert.IsFalse(attribute2.ExpressionValue.IsNull);
+			
+			Assert.IsTrue(attribute2.ExpressionValue is IdentifierExpression);
+			IdentifierExpression identifier = attribute2.ExpressionValue as IdentifierExpression;
+			Assert.AreEqual("name", identifier.Identifier);
+			Assert.AreEqual(new Location(23,1), identifier.StartLocation);
+			Assert.AreEqual(new Location(27,1), identifier.EndLocation);
+			
+			Assert.AreEqual(new Location(14,1), attribute2.StartLocation);
+			Assert.AreEqual(new Location(30,1), attribute2.EndLocation);
+			
+			Assert.IsTrue(element.Attributes[2] is XmlEmbeddedExpression);
+			XmlEmbeddedExpression attribute3 = element.Attributes[2] as XmlEmbeddedExpression;
+			
+			Assert.IsTrue(attribute3.InlineVBExpression is IdentifierExpression);
+			IdentifierExpression identifier2 = attribute3.InlineVBExpression as IdentifierExpression;
+			
+			Assert.AreEqual("contentData", identifier2.Identifier);
+			Assert.AreEqual(new Location(35,1), identifier2.StartLocation);
+			Assert.AreEqual(new Location(46,1), identifier2.EndLocation);
+			
+			Assert.AreEqual(new Location(31,1), attribute3.StartLocation);
+			Assert.AreEqual(new Location(49,1), attribute3.EndLocation);
+			
+			Assert.IsEmpty(element.Children);
+			Assert.AreEqual(new Location(1,1), element.StartLocation);
+			Assert.AreEqual(new Location(52,1), element.EndLocation);
+		}
+		
+		[Test]
+		public void VBNetElementWithAttributeTest()
+		{
+			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<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);
+			
+			Assert.IsNotEmpty(element.Attributes);
+			Assert.AreEqual(1, element.Attributes.Count);
+			Assert.IsTrue(element.Attributes[0] is XmlAttribute);
+			XmlAttribute attribute = element.Attributes[0] as XmlAttribute;
+			Assert.AreEqual("id", attribute.Name);
+			Assert.IsTrue(attribute.IsLiteralValue);
+			Assert.IsTrue(attribute.ExpressionValue.IsNull);
+			Assert.AreEqual("0", attribute.LiteralValue);
+			Assert.AreEqual(new Location(7,1), attribute.StartLocation);
+			Assert.AreEqual(new Location(13,1), attribute.EndLocation);
+			
+			Assert.IsNotEmpty(element.Children);
+			Assert.AreEqual(5, element.Children.Count);
+			
+			CheckContent(element.Children[0], "\n\t", XmlContentType.Text, new Location(14,1), new Location(2,2));
+			CheckContent(element.Children[2], "\n\t", XmlContentType.Text, new Location(10,2), new Location(2,3));
+			CheckContent(element.Children[4], "\n", XmlContentType.Text, new Location(10,3), new Location(1,4));
+			
+			CheckElement(element.Children[1], "Item", new Location(2,2), new Location(10,2));
+			CheckElement(element.Children[3], "Item", new Location(2,3), new Location(10,3));
+			
+			Assert.AreEqual(new Location(1,1), element.StartLocation);
+			Assert.AreEqual(new Location(8,4), element.EndLocation);
+		}
+		
+		[Test]
+		public void VBNetElementWithMixedContentTest()
+		{
+			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<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);
+			
+			Assert.IsNotEmpty(element.Attributes);
+			Assert.AreEqual(1, element.Attributes.Count);
+			Assert.IsTrue(element.Attributes[0] is XmlAttribute);
+			XmlAttribute attribute = element.Attributes[0] as XmlAttribute;
+			Assert.AreEqual("id", attribute.Name);
+			Assert.IsTrue(attribute.IsLiteralValue);
+			Assert.IsTrue(attribute.ExpressionValue.IsNull);
+			Assert.AreEqual("0", attribute.LiteralValue);
+			Assert.AreEqual(new Location(7,1), attribute.StartLocation);
+			Assert.AreEqual(new Location(13,1), attribute.EndLocation);
+			
+			Assert.IsNotEmpty(element.Children);
+			Assert.AreEqual(9, element.Children.Count);
+			
+			CheckContent(element.Children[0], "\n\t", XmlContentType.Text, new Location(14,1), new Location(2,2));
+			CheckContent(element.Children[2], "\n\t", XmlContentType.Text, new Location(15,2), new Location(2,3));
+			CheckContent(element.Children[4], "\n\t", XmlContentType.Text, new Location(10,3), new Location(2,4));
+			CheckContent(element.Children[6], "\n\t", XmlContentType.Text, new Location(10,4), new Location(2,5));
+			CheckContent(element.Children[7], "<cdata> section", XmlContentType.CData, new Location(2,5), new Location(29,5));
+			CheckContent(element.Children[8], "\n", XmlContentType.Text, new Location(29,5), new Location(1,6));
+			
+			CheckContent(element.Children[1], " test ", XmlContentType.Comment, new Location(2,2), new Location(15,2));
+			CheckElement(element.Children[3], "Item", new Location(2,3), new Location(10,3));
+			CheckElement(element.Children[5], "Item", new Location(2,4), new Location(10,4));
+			
+			Assert.AreEqual(new Location(1,1), element.StartLocation);
+			Assert.AreEqual(new Location(8,6), element.EndLocation);
+		}
+		
+		[Test]
+		public void VBNetProcessingInstructionAndCommentAtEndTest()
+		{
+			XmlLiteralExpression xle = ParseUtilVBNet.ParseExpression<XmlLiteralExpression>("<Test />\n" +
+			                                                                                "<!-- test -->\n" +
+			                                                                                "<?target some text?>");
+			Assert.IsNotEmpty(xle.Expressions);
+			Assert.AreEqual(3, xle.Expressions.Count);
+			
+			CheckElement(xle.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(xle.Expressions[2], "target some text", XmlContentType.ProcessingInstruction, new Location(1,3), new Location(21,3));
+		}
 		#endregion
+		
+		void CheckElement(INode node, string name, Location start, Location end)
+		{
+			Assert.IsTrue(node is XmlElementExpression);
+			XmlElementExpression expr = node as XmlElementExpression;
+			Assert.IsEmpty(expr.Attributes);
+			Assert.IsEmpty(expr.Children);
+			Assert.IsFalse(expr.NameIsExpression);
+			Assert.AreEqual(name, expr.XmlName);
+			Assert.AreEqual(start, expr.StartLocation);
+			Assert.AreEqual(end, expr.EndLocation);
+		}
+		
+		void CheckContent(INode node, string content, XmlContentType type, Location start, Location end)
+		{
+			Assert.IsTrue(node is XmlContentExpression);
+			XmlContentExpression expr = node as XmlContentExpression;
+			Assert.AreEqual(type, expr.Type);
+			Assert.AreEqual(content, expr.Content);
+			Assert.AreEqual(start, expr.StartLocation);
+			Assert.AreEqual(end, expr.EndLocation);
+		}
 	}
 }