- added DOM for XML literals

- removed XmlProcessingInstructionStart and XmlProcessingInstructionEnd

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

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

@@ -390,5 +390,49 @@ namespace NRefactoryASTGenerator.Ast
 		List<ExpressionRangeVariable> intoVariables;
 	}
 	
+	enum XmlAxisType { }
 	
+	class XmlMemberAccessExpression : Expression {
+		Expression targetObject;
+		XmlAxisType type;
+		bool isXmlIdentifier;
+		string identifier;
+	}
+
+	abstract class XmlExpression : Expression { }
+
+	class XmlLiteralExpression : Expression {
+		List<XmlExpression> expressions;
+	}
+
+	class XmlCommentExpression : XmlExpression {
+		string content;
+	}
+	
+	enum XmlContentType { }
+	
+	class XmlContentExpression : XmlExpression {
+		string content;
+		XmlContentType type;
+	}
+	
+	class XmlEmbeddedExpression : XmlExpression {
+		Expression inlineVBExpression;
+	}
+
+	[IncludeBoolProperty("IsExpression", "return !content.IsNull;")]
+	[IncludeBoolProperty("NameIsExpression", "return !nameExpression.IsNull;")]
+	class XmlElementExpression : XmlExpression {
+		Expression content;
+		Expression nameExpression;
+		string xmlName;
+		List<XmlExpression> attributes;
+	}
+	
+	[IncludeBoolProperty("IsLiteralValue", "return expressionValue.IsNull;")]
+	class XmlAttribute : XmlExpression {
+		string name;
+		string literalValue;
+		Expression expressionValue;
+	}
 }

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

@@ -398,4 +398,19 @@ namespace ICSharpCode.NRefactory.Ast
 		Skip,
 		SkipWhile
 	}
+	
+	public enum XmlAxisType
+	{
+		Element, // .
+		Attribute, // .@
+		Descendents // ...
+	}
+	
+	public enum XmlContentType
+	{
+		Comment,
+		Text,
+		CData,
+		ProcessingInstruction
+	}
 }

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

@@ -1665,9 +1665,9 @@ namespace ICSharpCode.NRefactory.Ast {
 			initializer = Expression.Null;
 		}
 		
-		public bool HasAddRegion {
+		public bool HasRaiseRegion {
 			get {
-				return !addRegion.IsNull;
+				return !raiseRegion.IsNull;
 			}
 		}
 		
@@ -1677,9 +1677,9 @@ namespace ICSharpCode.NRefactory.Ast {
 			}
 		}
 		
-		public bool HasRaiseRegion {
+		public bool HasAddRegion {
 			get {
-				return !raiseRegion.IsNull;
+				return !addRegion.IsNull;
 			}
 		}
 		
@@ -1983,15 +1983,6 @@ namespace ICSharpCode.NRefactory.Ast {
 		}
 		
 
-		public TypeReference GetTypeForField(int fieldIndex)
-		{
-			if (!typeReference.IsNull) {
-				return typeReference;
-			}
-			return ((VariableDeclaration)Fields[fieldIndex]).TypeReference;
-		}
-		
-
 		public VariableDeclaration GetVariableDeclaration(string variableName)
 		{
 			foreach (VariableDeclaration variableDeclaration in Fields) {
@@ -2002,6 +1993,15 @@ namespace ICSharpCode.NRefactory.Ast {
 			return null;
 		}
 		
+
+		public TypeReference GetTypeForField(int fieldIndex)
+		{
+			if (!typeReference.IsNull) {
+				return typeReference;
+			}
+			return ((VariableDeclaration)Fields[fieldIndex]).TypeReference;
+		}
+		
 		public override object AcceptVisitor(IAstVisitor visitor, object data) {
 			return visitor.VisitFieldDeclaration(this, data);
 		}
@@ -2421,32 +2421,32 @@ namespace ICSharpCode.NRefactory.Ast {
 			elseIfSections = new List<ElseIfSection>();
 		}
 		
-		public bool HasElseStatements {
+		public bool HasElseIfSections {
 			get {
-				return falseStatement.Count > 0;
+				return elseIfSections.Count > 0;
 			}
 		}
 		
-		public bool HasElseIfSections {
+		public bool HasElseStatements {
 			get {
-				return elseIfSections.Count > 0;
+				return falseStatement.Count > 0;
 			}
 		}
 		
 
-			public IfElseStatement(Expression condition, Statement trueStatement)
+			public IfElseStatement(Expression condition, Statement trueStatement, Statement falseStatement)
 				: this(condition) {
 				this.trueStatement.Add(Statement.CheckNull(trueStatement));
+				this.falseStatement.Add(Statement.CheckNull(falseStatement));
 				if (trueStatement != null) trueStatement.Parent = this;
+				if (falseStatement != null) falseStatement.Parent = this;
 			}
 		
 
-			public IfElseStatement(Expression condition, Statement trueStatement, Statement falseStatement)
+			public IfElseStatement(Expression condition, Statement trueStatement)
 				: this(condition) {
 				this.trueStatement.Add(Statement.CheckNull(trueStatement));
-				this.falseStatement.Add(Statement.CheckNull(falseStatement));
 				if (trueStatement != null) trueStatement.Parent = this;
-				if (falseStatement != null) falseStatement.Parent = this;
 			}
 		
 		public override object AcceptVisitor(IAstVisitor visitor, object data) {
@@ -3423,12 +3423,6 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public bool HasSetRegion {
-			get {
-				return !setRegion.IsNull;
-			}
-		}
-		
 		public bool IsReadOnly {
 			get {
 				return HasGetRegion && !HasSetRegion;
@@ -3447,6 +3441,12 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
+		public bool HasSetRegion {
+			get {
+				return !setRegion.IsNull;
+			}
+		}
+		
 
 		internal PropertyDeclaration(string name, TypeReference typeReference, Modifiers modifier, List<AttributeSection> attributes) : this(modifier, attributes, name, null)
 		{
@@ -5257,15 +5257,15 @@ public Location ExtendedEndLocation { get; set; }
 			alias = TypeReference.Null;
 		}
 		
-		public bool IsAlias {
+		public bool IsXml {
 			get {
-				return !alias.IsNull;
+				return xmlPrefix != null;
 			}
 		}
 		
-		public bool IsXml {
+		public bool IsAlias {
 			get {
-				return xmlPrefix != null;
+				return !alias.IsNull;
 			}
 		}
 		
@@ -5295,12 +5295,12 @@ public Location ExtendedEndLocation { get; set; }
 			Usings = usings;
 		}
 		
-public UsingDeclaration(string @namespace, TypeReference alias) { usings = new List<Using>(1); usings.Add(new Using(@namespace, alias)); }
-		
 public UsingDeclaration(string @namespace) : this(@namespace, TypeReference.Null) {}
 		
 public UsingDeclaration(string xmlNamespace, string prefix) { usings = new List<Using>(1); usings.Add(new Using(xmlNamespace, prefix)); }
 		
+public UsingDeclaration(string @namespace, TypeReference alias) { usings = new List<Using>(1); usings.Add(new Using(@namespace, alias)); }
+		
 		public override object AcceptVisitor(IAstVisitor visitor, object data) {
 			return visitor.VisitUsingDeclaration(this, data);
 		}
@@ -5458,6 +5458,323 @@ public UsingDeclaration(string xmlNamespace, string prefix) { usings = new List<
 		}
 	}
 	
+	public class XmlAttribute : XmlExpression {
+		
+		string name;
+		
+		string literalValue;
+		
+		Expression expressionValue;
+		
+		public string Name {
+			get {
+				return name;
+			}
+			set {
+				name = value ?? "";
+			}
+		}
+		
+		public string LiteralValue {
+			get {
+				return literalValue;
+			}
+			set {
+				literalValue = value ?? "";
+			}
+		}
+		
+		public Expression ExpressionValue {
+			get {
+				return expressionValue;
+			}
+			set {
+				expressionValue = value ?? Expression.Null;
+				if (!expressionValue.IsNull) expressionValue.Parent = this;
+			}
+		}
+		
+		public XmlAttribute() {
+			name = "";
+			literalValue = "";
+			expressionValue = Expression.Null;
+		}
+		
+		public bool IsLiteralValue {
+			get {
+				return expressionValue.IsNull;
+			}
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitXmlAttribute(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[XmlAttribute Name={0} LiteralValue={1} ExpressionValue={2}]", Name, LiteralValue, ExpressionValue);
+		}
+	}
+	
+	public class XmlCommentExpression : XmlExpression {
+		
+		string content;
+		
+		public string Content {
+			get {
+				return content;
+			}
+			set {
+				content = value ?? "";
+			}
+		}
+		
+		public XmlCommentExpression() {
+			content = "";
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitXmlCommentExpression(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[XmlCommentExpression Content={0}]", Content);
+		}
+	}
+	
+	public class XmlContentExpression : XmlExpression {
+		
+		string content;
+		
+		XmlContentType type;
+		
+		public string Content {
+			get {
+				return content;
+			}
+			set {
+				content = value ?? "";
+			}
+		}
+		
+		public XmlContentType Type {
+			get {
+				return type;
+			}
+			set {
+				type = value;
+			}
+		}
+		
+		public XmlContentExpression() {
+			content = "";
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitXmlContentExpression(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[XmlContentExpression Content={0} Type={1}]", Content, Type);
+		}
+	}
+	
+	public class XmlElementExpression : XmlExpression {
+		
+		Expression content;
+		
+		Expression nameExpression;
+		
+		string xmlName;
+		
+		List<XmlExpression> attributes;
+		
+		public Expression Content {
+			get {
+				return content;
+			}
+			set {
+				content = value ?? Expression.Null;
+				if (!content.IsNull) content.Parent = this;
+			}
+		}
+		
+		public Expression NameExpression {
+			get {
+				return nameExpression;
+			}
+			set {
+				nameExpression = value ?? Expression.Null;
+				if (!nameExpression.IsNull) nameExpression.Parent = this;
+			}
+		}
+		
+		public string XmlName {
+			get {
+				return xmlName;
+			}
+			set {
+				xmlName = value ?? "";
+			}
+		}
+		
+		public List<XmlExpression> Attributes {
+			get {
+				return attributes;
+			}
+			set {
+				attributes = value ?? new List<XmlExpression>();
+			}
+		}
+		
+		public XmlElementExpression() {
+			content = Expression.Null;
+			nameExpression = Expression.Null;
+			xmlName = "";
+			attributes = new List<XmlExpression>();
+		}
+		
+		public bool IsExpression {
+			get {
+				return !content.IsNull;
+			}
+		}
+		
+		public bool NameIsExpression {
+			get {
+				return !nameExpression.IsNull;
+			}
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitXmlElementExpression(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[XmlElementExpression Content={0} NameExpression={1} XmlName={2} Attributes={3}]", Content, NameExpression, XmlName, GetCollectionString(Attributes));
+		}
+	}
+	
+	public class XmlEmbeddedExpression : XmlExpression {
+		
+		Expression inlineVBExpression;
+		
+		public Expression InlineVBExpression {
+			get {
+				return inlineVBExpression;
+			}
+			set {
+				inlineVBExpression = value ?? Expression.Null;
+				if (!inlineVBExpression.IsNull) inlineVBExpression.Parent = this;
+			}
+		}
+		
+		public XmlEmbeddedExpression() {
+			inlineVBExpression = Expression.Null;
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitXmlEmbeddedExpression(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[XmlEmbeddedExpression InlineVBExpression={0}]", InlineVBExpression);
+		}
+	}
+	
+	public abstract class XmlExpression : Expression {
+		
+		protected XmlExpression() {
+		}
+	}
+	
+	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;
+		
+		XmlAxisType type;
+		
+		bool isXmlIdentifier;
+		
+		string identifier;
+		
+		public Expression TargetObject {
+			get {
+				return targetObject;
+			}
+			set {
+				targetObject = value ?? Expression.Null;
+				if (!targetObject.IsNull) targetObject.Parent = this;
+			}
+		}
+		
+		public XmlAxisType Type {
+			get {
+				return type;
+			}
+			set {
+				type = value;
+			}
+		}
+		
+		public bool IsXmlIdentifier {
+			get {
+				return isXmlIdentifier;
+			}
+			set {
+				isXmlIdentifier = value;
+			}
+		}
+		
+		public string Identifier {
+			get {
+				return identifier;
+			}
+			set {
+				identifier = value ?? "";
+			}
+		}
+		
+		public XmlMemberAccessExpression() {
+			targetObject = Expression.Null;
+			identifier = "";
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitXmlMemberAccessExpression(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[XmlMemberAccessExpression TargetObject={0} Type={1} IsXmlIdentifier={2} Identifi" +
+					"er={3}]", TargetObject, Type, IsXmlIdentifier, Identifier);
+		}
+	}
+	
 	public class YieldStatement : Statement {
 		
 		Statement statement;

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

@@ -261,6 +261,20 @@ namespace ICSharpCode.NRefactory {
 		
 		object VisitWithStatement(WithStatement withStatement, object data);
 		
+		object VisitXmlAttribute(XmlAttribute xmlAttribute, object data);
+		
+		object VisitXmlCommentExpression(XmlCommentExpression xmlCommentExpression, object data);
+		
+		object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, 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/Lexer/VBNet/KeywordList.txt

@@ -30,8 +30,7 @@ XmlOpenEndTag
 XmlContent
 XmlComment
 XmlCData
-XmlProcessingInstructionStart
-XmlProcessingInstructionEnd
+XmlProcessingInstruction
 
 # SPECIAL_CHARACTERS
 Assign = "="

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

@@ -129,8 +129,11 @@ namespace ICSharpCode.NRefactory.Parser.VB
 								}
 								if (ReaderPeek() == '?') {
 									ReaderRead();
-									info.inXmlTag = true;
-									return new Token(Tokens.XmlProcessingInstructionStart, x, y);
+									Token t = ReadXmlProcessingInstruction(x, y);
+									info.wasProcessingInstruction = true;
+									ReaderRead();
+									ReaderRead();
+									return t;
 								}
 								if (ReaderPeek() == '!') {
 									ReaderRead();
@@ -150,14 +153,6 @@ namespace ICSharpCode.NRefactory.Parser.VB
 									return new Token(Tokens.XmlCloseTagEmptyElement, x, y);
 								}
 								break;
-							case '?':
-								if (ReaderPeek() == '>') {
-									ReaderRead();
-									info.inXmlTag = false;
-									info.wasProcessingInstruction = true;
-									return new Token(Tokens.XmlProcessingInstructionEnd, x, y);
-								}
-								break;
 							case '>':
 								if (info.inXmlCloseTag)
 									info.level--;
@@ -374,8 +369,11 @@ namespace ICSharpCode.NRefactory.Parser.VB
 							}
 							if (ReaderPeek() == '?') {
 								ReaderRead();
-								info.inXmlTag = true;
-								return new Token(Tokens.XmlProcessingInstructionStart, x, y);
+								Token t = ReadXmlProcessingInstruction(x, y);
+								info.wasProcessingInstruction = true;
+								ReaderRead();
+								ReaderRead();
+								return t;
 							}
 							info.inXmlTag = true;
 							info.level++;
@@ -393,15 +391,32 @@ namespace ICSharpCode.NRefactory.Parser.VB
 			}
 		}
 		
+		Token ReadXmlProcessingInstruction(int x, int y)
+		{
+			sb.Length = 0;
+			int nextChar = -1;
+			
+			while (ReaderPeek() != '?' || ReaderPeek(1) != '>') {
+				nextChar = ReaderRead();
+				if (nextChar == -1)
+					break;
+				sb.Append((char)nextChar);
+			}
+			
+			return new Token(Tokens.XmlProcessingInstruction, x, y, sb.ToString());
+		}
+		
 		Token ReadXmlCommentOrCData(int x, int y)
 		{
 			sb.Length = 0;
 			int nextChar = -1;
 			
 			for (int i = 0; i < 7; i++) {
-				nextChar = ReaderRead();
-				if (nextChar > -1)
+				nextChar = ReaderPeek();
+				if (nextChar > -1 && nextChar != '>') {
+					ReaderRead();
 					sb.Append((char)nextChar);
+				}
 			}
 			
 			if (sb.ToString().StartsWith("--")) {

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

@@ -26,232 +26,231 @@ namespace ICSharpCode.NRefactory.Parser.VB
 		public const int XmlContent           = 16;
 		public const int XmlComment           = 17;
 		public const int XmlCData             = 18;
-		public const int XmlProcessingInstructionStart = 19;
-		public const int XmlProcessingInstructionEnd = 20;
+		public const int XmlProcessingInstruction = 19;
 
 		// ----- special character -----
-		public const int Assign               = 21;
-		public const int Colon                = 22;
-		public const int Comma                = 23;
-		public const int ConcatString         = 24;
-		public const int Div                  = 25;
-		public const int DivInteger           = 26;
-		public const int Dot                  = 27;
-		public const int TripleDot            = 28;
-		public const int DotAt                = 29;
-		public const int ExclamationMark      = 30;
-		public const int Minus                = 31;
-		public const int Plus                 = 32;
-		public const int Power                = 33;
-		public const int QuestionMark         = 34;
-		public const int Times                = 35;
-		public const int OpenCurlyBrace       = 36;
-		public const int CloseCurlyBrace      = 37;
-		public const int OpenParenthesis      = 38;
-		public const int CloseParenthesis     = 39;
-		public const int GreaterThan          = 40;
-		public const int LessThan             = 41;
-		public const int NotEqual             = 42;
-		public const int GreaterEqual         = 43;
-		public const int LessEqual            = 44;
-		public const int ShiftLeft            = 45;
-		public const int ShiftRight           = 46;
-		public const int PlusAssign           = 47;
-		public const int PowerAssign          = 48;
-		public const int MinusAssign          = 49;
-		public const int TimesAssign          = 50;
-		public const int DivAssign            = 51;
-		public const int DivIntegerAssign     = 52;
-		public const int ShiftLeftAssign      = 53;
-		public const int ShiftRightAssign     = 54;
-		public const int ConcatStringAssign   = 55;
-		public const int ColonAssign          = 56;
+		public const int Assign               = 20;
+		public const int Colon                = 21;
+		public const int Comma                = 22;
+		public const int ConcatString         = 23;
+		public const int Div                  = 24;
+		public const int DivInteger           = 25;
+		public const int Dot                  = 26;
+		public const int TripleDot            = 27;
+		public const int DotAt                = 28;
+		public const int ExclamationMark      = 29;
+		public const int Minus                = 30;
+		public const int Plus                 = 31;
+		public const int Power                = 32;
+		public const int QuestionMark         = 33;
+		public const int Times                = 34;
+		public const int OpenCurlyBrace       = 35;
+		public const int CloseCurlyBrace      = 36;
+		public const int OpenParenthesis      = 37;
+		public const int CloseParenthesis     = 38;
+		public const int GreaterThan          = 39;
+		public const int LessThan             = 40;
+		public const int NotEqual             = 41;
+		public const int GreaterEqual         = 42;
+		public const int LessEqual            = 43;
+		public const int ShiftLeft            = 44;
+		public const int ShiftRight           = 45;
+		public const int PlusAssign           = 46;
+		public const int PowerAssign          = 47;
+		public const int MinusAssign          = 48;
+		public const int TimesAssign          = 49;
+		public const int DivAssign            = 50;
+		public const int DivIntegerAssign     = 51;
+		public const int ShiftLeftAssign      = 52;
+		public const int ShiftRightAssign     = 53;
+		public const int ConcatStringAssign   = 54;
+		public const int ColonAssign          = 55;
 
 		// ----- keywords -----
-		public const int AddHandler           = 57;
-		public const int AddressOf            = 58;
-		public const int Aggregate            = 59;
-		public const int Alias                = 60;
-		public const int And                  = 61;
-		public const int AndAlso              = 62;
-		public const int Ansi                 = 63;
-		public const int As                   = 64;
-		public const int Ascending            = 65;
-		public const int Assembly             = 66;
-		public const int Auto                 = 67;
-		public const int Binary               = 68;
-		public const int Boolean              = 69;
-		public const int ByRef                = 70;
-		public const int By                   = 71;
-		public const int Byte                 = 72;
-		public const int ByVal                = 73;
-		public const int Call                 = 74;
-		public const int Case                 = 75;
-		public const int Catch                = 76;
-		public const int CBool                = 77;
-		public const int CByte                = 78;
-		public const int CChar                = 79;
-		public const int CDate                = 80;
-		public const int CDbl                 = 81;
-		public const int CDec                 = 82;
-		public const int Char                 = 83;
-		public const int CInt                 = 84;
-		public const int Class                = 85;
-		public const int CLng                 = 86;
-		public const int CObj                 = 87;
-		public const int Compare              = 88;
-		public const int Const                = 89;
-		public const int Continue             = 90;
-		public const int CSByte               = 91;
-		public const int CShort               = 92;
-		public const int CSng                 = 93;
-		public const int CStr                 = 94;
-		public const int CType                = 95;
-		public const int CUInt                = 96;
-		public const int CULng                = 97;
-		public const int CUShort              = 98;
-		public const int Custom               = 99;
-		public const int Date                 = 100;
-		public const int Decimal              = 101;
-		public const int Declare              = 102;
-		public const int Default              = 103;
-		public const int Delegate             = 104;
-		public const int Descending           = 105;
-		public const int Dim                  = 106;
-		public const int DirectCast           = 107;
-		public const int Distinct             = 108;
-		public const int Do                   = 109;
-		public const int Double               = 110;
-		public const int Each                 = 111;
-		public const int Else                 = 112;
-		public const int ElseIf               = 113;
-		public const int End                  = 114;
-		public const int EndIf                = 115;
-		public const int Enum                 = 116;
-		new public const int Equals               = 117;
-		public const int Erase                = 118;
-		public const int Error                = 119;
-		public const int Event                = 120;
-		public const int Exit                 = 121;
-		public const int Explicit             = 122;
-		public const int False                = 123;
-		public const int Finally              = 124;
-		public const int For                  = 125;
-		public const int Friend               = 126;
-		public const int From                 = 127;
-		public const int Function             = 128;
-		public const int Get                  = 129;
-		new public const int GetType              = 130;
-		public const int Global               = 131;
-		public const int GoSub                = 132;
-		public const int GoTo                 = 133;
-		public const int Group                = 134;
-		public const int Handles              = 135;
-		public const int If                   = 136;
-		public const int Implements           = 137;
-		public const int Imports              = 138;
-		public const int In                   = 139;
-		public const int Infer                = 140;
-		public const int Inherits             = 141;
-		public const int Integer              = 142;
-		public const int Interface            = 143;
-		public const int Into                 = 144;
-		public const int Is                   = 145;
-		public const int IsNot                = 146;
-		public const int Join                 = 147;
-		public const int Key                  = 148;
-		public const int Let                  = 149;
-		public const int Lib                  = 150;
-		public const int Like                 = 151;
-		public const int Long                 = 152;
-		public const int Loop                 = 153;
-		public const int Me                   = 154;
-		public const int Mod                  = 155;
-		public const int Module               = 156;
-		public const int MustInherit          = 157;
-		public const int MustOverride         = 158;
-		public const int MyBase               = 159;
-		public const int MyClass              = 160;
-		public const int Namespace            = 161;
-		public const int Narrowing            = 162;
-		public const int New                  = 163;
-		public const int Next                 = 164;
-		public const int Not                  = 165;
-		public const int Nothing              = 166;
-		public const int NotInheritable       = 167;
-		public const int NotOverridable       = 168;
-		public const int Object               = 169;
-		public const int Of                   = 170;
-		public const int Off                  = 171;
-		public const int On                   = 172;
-		public const int Operator             = 173;
-		public const int Option               = 174;
-		public const int Optional             = 175;
-		public const int Or                   = 176;
-		public const int Order                = 177;
-		public const int OrElse               = 178;
-		public const int Out                  = 179;
-		public const int Overloads            = 180;
-		public const int Overridable          = 181;
-		public const int Overrides            = 182;
-		public const int ParamArray           = 183;
-		public const int Partial              = 184;
-		public const int Preserve             = 185;
-		public const int Private              = 186;
-		public const int Property             = 187;
-		public const int Protected            = 188;
-		public const int Public               = 189;
-		public const int RaiseEvent           = 190;
-		public const int ReadOnly             = 191;
-		public const int ReDim                = 192;
-		public const int Rem                  = 193;
-		public const int RemoveHandler        = 194;
-		public const int Resume               = 195;
-		public const int Return               = 196;
-		public const int SByte                = 197;
-		public const int Select               = 198;
-		public const int Set                  = 199;
-		public const int Shadows              = 200;
-		public const int Shared               = 201;
-		public const int Short                = 202;
-		public const int Single               = 203;
-		public const int Skip                 = 204;
-		public const int Static               = 205;
-		public const int Step                 = 206;
-		public const int Stop                 = 207;
-		public const int Strict               = 208;
-		public const int String               = 209;
-		public const int Structure            = 210;
-		public const int Sub                  = 211;
-		public const int SyncLock             = 212;
-		public const int Take                 = 213;
-		public const int Text                 = 214;
-		public const int Then                 = 215;
-		public const int Throw                = 216;
-		public const int To                   = 217;
-		public const int True                 = 218;
-		public const int Try                  = 219;
-		public const int TryCast              = 220;
-		public const int TypeOf               = 221;
-		public const int UInteger             = 222;
-		public const int ULong                = 223;
-		public const int Unicode              = 224;
-		public const int Until                = 225;
-		public const int UShort               = 226;
-		public const int Using                = 227;
-		public const int Variant              = 228;
-		public const int Wend                 = 229;
-		public const int When                 = 230;
-		public const int Where                = 231;
-		public const int While                = 232;
-		public const int Widening             = 233;
-		public const int With                 = 234;
-		public const int WithEvents           = 235;
-		public const int WriteOnly            = 236;
-		public const int Xor                  = 237;
-		public const int GetXmlNamespace      = 238;
+		public const int AddHandler           = 56;
+		public const int AddressOf            = 57;
+		public const int Aggregate            = 58;
+		public const int Alias                = 59;
+		public const int And                  = 60;
+		public const int AndAlso              = 61;
+		public const int Ansi                 = 62;
+		public const int As                   = 63;
+		public const int Ascending            = 64;
+		public const int Assembly             = 65;
+		public const int Auto                 = 66;
+		public const int Binary               = 67;
+		public const int Boolean              = 68;
+		public const int ByRef                = 69;
+		public const int By                   = 70;
+		public const int Byte                 = 71;
+		public const int ByVal                = 72;
+		public const int Call                 = 73;
+		public const int Case                 = 74;
+		public const int Catch                = 75;
+		public const int CBool                = 76;
+		public const int CByte                = 77;
+		public const int CChar                = 78;
+		public const int CDate                = 79;
+		public const int CDbl                 = 80;
+		public const int CDec                 = 81;
+		public const int Char                 = 82;
+		public const int CInt                 = 83;
+		public const int Class                = 84;
+		public const int CLng                 = 85;
+		public const int CObj                 = 86;
+		public const int Compare              = 87;
+		public const int Const                = 88;
+		public const int Continue             = 89;
+		public const int CSByte               = 90;
+		public const int CShort               = 91;
+		public const int CSng                 = 92;
+		public const int CStr                 = 93;
+		public const int CType                = 94;
+		public const int CUInt                = 95;
+		public const int CULng                = 96;
+		public const int CUShort              = 97;
+		public const int Custom               = 98;
+		public const int Date                 = 99;
+		public const int Decimal              = 100;
+		public const int Declare              = 101;
+		public const int Default              = 102;
+		public const int Delegate             = 103;
+		public const int Descending           = 104;
+		public const int Dim                  = 105;
+		public const int DirectCast           = 106;
+		public const int Distinct             = 107;
+		public const int Do                   = 108;
+		public const int Double               = 109;
+		public const int Each                 = 110;
+		public const int Else                 = 111;
+		public const int ElseIf               = 112;
+		public const int End                  = 113;
+		public const int EndIf                = 114;
+		public const int Enum                 = 115;
+		new public const int Equals               = 116;
+		public const int Erase                = 117;
+		public const int Error                = 118;
+		public const int Event                = 119;
+		public const int Exit                 = 120;
+		public const int Explicit             = 121;
+		public const int False                = 122;
+		public const int Finally              = 123;
+		public const int For                  = 124;
+		public const int Friend               = 125;
+		public const int From                 = 126;
+		public const int Function             = 127;
+		public const int Get                  = 128;
+		new public const int GetType              = 129;
+		public const int Global               = 130;
+		public const int GoSub                = 131;
+		public const int GoTo                 = 132;
+		public const int Group                = 133;
+		public const int Handles              = 134;
+		public const int If                   = 135;
+		public const int Implements           = 136;
+		public const int Imports              = 137;
+		public const int In                   = 138;
+		public const int Infer                = 139;
+		public const int Inherits             = 140;
+		public const int Integer              = 141;
+		public const int Interface            = 142;
+		public const int Into                 = 143;
+		public const int Is                   = 144;
+		public const int IsNot                = 145;
+		public const int Join                 = 146;
+		public const int Key                  = 147;
+		public const int Let                  = 148;
+		public const int Lib                  = 149;
+		public const int Like                 = 150;
+		public const int Long                 = 151;
+		public const int Loop                 = 152;
+		public const int Me                   = 153;
+		public const int Mod                  = 154;
+		public const int Module               = 155;
+		public const int MustInherit          = 156;
+		public const int MustOverride         = 157;
+		public const int MyBase               = 158;
+		public const int MyClass              = 159;
+		public const int Namespace            = 160;
+		public const int Narrowing            = 161;
+		public const int New                  = 162;
+		public const int Next                 = 163;
+		public const int Not                  = 164;
+		public const int Nothing              = 165;
+		public const int NotInheritable       = 166;
+		public const int NotOverridable       = 167;
+		public const int Object               = 168;
+		public const int Of                   = 169;
+		public const int Off                  = 170;
+		public const int On                   = 171;
+		public const int Operator             = 172;
+		public const int Option               = 173;
+		public const int Optional             = 174;
+		public const int Or                   = 175;
+		public const int Order                = 176;
+		public const int OrElse               = 177;
+		public const int Out                  = 178;
+		public const int Overloads            = 179;
+		public const int Overridable          = 180;
+		public const int Overrides            = 181;
+		public const int ParamArray           = 182;
+		public const int Partial              = 183;
+		public const int Preserve             = 184;
+		public const int Private              = 185;
+		public const int Property             = 186;
+		public const int Protected            = 187;
+		public const int Public               = 188;
+		public const int RaiseEvent           = 189;
+		public const int ReadOnly             = 190;
+		public const int ReDim                = 191;
+		public const int Rem                  = 192;
+		public const int RemoveHandler        = 193;
+		public const int Resume               = 194;
+		public const int Return               = 195;
+		public const int SByte                = 196;
+		public const int Select               = 197;
+		public const int Set                  = 198;
+		public const int Shadows              = 199;
+		public const int Shared               = 200;
+		public const int Short                = 201;
+		public const int Single               = 202;
+		public const int Skip                 = 203;
+		public const int Static               = 204;
+		public const int Step                 = 205;
+		public const int Stop                 = 206;
+		public const int Strict               = 207;
+		public const int String               = 208;
+		public const int Structure            = 209;
+		public const int Sub                  = 210;
+		public const int SyncLock             = 211;
+		public const int Take                 = 212;
+		public const int Text                 = 213;
+		public const int Then                 = 214;
+		public const int Throw                = 215;
+		public const int To                   = 216;
+		public const int True                 = 217;
+		public const int Try                  = 218;
+		public const int TryCast              = 219;
+		public const int TypeOf               = 220;
+		public const int UInteger             = 221;
+		public const int ULong                = 222;
+		public const int Unicode              = 223;
+		public const int Until                = 224;
+		public const int UShort               = 225;
+		public const int Using                = 226;
+		public const int Variant              = 227;
+		public const int Wend                 = 228;
+		public const int When                 = 229;
+		public const int Where                = 230;
+		public const int While                = 231;
+		public const int Widening             = 232;
+		public const int With                 = 233;
+		public const int WithEvents           = 234;
+		public const int WriteOnly            = 235;
+		public const int Xor                  = 236;
+		public const int GetXmlNamespace      = 237;
 
-		public const int MaxToken = 239;
+		public const int MaxToken = 238;
 		static BitArray NewSet(params int[] values)
 		{
 			BitArray bitArray = new BitArray(MaxToken);
@@ -290,8 +289,7 @@ namespace ICSharpCode.NRefactory.Parser.VB
 			"<XmlContent>",
 			"<XmlComment>",
 			"<XmlCData>",
-			"<XmlProcessingInstructionStart>",
-			"<XmlProcessingInstructionEnd>",
+			"<XmlProcessingInstruction>",
 			// ----- special character -----
 			"=",
 			":",

src/Libraries/NRefactory/Project/Src/Parser/VBNet/Experimental/ExpressionFinder.atg

@@ -31,8 +31,7 @@ TOKENS
 	XmlContent
 	XmlComment
 	XmlCData
-	XmlProcessingInstructionStart
-	XmlProcessingInstructionEnd
+	XmlProcessingInstruction
 
 	/* ----- special character ----- */
 	"="
@@ -651,7 +650,7 @@ XmlLiteral
     (.OnEachPossiblePath: nextTokenIsPotentialStartOfXmlMode = true; .)
 =
     (. PushContext(Context.Xml, t); .)
-    { XmlComment [ XmlContent ] | XmlProcessingInstruction [ XmlContent ] } XmlElement { XmlComment [ XmlContent ] }
+    { ( XmlComment | XmlProcessingInstruction ) [ XmlContent ] } XmlElement { XmlComment [ XmlContent ] }
     (. PopContext(); .)
 .
 
@@ -659,10 +658,6 @@ XmlElement =
 	XmlOpenTag { ANY | XmlEmbeddedExpression } ( XmlCloseTagEmptyElement | XmlCloseTag { ANY | XmlEmbeddedExpression | XmlElement } XmlOpenEndTag { ANY | XmlEmbeddedExpression } XmlCloseTag )
 .
 
-XmlProcessingInstruction =
-	XmlProcessingInstructionStart Identifier { Identifier [ "=" LiteralString ] } XmlProcessingInstructionEnd
-.
-
 XmlEmbeddedExpression =
 	XmlStartInlineVB Expression XmlEndInlineVB
 .

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

@@ -355,8 +355,7 @@ namespace DefaultNamespace
 			
 			CheckHead(lexer);
 			
-			CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.XmlProcessingInstructionStart, Tokens.Identifier,
-			            Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlProcessingInstructionEnd, Tokens.XmlContent,
+			CheckTokens(lexer, Tokens.Dim, Tokens.Identifier, Tokens.Assign, Tokens.XmlProcessingInstruction, Tokens.XmlContent,
 			            Tokens.XmlOpenTag, Tokens.Identifier, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlOpenTag, Tokens.Identifier,
 			            Tokens.Identifier, Tokens.Assign, Tokens.LiteralString, Tokens.XmlCloseTag, Tokens.XmlContent, Tokens.XmlStartInlineVB,
 			            Tokens.From, Tokens.Identifier, Tokens.In, Tokens.Identifier, Tokens.Where, Tokens.Identifier, Tokens.Dot,

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

@@ -30,8 +30,7 @@ TOKENS
 	XmlContent
 	XmlComment
 	XmlCData
-	XmlProcessingInstructionStart
-	XmlProcessingInstructionEnd
+	XmlProcessingInstruction
 
 	/* ----- special character ----- */
 	"="

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

@@ -1251,6 +1251,58 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return withStatement.Body.AcceptVisitor(this, data);
 		}
 		
+		public virtual object VisitXmlAttribute(XmlAttribute xmlAttribute, object data) {
+			Debug.Assert((xmlAttribute != null));
+			Debug.Assert((xmlAttribute.ExpressionValue != null));
+			return xmlAttribute.ExpressionValue.AcceptVisitor(this, data);
+		}
+		
+		public virtual object VisitXmlCommentExpression(XmlCommentExpression xmlCommentExpression, object data) {
+			Debug.Assert((xmlCommentExpression != null));
+			return null;
+		}
+		
+		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+			Debug.Assert((xmlContentExpression != null));
+			return null;
+		}
+		
+		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+			Debug.Assert((xmlElementExpression != null));
+			Debug.Assert((xmlElementExpression.Content != null));
+			Debug.Assert((xmlElementExpression.NameExpression != null));
+			Debug.Assert((xmlElementExpression.Attributes != null));
+			xmlElementExpression.Content.AcceptVisitor(this, data);
+			xmlElementExpression.NameExpression.AcceptVisitor(this, data);
+			foreach (XmlExpression o in xmlElementExpression.Attributes) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			return null;
+		}
+		
+		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+			Debug.Assert((xmlEmbeddedExpression != null));
+			Debug.Assert((xmlEmbeddedExpression.InlineVBExpression != null));
+			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));
+			return xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
+		}
+		
 		public virtual object VisitYieldStatement(YieldStatement yieldStatement, object data) {
 			Debug.Assert((yieldStatement != null));
 			Debug.Assert((yieldStatement.Statement != null));

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

@@ -2244,6 +2244,85 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitXmlAttribute(XmlAttribute xmlAttribute, object data) {
+			Debug.Assert((xmlAttribute != null));
+			Debug.Assert((xmlAttribute.ExpressionValue != null));
+			nodeStack.Push(xmlAttribute.ExpressionValue);
+			xmlAttribute.ExpressionValue.AcceptVisitor(this, data);
+			xmlAttribute.ExpressionValue = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
+		public virtual object VisitXmlCommentExpression(XmlCommentExpression xmlCommentExpression, object data) {
+			Debug.Assert((xmlCommentExpression != null));
+			return null;
+		}
+		
+		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+			Debug.Assert((xmlContentExpression != null));
+			return null;
+		}
+		
+		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+			Debug.Assert((xmlElementExpression != null));
+			Debug.Assert((xmlElementExpression.Content != null));
+			Debug.Assert((xmlElementExpression.NameExpression != null));
+			Debug.Assert((xmlElementExpression.Attributes != null));
+			nodeStack.Push(xmlElementExpression.Content);
+			xmlElementExpression.Content.AcceptVisitor(this, data);
+			xmlElementExpression.Content = ((Expression)(nodeStack.Pop()));
+			nodeStack.Push(xmlElementExpression.NameExpression);
+			xmlElementExpression.NameExpression.AcceptVisitor(this, data);
+			xmlElementExpression.NameExpression = ((Expression)(nodeStack.Pop()));
+			for (int i = 0; i < xmlElementExpression.Attributes.Count; i++) {
+				XmlExpression o = xmlElementExpression.Attributes[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (XmlExpression)nodeStack.Pop();
+				if (o == null)
+					xmlElementExpression.Attributes.RemoveAt(i--);
+				else
+					xmlElementExpression.Attributes[i] = o;
+			}
+			return null;
+		}
+		
+		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+			Debug.Assert((xmlEmbeddedExpression != null));
+			Debug.Assert((xmlEmbeddedExpression.InlineVBExpression != null));
+			nodeStack.Push(xmlEmbeddedExpression.InlineVBExpression);
+			xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
+			xmlEmbeddedExpression.InlineVBExpression = ((Expression)(nodeStack.Pop()));
+			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));
+			nodeStack.Push(xmlMemberAccessExpression.TargetObject);
+			xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
+			xmlMemberAccessExpression.TargetObject = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
 		public virtual object VisitYieldStatement(YieldStatement yieldStatement, object data) {
 			Debug.Assert((yieldStatement != null));
 			Debug.Assert((yieldStatement.Statement != null));

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

@@ -892,6 +892,55 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return result;
 		}
 		
+		public sealed override object VisitXmlAttribute(XmlAttribute xmlAttribute, object data) {
+			this.BeginVisit(xmlAttribute);
+			object result = this.TrackedVisitXmlAttribute(xmlAttribute, data);
+			this.EndVisit(xmlAttribute);
+			return result;
+		}
+		
+		public sealed override object VisitXmlCommentExpression(XmlCommentExpression xmlCommentExpression, object data) {
+			this.BeginVisit(xmlCommentExpression);
+			object result = this.TrackedVisitXmlCommentExpression(xmlCommentExpression, data);
+			this.EndVisit(xmlCommentExpression);
+			return result;
+		}
+		
+		public sealed override object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+			this.BeginVisit(xmlContentExpression);
+			object result = this.TrackedVisitXmlContentExpression(xmlContentExpression, data);
+			this.EndVisit(xmlContentExpression);
+			return result;
+		}
+		
+		public sealed override object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+			this.BeginVisit(xmlElementExpression);
+			object result = this.TrackedVisitXmlElementExpression(xmlElementExpression, data);
+			this.EndVisit(xmlElementExpression);
+			return result;
+		}
+		
+		public sealed override object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+			this.BeginVisit(xmlEmbeddedExpression);
+			object result = this.TrackedVisitXmlEmbeddedExpression(xmlEmbeddedExpression, data);
+			this.EndVisit(xmlEmbeddedExpression);
+			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);
+			this.EndVisit(xmlMemberAccessExpression);
+			return result;
+		}
+		
 		public sealed override object VisitYieldStatement(YieldStatement yieldStatement, object data) {
 			this.BeginVisit(yieldStatement);
 			object result = this.TrackedVisitYieldStatement(yieldStatement, data);
@@ -1391,6 +1440,34 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return base.VisitWithStatement(withStatement, data);
 		}
 		
+		public virtual object TrackedVisitXmlAttribute(XmlAttribute xmlAttribute, object data) {
+			return base.VisitXmlAttribute(xmlAttribute, data);
+		}
+		
+		public virtual object TrackedVisitXmlCommentExpression(XmlCommentExpression xmlCommentExpression, object data) {
+			return base.VisitXmlCommentExpression(xmlCommentExpression, data);
+		}
+		
+		public virtual object TrackedVisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+			return base.VisitXmlContentExpression(xmlContentExpression, data);
+		}
+		
+		public virtual object TrackedVisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+			return base.VisitXmlElementExpression(xmlElementExpression, data);
+		}
+		
+		public virtual object TrackedVisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+			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);
+		}
+		
 		public virtual object TrackedVisitYieldStatement(YieldStatement yieldStatement, object data) {
 			return base.VisitYieldStatement(yieldStatement, data);
 		}

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

@@ -510,6 +510,34 @@ namespace ICSharpCode.NRefactory.Visitors {
 			throw new global::System.NotImplementedException("WithStatement");
 		}
 		
+		public virtual object VisitXmlAttribute(XmlAttribute xmlAttribute, object data) {
+			throw new global::System.NotImplementedException("XmlAttribute");
+		}
+		
+		public virtual object VisitXmlCommentExpression(XmlCommentExpression xmlCommentExpression, object data) {
+			throw new global::System.NotImplementedException("XmlCommentExpression");
+		}
+		
+		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+			throw new global::System.NotImplementedException("XmlContentExpression");
+		}
+		
+		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+			throw new global::System.NotImplementedException("XmlElementExpression");
+		}
+		
+		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+			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");
+		}
+		
 		public virtual object VisitYieldStatement(YieldStatement yieldStatement, object data) {
 			throw new global::System.NotImplementedException("YieldStatement");
 		}