diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
index 43f8a2d119..6fd33cca4f 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
@@ -1,5 +1,5 @@
 
-//#line  1 "VBNET.ATG" 
+#line  1 "VBNET.ATG" 
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
@@ -26,7 +26,7 @@ partial class Parser : AbstractParser
 	const  bool   x            = false;
 	
 
-//#line  13 "VBNET.ATG" 
+#line  13 "VBNET.ATG" 
 
 
 /*
@@ -35,7 +35,7 @@ partial class Parser : AbstractParser
 
 	void VBNET() {
 
-//#line  263 "VBNET.ATG" 
+#line  263 "VBNET.ATG" 
 		lexer.NextToken(); // get the first token
 		compilationUnit = new CompilationUnit();
 		BlockStart(compilationUnit);
@@ -56,7 +56,7 @@ partial class Parser : AbstractParser
 			}
 		}
 		while (
-//#line  271 "VBNET.ATG" 
+#line  271 "VBNET.ATG" 
 IsGlobalAttrTarget()) {
 			GlobalAttributeSection();
 			while (la.kind == 1 || la.kind == 21) {
@@ -83,59 +83,59 @@ IsGlobalAttrTarget()) {
 
 	void OptionStmt() {
 
-//#line  276 "VBNET.ATG" 
+#line  276 "VBNET.ATG" 
 		INode node = null; bool val = true; 
 		Expect(173);
 
-//#line  277 "VBNET.ATG" 
+#line  277 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (la.kind == 121) {
 			lexer.NextToken();
 			if (la.kind == 170 || la.kind == 171) {
 				OptionValue(
-//#line  279 "VBNET.ATG" 
+#line  279 "VBNET.ATG" 
 ref val);
 			}
 
-//#line  280 "VBNET.ATG" 
+#line  280 "VBNET.ATG" 
 			node = new OptionDeclaration(OptionType.Explicit, val); 
 		} else if (la.kind == 207) {
 			lexer.NextToken();
 			if (la.kind == 170 || la.kind == 171) {
 				OptionValue(
-//#line  282 "VBNET.ATG" 
+#line  282 "VBNET.ATG" 
 ref val);
 			}
 
-//#line  283 "VBNET.ATG" 
+#line  283 "VBNET.ATG" 
 			node = new OptionDeclaration(OptionType.Strict, val); 
 		} else if (la.kind == 87) {
 			lexer.NextToken();
 			if (la.kind == 67) {
 				lexer.NextToken();
 
-//#line  285 "VBNET.ATG" 
+#line  285 "VBNET.ATG" 
 				node = new OptionDeclaration(OptionType.CompareBinary, val); 
 			} else if (la.kind == 213) {
 				lexer.NextToken();
 
-//#line  286 "VBNET.ATG" 
+#line  286 "VBNET.ATG" 
 				node = new OptionDeclaration(OptionType.CompareText, val); 
 			} else SynErr(241);
 		} else if (la.kind == 139) {
 			lexer.NextToken();
 			if (la.kind == 170 || la.kind == 171) {
 				OptionValue(
-//#line  289 "VBNET.ATG" 
+#line  289 "VBNET.ATG" 
 ref val);
 			}
 
-//#line  290 "VBNET.ATG" 
+#line  290 "VBNET.ATG" 
 			node = new OptionDeclaration(OptionType.Infer, val); 
 		} else SynErr(242);
 		EndOfStmt();
 
-//#line  294 "VBNET.ATG" 
+#line  294 "VBNET.ATG" 
 		if (node != null) {
 		node.StartLocation = startPos;
 		node.EndLocation   = t.Location;
@@ -146,33 +146,33 @@ ref val);
 
 	void ImportsStmt() {
 
-//#line  315 "VBNET.ATG" 
+#line  315 "VBNET.ATG" 
 		List<Using> usings = new List<Using>();
 		
 		Expect(137);
 
-//#line  319 "VBNET.ATG" 
+#line  319 "VBNET.ATG" 
 		Location startPos = t.Location;
 		Using u;
 		
 		ImportClause(
-//#line  322 "VBNET.ATG" 
+#line  322 "VBNET.ATG" 
 out u);
 
-//#line  322 "VBNET.ATG" 
+#line  322 "VBNET.ATG" 
 		if (u != null) { usings.Add(u); } 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			ImportClause(
-//#line  324 "VBNET.ATG" 
+#line  324 "VBNET.ATG" 
 out u);
 
-//#line  324 "VBNET.ATG" 
+#line  324 "VBNET.ATG" 
 			if (u != null) { usings.Add(u); } 
 		}
 		EndOfStmt();
 
-//#line  328 "VBNET.ATG" 
+#line  328 "VBNET.ATG" 
 		UsingDeclaration usingDeclaration = new UsingDeclaration(usings);
 		usingDeclaration.StartLocation = startPos;
 		usingDeclaration.EndLocation   = t.Location;
@@ -183,7 +183,7 @@ out u);
 	void GlobalAttributeSection() {
 		Expect(40);
 
-//#line  2823 "VBNET.ATG" 
+#line  2826 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (la.kind == 65) {
 			lexer.NextToken();
@@ -191,20 +191,20 @@ out u);
 			lexer.NextToken();
 		} else SynErr(243);
 
-//#line  2825 "VBNET.ATG" 
+#line  2828 "VBNET.ATG" 
 		string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
 		List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		Expect(21);
 		Attribute(
-//#line  2829 "VBNET.ATG" 
+#line  2832 "VBNET.ATG" 
 out attribute);
 
-//#line  2829 "VBNET.ATG" 
+#line  2832 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-//#line  2830 "VBNET.ATG" 
+#line  2833 "VBNET.ATG" 
 NotFinalComma()) {
 			if (la.kind == 22) {
 				lexer.NextToken();
@@ -216,10 +216,10 @@ NotFinalComma()) {
 				Expect(21);
 			}
 			Attribute(
-//#line  2830 "VBNET.ATG" 
+#line  2833 "VBNET.ATG" 
 out attribute);
 
-//#line  2830 "VBNET.ATG" 
+#line  2833 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 22) {
@@ -228,7 +228,7 @@ out attribute);
 		Expect(39);
 		EndOfStmt();
 
-//#line  2835 "VBNET.ATG" 
+#line  2838 "VBNET.ATG" 
 		AttributeSection section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -241,7 +241,7 @@ out attribute);
 
 	void NamespaceMemberDecl() {
 
-//#line  361 "VBNET.ATG" 
+#line  361 "VBNET.ATG" 
 		ModifierList m = new ModifierList();
 		AttributeSection section;
 		List<AttributeSection> attributes = new List<AttributeSection>();
@@ -250,14 +250,14 @@ out attribute);
 		if (la.kind == 160) {
 			lexer.NextToken();
 
-//#line  368 "VBNET.ATG" 
+#line  368 "VBNET.ATG" 
 			Location startPos = t.Location;
 			
 			Qualident(
-//#line  370 "VBNET.ATG" 
+#line  370 "VBNET.ATG" 
 out qualident);
 
-//#line  372 "VBNET.ATG" 
+#line  372 "VBNET.ATG" 
 			INode node =  new NamespaceDeclaration(qualident);
 			node.StartLocation = startPos;
 			AddChild(node);
@@ -266,67 +266,67 @@ out qualident);
 			EndOfStmt();
 			NamespaceBody();
 
-//#line  380 "VBNET.ATG" 
+#line  380 "VBNET.ATG" 
 			node.EndLocation = t.Location;
 			BlockEnd();
 			
 		} else if (StartOf(2)) {
 			while (la.kind == 40) {
 				AttributeSection(
-//#line  384 "VBNET.ATG" 
+#line  384 "VBNET.ATG" 
 out section);
 
-//#line  384 "VBNET.ATG" 
+#line  384 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(3)) {
 				TypeModifier(
-//#line  385 "VBNET.ATG" 
+#line  385 "VBNET.ATG" 
 m);
 			}
 			NonModuleDeclaration(
-//#line  385 "VBNET.ATG" 
+#line  385 "VBNET.ATG" 
 m, attributes);
 		} else SynErr(245);
 	}
 
 	void OptionValue(
-//#line  302 "VBNET.ATG" 
+#line  302 "VBNET.ATG" 
 ref bool val) {
 		if (la.kind == 171) {
 			lexer.NextToken();
 
-//#line  304 "VBNET.ATG" 
+#line  304 "VBNET.ATG" 
 			val = true; 
 		} else if (la.kind == 170) {
 			lexer.NextToken();
 
-//#line  306 "VBNET.ATG" 
+#line  306 "VBNET.ATG" 
 			val = false; 
 		} else SynErr(246);
 	}
 
 	void ImportClause(
-//#line  335 "VBNET.ATG" 
+#line  335 "VBNET.ATG" 
 out Using u) {
 
-//#line  337 "VBNET.ATG" 
+#line  337 "VBNET.ATG" 
 		string qualident  = null;
 		TypeReference aliasedType = null;
 		u = null;
 		
 		if (StartOf(4)) {
 			Qualident(
-//#line  342 "VBNET.ATG" 
+#line  342 "VBNET.ATG" 
 out qualident);
 			if (la.kind == 20) {
 				lexer.NextToken();
 				TypeName(
-//#line  343 "VBNET.ATG" 
+#line  343 "VBNET.ATG" 
 out aliasedType);
 			}
 
-//#line  345 "VBNET.ATG" 
+#line  345 "VBNET.ATG" 
 			if (qualident != null && qualident.Length > 0) {
 			if (aliasedType != null) {
 				u = new Using(qualident, aliasedType);
@@ -337,64 +337,64 @@ out aliasedType);
 			
 		} else if (la.kind == 10) {
 
-//#line  353 "VBNET.ATG" 
+#line  353 "VBNET.ATG" 
 			string prefix = null; 
 			lexer.NextToken();
 			Identifier();
 
-//#line  354 "VBNET.ATG" 
+#line  354 "VBNET.ATG" 
 			prefix = t.val; 
 			Expect(20);
 			Expect(3);
 
-//#line  354 "VBNET.ATG" 
+#line  354 "VBNET.ATG" 
 			u = new Using(t.literalValue as string, prefix); 
 			Expect(11);
 		} else SynErr(247);
 	}
 
 	void Qualident(
-//#line  3623 "VBNET.ATG" 
+#line  3626 "VBNET.ATG" 
 out string qualident) {
 
-//#line  3625 "VBNET.ATG" 
+#line  3628 "VBNET.ATG" 
 		string name;
 		qualidentBuilder.Length = 0; 
 		
 		Identifier();
 
-//#line  3629 "VBNET.ATG" 
+#line  3632 "VBNET.ATG" 
 		qualidentBuilder.Append(t.val); 
 		while (
-//#line  3630 "VBNET.ATG" 
+#line  3633 "VBNET.ATG" 
 DotAndIdentOrKw()) {
 			Expect(26);
 			IdentifierOrKeyword(
-//#line  3630 "VBNET.ATG" 
+#line  3633 "VBNET.ATG" 
 out name);
 
-//#line  3630 "VBNET.ATG" 
+#line  3633 "VBNET.ATG" 
 			qualidentBuilder.Append('.'); qualidentBuilder.Append(name); 
 		}
 
-//#line  3632 "VBNET.ATG" 
+#line  3635 "VBNET.ATG" 
 		qualident = qualidentBuilder.ToString(); 
 	}
 
 	void TypeName(
-//#line  2694 "VBNET.ATG" 
+#line  2697 "VBNET.ATG" 
 out TypeReference typeref) {
 
-//#line  2695 "VBNET.ATG" 
+#line  2698 "VBNET.ATG" 
 		ArrayList rank = null; Location startLocation = la.Location; 
 		NonArrayTypeName(
-//#line  2697 "VBNET.ATG" 
+#line  2700 "VBNET.ATG" 
 out typeref, false);
 		ArrayTypeModifiers(
-//#line  2698 "VBNET.ATG" 
+#line  2701 "VBNET.ATG" 
 out rank);
 
-//#line  2700 "VBNET.ATG" 
+#line  2703 "VBNET.ATG" 
 		if (typeref != null) {
 		if (rank != null) {
 			typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
@@ -429,10 +429,10 @@ out rank);
 	}
 
 	void AttributeSection(
-//#line  2901 "VBNET.ATG" 
+#line  2904 "VBNET.ATG" 
 out AttributeSection section) {
 
-//#line  2903 "VBNET.ATG" 
+#line  2906 "VBNET.ATG" 
 		string attributeTarget = "";
 		List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
@@ -440,22 +440,22 @@ out AttributeSection section) {
 		
 		Expect(40);
 		if (
-//#line  2909 "VBNET.ATG" 
+#line  2912 "VBNET.ATG" 
 IsLocalAttrTarget()) {
 			if (la.kind == 119) {
 				lexer.NextToken();
 
-//#line  2910 "VBNET.ATG" 
+#line  2913 "VBNET.ATG" 
 				attributeTarget = "event";
 			} else if (la.kind == 195) {
 				lexer.NextToken();
 
-//#line  2911 "VBNET.ATG" 
+#line  2914 "VBNET.ATG" 
 				attributeTarget = "return";
 			} else {
 				Identifier();
 
-//#line  2914 "VBNET.ATG" 
+#line  2917 "VBNET.ATG" 
 				string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
 				if (val != "field"	|| val != "method" ||
 					val != "module" || val != "param"  ||
@@ -468,20 +468,20 @@ IsLocalAttrTarget()) {
 			Expect(21);
 		}
 		Attribute(
-//#line  2924 "VBNET.ATG" 
+#line  2927 "VBNET.ATG" 
 out attribute);
 
-//#line  2924 "VBNET.ATG" 
+#line  2927 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-//#line  2925 "VBNET.ATG" 
+#line  2928 "VBNET.ATG" 
 NotFinalComma()) {
 			Expect(22);
 			Attribute(
-//#line  2925 "VBNET.ATG" 
+#line  2928 "VBNET.ATG" 
 out attribute);
 
-//#line  2925 "VBNET.ATG" 
+#line  2928 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 22) {
@@ -489,7 +489,7 @@ out attribute);
 		}
 		Expect(39);
 
-//#line  2929 "VBNET.ATG" 
+#line  2932 "VBNET.ATG" 
 		section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -500,69 +500,69 @@ out attribute);
 	}
 
 	void TypeModifier(
-//#line  3708 "VBNET.ATG" 
+#line  3711 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 188: {
 			lexer.NextToken();
 
-//#line  3709 "VBNET.ATG" 
+#line  3712 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location); 
 			break;
 		}
 		case 187: {
 			lexer.NextToken();
 
-//#line  3710 "VBNET.ATG" 
+#line  3713 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location); 
 			break;
 		}
 		case 125: {
 			lexer.NextToken();
 
-//#line  3711 "VBNET.ATG" 
+#line  3714 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location); 
 			break;
 		}
 		case 185: {
 			lexer.NextToken();
 
-//#line  3712 "VBNET.ATG" 
+#line  3715 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location); 
 			break;
 		}
 		case 200: {
 			lexer.NextToken();
 
-//#line  3713 "VBNET.ATG" 
+#line  3716 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location); 
 			break;
 		}
 		case 199: {
 			lexer.NextToken();
 
-//#line  3714 "VBNET.ATG" 
+#line  3717 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location); 
 			break;
 		}
 		case 156: {
 			lexer.NextToken();
 
-//#line  3715 "VBNET.ATG" 
+#line  3718 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location); 
 			break;
 		}
 		case 166: {
 			lexer.NextToken();
 
-//#line  3716 "VBNET.ATG" 
+#line  3719 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location); 
 			break;
 		}
 		case 183: {
 			lexer.NextToken();
 
-//#line  3717 "VBNET.ATG" 
+#line  3720 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location); 
 			break;
 		}
@@ -571,21 +571,21 @@ ModifierList m) {
 	}
 
 	void NonModuleDeclaration(
-//#line  455 "VBNET.ATG" 
+#line  455 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 
-//#line  457 "VBNET.ATG" 
+#line  457 "VBNET.ATG" 
 		TypeReference typeRef = null;
 		List<TypeReference> baseInterfaces = null;
 		
 		switch (la.kind) {
 		case 84: {
 
-//#line  460 "VBNET.ATG" 
+#line  460 "VBNET.ATG" 
 			m.Check(Modifiers.Classes); 
 			lexer.NextToken();
 
-//#line  463 "VBNET.ATG" 
+#line  463 "VBNET.ATG" 
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = t.Location;
 			AddChild(newType);
@@ -595,42 +595,42 @@ ModifierList m, List<AttributeSection> attributes) {
 			
 			Identifier();
 
-//#line  470 "VBNET.ATG" 
+#line  470 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-//#line  471 "VBNET.ATG" 
+#line  471 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-//#line  473 "VBNET.ATG" 
+#line  473 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			if (la.kind == 140) {
 				ClassBaseType(
-//#line  474 "VBNET.ATG" 
+#line  474 "VBNET.ATG" 
 out typeRef);
 
-//#line  474 "VBNET.ATG" 
+#line  474 "VBNET.ATG" 
 				SafeAdd(newType, newType.BaseTypes, typeRef); 
 			}
 			while (la.kind == 136) {
 				TypeImplementsClause(
-//#line  475 "VBNET.ATG" 
+#line  475 "VBNET.ATG" 
 out baseInterfaces);
 
-//#line  475 "VBNET.ATG" 
+#line  475 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces); 
 			}
 			ClassBody(
-//#line  476 "VBNET.ATG" 
+#line  476 "VBNET.ATG" 
 newType);
 			Expect(113);
 			Expect(84);
 
-//#line  477 "VBNET.ATG" 
+#line  477 "VBNET.ATG" 
 			newType.EndLocation = t.EndLocation; 
 			EndOfStmt();
 
-//#line  480 "VBNET.ATG" 
+#line  480 "VBNET.ATG" 
 			BlockEnd();
 			
 			break;
@@ -638,7 +638,7 @@ newType);
 		case 155: {
 			lexer.NextToken();
 
-//#line  484 "VBNET.ATG" 
+#line  484 "VBNET.ATG" 
 			m.Check(Modifiers.VBModules);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			AddChild(newType);
@@ -648,17 +648,17 @@ newType);
 			
 			Identifier();
 
-//#line  491 "VBNET.ATG" 
+#line  491 "VBNET.ATG" 
 			newType.Name = t.val; 
 			EndOfStmt();
 
-//#line  493 "VBNET.ATG" 
+#line  493 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			ModuleBody(
-//#line  494 "VBNET.ATG" 
+#line  494 "VBNET.ATG" 
 newType);
 
-//#line  496 "VBNET.ATG" 
+#line  496 "VBNET.ATG" 
 			BlockEnd();
 			
 			break;
@@ -666,7 +666,7 @@ newType);
 		case 209: {
 			lexer.NextToken();
 
-//#line  500 "VBNET.ATG" 
+#line  500 "VBNET.ATG" 
 			m.Check(Modifiers.VBStructures);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			AddChild(newType);
@@ -676,28 +676,28 @@ newType);
 			
 			Identifier();
 
-//#line  507 "VBNET.ATG" 
+#line  507 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-//#line  508 "VBNET.ATG" 
+#line  508 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-//#line  510 "VBNET.ATG" 
+#line  510 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			while (la.kind == 136) {
 				TypeImplementsClause(
-//#line  511 "VBNET.ATG" 
+#line  511 "VBNET.ATG" 
 out baseInterfaces);
 
-//#line  511 "VBNET.ATG" 
+#line  511 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces);
 			}
 			StructureBody(
-//#line  512 "VBNET.ATG" 
+#line  512 "VBNET.ATG" 
 newType);
 
-//#line  514 "VBNET.ATG" 
+#line  514 "VBNET.ATG" 
 			BlockEnd();
 			
 			break;
@@ -705,7 +705,7 @@ newType);
 		case 115: {
 			lexer.NextToken();
 
-//#line  519 "VBNET.ATG" 
+#line  519 "VBNET.ATG" 
 			m.Check(Modifiers.VBEnums);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -716,26 +716,26 @@ newType);
 			
 			Identifier();
 
-//#line  527 "VBNET.ATG" 
+#line  527 "VBNET.ATG" 
 			newType.Name = t.val; 
 			if (la.kind == 63) {
 				lexer.NextToken();
 				NonArrayTypeName(
-//#line  528 "VBNET.ATG" 
+#line  528 "VBNET.ATG" 
 out typeRef, false);
 
-//#line  528 "VBNET.ATG" 
+#line  528 "VBNET.ATG" 
 				SafeAdd(newType, newType.BaseTypes, typeRef); 
 			}
 			EndOfStmt();
 
-//#line  530 "VBNET.ATG" 
+#line  530 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			EnumBody(
-//#line  531 "VBNET.ATG" 
+#line  531 "VBNET.ATG" 
 newType);
 
-//#line  533 "VBNET.ATG" 
+#line  533 "VBNET.ATG" 
 			BlockEnd();
 			
 			break;
@@ -743,7 +743,7 @@ newType);
 		case 142: {
 			lexer.NextToken();
 
-//#line  538 "VBNET.ATG" 
+#line  538 "VBNET.ATG" 
 			m.Check(Modifiers.VBInterfacs);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -753,28 +753,28 @@ newType);
 			
 			Identifier();
 
-//#line  545 "VBNET.ATG" 
+#line  545 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-//#line  546 "VBNET.ATG" 
+#line  546 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-//#line  548 "VBNET.ATG" 
+#line  548 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			while (la.kind == 140) {
 				InterfaceBase(
-//#line  549 "VBNET.ATG" 
+#line  549 "VBNET.ATG" 
 out baseInterfaces);
 
-//#line  549 "VBNET.ATG" 
+#line  549 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces); 
 			}
 			InterfaceBody(
-//#line  550 "VBNET.ATG" 
+#line  550 "VBNET.ATG" 
 newType);
 
-//#line  552 "VBNET.ATG" 
+#line  552 "VBNET.ATG" 
 			BlockEnd();
 			
 			break;
@@ -782,7 +782,7 @@ newType);
 		case 103: {
 			lexer.NextToken();
 
-//#line  557 "VBNET.ATG" 
+#line  557 "VBNET.ATG" 
 			m.Check(Modifiers.VBDelegates);
 			DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes);
 			delegateDeclr.ReturnType = new TypeReference("System.Void", true);
@@ -793,63 +793,63 @@ newType);
 				lexer.NextToken();
 				Identifier();
 
-//#line  564 "VBNET.ATG" 
+#line  564 "VBNET.ATG" 
 				delegateDeclr.Name = t.val; 
 				TypeParameterList(
-//#line  565 "VBNET.ATG" 
+#line  565 "VBNET.ATG" 
 delegateDeclr.Templates);
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  566 "VBNET.ATG" 
+#line  566 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
 
-//#line  566 "VBNET.ATG" 
+#line  566 "VBNET.ATG" 
 					delegateDeclr.Parameters = p; 
 				}
 			} else if (la.kind == 127) {
 				lexer.NextToken();
 				Identifier();
 
-//#line  568 "VBNET.ATG" 
+#line  568 "VBNET.ATG" 
 				delegateDeclr.Name = t.val; 
 				TypeParameterList(
-//#line  569 "VBNET.ATG" 
+#line  569 "VBNET.ATG" 
 delegateDeclr.Templates);
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  570 "VBNET.ATG" 
+#line  570 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
 
-//#line  570 "VBNET.ATG" 
+#line  570 "VBNET.ATG" 
 					delegateDeclr.Parameters = p; 
 				}
 				if (la.kind == 63) {
 					lexer.NextToken();
 
-//#line  571 "VBNET.ATG" 
+#line  571 "VBNET.ATG" 
 					TypeReference type; 
 					TypeName(
-//#line  571 "VBNET.ATG" 
+#line  571 "VBNET.ATG" 
 out type);
 
-//#line  571 "VBNET.ATG" 
+#line  571 "VBNET.ATG" 
 					delegateDeclr.ReturnType = type; 
 				}
 			} else SynErr(250);
 
-//#line  573 "VBNET.ATG" 
+#line  573 "VBNET.ATG" 
 			delegateDeclr.EndLocation = t.EndLocation; 
 			EndOfStmt();
 
-//#line  576 "VBNET.ATG" 
+#line  576 "VBNET.ATG" 
 			AddChild(delegateDeclr);
 			
 			break;
@@ -859,31 +859,31 @@ out type);
 	}
 
 	void TypeParameterList(
-//#line  389 "VBNET.ATG" 
+#line  389 "VBNET.ATG" 
 List<TemplateDefinition> templates) {
 
-//#line  391 "VBNET.ATG" 
+#line  391 "VBNET.ATG" 
 		TemplateDefinition template;
 		
 		if (
-//#line  395 "VBNET.ATG" 
+#line  395 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			lexer.NextToken();
 			Expect(169);
 			TypeParameter(
-//#line  396 "VBNET.ATG" 
+#line  396 "VBNET.ATG" 
 out template);
 
-//#line  398 "VBNET.ATG" 
+#line  398 "VBNET.ATG" 
 			if (template != null) templates.Add(template);
 			
 			while (la.kind == 22) {
 				lexer.NextToken();
 				TypeParameter(
-//#line  401 "VBNET.ATG" 
+#line  401 "VBNET.ATG" 
 out template);
 
-//#line  403 "VBNET.ATG" 
+#line  403 "VBNET.ATG" 
 				if (template != null) templates.Add(template);
 				
 			}
@@ -892,35 +892,35 @@ out template);
 	}
 
 	void TypeParameter(
-//#line  411 "VBNET.ATG" 
+#line  411 "VBNET.ATG" 
 out TemplateDefinition template) {
 
-//#line  412 "VBNET.ATG" 
+#line  412 "VBNET.ATG" 
 		VarianceModifier modifier = VarianceModifier.Invariant; Location startLocation = la.Location; 
 		if (la.kind == 138 || la.kind == 178) {
 			if (la.kind == 138) {
 				lexer.NextToken();
 
-//#line  415 "VBNET.ATG" 
+#line  415 "VBNET.ATG" 
 				modifier = VarianceModifier.Contravariant; 
 			} else {
 				lexer.NextToken();
 
-//#line  415 "VBNET.ATG" 
+#line  415 "VBNET.ATG" 
 				modifier = VarianceModifier.Covariant; 
 			}
 		}
 		Identifier();
 
-//#line  415 "VBNET.ATG" 
+#line  415 "VBNET.ATG" 
 		template = new TemplateDefinition(t.val, null) { VarianceModifier = modifier }; 
 		if (la.kind == 63) {
 			TypeParameterConstraints(
-//#line  416 "VBNET.ATG" 
+#line  416 "VBNET.ATG" 
 template);
 		}
 
-//#line  419 "VBNET.ATG" 
+#line  419 "VBNET.ATG" 
 		if (template != null) {
 		template.StartLocation = startLocation;
 		template.EndLocation = t.EndLocation;
@@ -929,141 +929,141 @@ template);
 	}
 
 	void TypeParameterConstraints(
-//#line  427 "VBNET.ATG" 
+#line  427 "VBNET.ATG" 
 TemplateDefinition template) {
 
-//#line  429 "VBNET.ATG" 
+#line  429 "VBNET.ATG" 
 		TypeReference constraint;
 		
 		Expect(63);
 		if (la.kind == 35) {
 			lexer.NextToken();
 			TypeParameterConstraint(
-//#line  435 "VBNET.ATG" 
+#line  435 "VBNET.ATG" 
 out constraint);
 
-//#line  435 "VBNET.ATG" 
+#line  435 "VBNET.ATG" 
 			if (constraint != null) { template.Bases.Add(constraint); } 
 			while (la.kind == 22) {
 				lexer.NextToken();
 				TypeParameterConstraint(
-//#line  438 "VBNET.ATG" 
+#line  438 "VBNET.ATG" 
 out constraint);
 
-//#line  438 "VBNET.ATG" 
+#line  438 "VBNET.ATG" 
 				if (constraint != null) { template.Bases.Add(constraint); } 
 			}
 			Expect(36);
 		} else if (StartOf(7)) {
 			TypeParameterConstraint(
-//#line  441 "VBNET.ATG" 
+#line  441 "VBNET.ATG" 
 out constraint);
 
-//#line  441 "VBNET.ATG" 
+#line  441 "VBNET.ATG" 
 			if (constraint != null) { template.Bases.Add(constraint); } 
 		} else SynErr(252);
 	}
 
 	void TypeParameterConstraint(
-//#line  445 "VBNET.ATG" 
+#line  445 "VBNET.ATG" 
 out TypeReference constraint) {
 
-//#line  446 "VBNET.ATG" 
+#line  446 "VBNET.ATG" 
 		constraint = null; Location startLocation = la.Location; 
 		if (la.kind == 84) {
 			lexer.NextToken();
 
-//#line  448 "VBNET.ATG" 
+#line  448 "VBNET.ATG" 
 			constraint = TypeReference.ClassConstraint; 
 		} else if (la.kind == 209) {
 			lexer.NextToken();
 
-//#line  449 "VBNET.ATG" 
+#line  449 "VBNET.ATG" 
 			constraint = TypeReference.StructConstraint; 
 		} else if (la.kind == 162) {
 			lexer.NextToken();
 
-//#line  450 "VBNET.ATG" 
+#line  450 "VBNET.ATG" 
 			constraint = TypeReference.NewConstraint; 
 		} else if (StartOf(8)) {
 			TypeName(
-//#line  451 "VBNET.ATG" 
+#line  451 "VBNET.ATG" 
 out constraint);
 		} else SynErr(253);
 	}
 
 	void ClassBaseType(
-//#line  797 "VBNET.ATG" 
+#line  797 "VBNET.ATG" 
 out TypeReference typeRef) {
 
-//#line  799 "VBNET.ATG" 
+#line  799 "VBNET.ATG" 
 		typeRef = null;
 		
 		Expect(140);
 		TypeName(
-//#line  802 "VBNET.ATG" 
+#line  802 "VBNET.ATG" 
 out typeRef);
 		EndOfStmt();
 	}
 
 	void TypeImplementsClause(
-//#line  1617 "VBNET.ATG" 
+#line  1620 "VBNET.ATG" 
 out List<TypeReference> baseInterfaces) {
 
-//#line  1619 "VBNET.ATG" 
+#line  1622 "VBNET.ATG" 
 		baseInterfaces = new List<TypeReference>();
 		TypeReference type = null;
 		
 		Expect(136);
 		TypeName(
-//#line  1622 "VBNET.ATG" 
+#line  1625 "VBNET.ATG" 
 out type);
 
-//#line  1624 "VBNET.ATG" 
+#line  1627 "VBNET.ATG" 
 		if (type != null) baseInterfaces.Add(type);
 		
 		while (la.kind == 22) {
 			lexer.NextToken();
 			TypeName(
-//#line  1627 "VBNET.ATG" 
+#line  1630 "VBNET.ATG" 
 out type);
 
-//#line  1628 "VBNET.ATG" 
+#line  1631 "VBNET.ATG" 
 			if (type != null) baseInterfaces.Add(type); 
 		}
 		EndOfStmt();
 	}
 
 	void ClassBody(
-//#line  590 "VBNET.ATG" 
+#line  590 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-//#line  591 "VBNET.ATG" 
+#line  591 "VBNET.ATG" 
 		AttributeSection section; 
 		while (la.kind == 1 || la.kind == 21) {
 			EndOfStmt();
 		}
 		while (StartOf(9)) {
 
-//#line  594 "VBNET.ATG" 
+#line  594 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 40) {
 				AttributeSection(
-//#line  597 "VBNET.ATG" 
+#line  597 "VBNET.ATG" 
 out section);
 
-//#line  597 "VBNET.ATG" 
+#line  597 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(10)) {
 				MemberModifier(
-//#line  598 "VBNET.ATG" 
+#line  598 "VBNET.ATG" 
 m);
 			}
 			ClassMemberDecl(
-//#line  599 "VBNET.ATG" 
+#line  599 "VBNET.ATG" 
 m, attributes);
 			while (la.kind == 1 || la.kind == 21) {
 				EndOfStmt();
@@ -1072,35 +1072,35 @@ m, attributes);
 	}
 
 	void ModuleBody(
-//#line  621 "VBNET.ATG" 
+#line  621 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-//#line  622 "VBNET.ATG" 
+#line  622 "VBNET.ATG" 
 		AttributeSection section; 
 		while (la.kind == 1 || la.kind == 21) {
 			EndOfStmt();
 		}
 		while (StartOf(9)) {
 
-//#line  625 "VBNET.ATG" 
+#line  625 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 40) {
 				AttributeSection(
-//#line  628 "VBNET.ATG" 
+#line  628 "VBNET.ATG" 
 out section);
 
-//#line  628 "VBNET.ATG" 
+#line  628 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(10)) {
 				MemberModifier(
-//#line  629 "VBNET.ATG" 
+#line  629 "VBNET.ATG" 
 m);
 			}
 			ClassMemberDecl(
-//#line  630 "VBNET.ATG" 
+#line  630 "VBNET.ATG" 
 m, attributes);
 			while (la.kind == 1 || la.kind == 21) {
 				EndOfStmt();
@@ -1109,41 +1109,41 @@ m, attributes);
 		Expect(113);
 		Expect(155);
 
-//#line  633 "VBNET.ATG" 
+#line  633 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void StructureBody(
-//#line  604 "VBNET.ATG" 
+#line  604 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-//#line  605 "VBNET.ATG" 
+#line  605 "VBNET.ATG" 
 		AttributeSection section; 
 		while (la.kind == 1 || la.kind == 21) {
 			EndOfStmt();
 		}
 		while (StartOf(9)) {
 
-//#line  608 "VBNET.ATG" 
+#line  608 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 40) {
 				AttributeSection(
-//#line  611 "VBNET.ATG" 
+#line  611 "VBNET.ATG" 
 out section);
 
-//#line  611 "VBNET.ATG" 
+#line  611 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(10)) {
 				MemberModifier(
-//#line  612 "VBNET.ATG" 
+#line  612 "VBNET.ATG" 
 m);
 			}
 			StructureMemberDecl(
-//#line  613 "VBNET.ATG" 
+#line  613 "VBNET.ATG" 
 m, attributes);
 			while (la.kind == 1 || la.kind == 21) {
 				EndOfStmt();
@@ -1152,16 +1152,16 @@ m, attributes);
 		Expect(113);
 		Expect(209);
 
-//#line  616 "VBNET.ATG" 
+#line  616 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void NonArrayTypeName(
-//#line  2722 "VBNET.ATG" 
+#line  2725 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-//#line  2724 "VBNET.ATG" 
+#line  2727 "VBNET.ATG" 
 		string name;
 		typeref = null;
 		bool isGlobal = false;
@@ -1171,36 +1171,36 @@ out TypeReference typeref, bool canBeUnbound) {
 				lexer.NextToken();
 				Expect(26);
 
-//#line  2729 "VBNET.ATG" 
+#line  2732 "VBNET.ATG" 
 				isGlobal = true; 
 			}
 			QualIdentAndTypeArguments(
-//#line  2730 "VBNET.ATG" 
+#line  2733 "VBNET.ATG" 
 out typeref, canBeUnbound);
 
-//#line  2731 "VBNET.ATG" 
+#line  2734 "VBNET.ATG" 
 			typeref.IsGlobal = isGlobal; 
 			while (la.kind == 26) {
 				lexer.NextToken();
 
-//#line  2732 "VBNET.ATG" 
+#line  2735 "VBNET.ATG" 
 				TypeReference nestedTypeRef; 
 				QualIdentAndTypeArguments(
-//#line  2733 "VBNET.ATG" 
+#line  2736 "VBNET.ATG" 
 out nestedTypeRef, canBeUnbound);
 
-//#line  2734 "VBNET.ATG" 
+#line  2737 "VBNET.ATG" 
 				typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes); 
 			}
 		} else if (la.kind == 168) {
 			lexer.NextToken();
 
-//#line  2737 "VBNET.ATG" 
+#line  2740 "VBNET.ATG" 
 			typeref = new TypeReference("System.Object", true); 
 			if (la.kind == 33) {
 				lexer.NextToken();
 
-//#line  2741 "VBNET.ATG" 
+#line  2744 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
@@ -1208,15 +1208,15 @@ out nestedTypeRef, canBeUnbound);
 			}
 		} else if (StartOf(12)) {
 			PrimitiveTypeName(
-//#line  2747 "VBNET.ATG" 
+#line  2750 "VBNET.ATG" 
 out name);
 
-//#line  2747 "VBNET.ATG" 
+#line  2750 "VBNET.ATG" 
 			typeref = new TypeReference(name, true); 
 			if (la.kind == 33) {
 				lexer.NextToken();
 
-//#line  2751 "VBNET.ATG" 
+#line  2754 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
@@ -1226,20 +1226,20 @@ out name);
 	}
 
 	void EnumBody(
-//#line  637 "VBNET.ATG" 
+#line  637 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-//#line  638 "VBNET.ATG" 
+#line  638 "VBNET.ATG" 
 		FieldDeclaration f; 
 		while (la.kind == 1 || la.kind == 21) {
 			EndOfStmt();
 		}
 		while (StartOf(13)) {
 			EnumMemberDecl(
-//#line  641 "VBNET.ATG" 
+#line  641 "VBNET.ATG" 
 out f);
 
-//#line  643 "VBNET.ATG" 
+#line  643 "VBNET.ATG" 
 			AddChild(f);
 			
 			while (la.kind == 1 || la.kind == 21) {
@@ -1249,40 +1249,40 @@ out f);
 		Expect(113);
 		Expect(115);
 
-//#line  647 "VBNET.ATG" 
+#line  647 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void InterfaceBase(
-//#line  1602 "VBNET.ATG" 
+#line  1605 "VBNET.ATG" 
 out List<TypeReference> bases) {
 
-//#line  1604 "VBNET.ATG" 
+#line  1607 "VBNET.ATG" 
 		TypeReference type;
 		bases = new List<TypeReference>();
 		
 		Expect(140);
 		TypeName(
-//#line  1608 "VBNET.ATG" 
+#line  1611 "VBNET.ATG" 
 out type);
 
-//#line  1608 "VBNET.ATG" 
+#line  1611 "VBNET.ATG" 
 		if (type != null) bases.Add(type); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			TypeName(
-//#line  1611 "VBNET.ATG" 
+#line  1614 "VBNET.ATG" 
 out type);
 
-//#line  1611 "VBNET.ATG" 
+#line  1614 "VBNET.ATG" 
 			if (type != null) bases.Add(type); 
 		}
 		EndOfStmt();
 	}
 
 	void InterfaceBody(
-//#line  651 "VBNET.ATG" 
+#line  651 "VBNET.ATG" 
 TypeDeclaration newType) {
 		while (la.kind == 1 || la.kind == 21) {
 			EndOfStmt();
@@ -1296,168 +1296,168 @@ TypeDeclaration newType) {
 		Expect(113);
 		Expect(142);
 
-//#line  657 "VBNET.ATG" 
+#line  657 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void FormalParameterList(
-//#line  2939 "VBNET.ATG" 
+#line  2942 "VBNET.ATG" 
 List<ParameterDeclarationExpression> parameter) {
 
-//#line  2940 "VBNET.ATG" 
+#line  2943 "VBNET.ATG" 
 		ParameterDeclarationExpression p; 
 		FormalParameter(
-//#line  2942 "VBNET.ATG" 
+#line  2945 "VBNET.ATG" 
 out p);
 
-//#line  2942 "VBNET.ATG" 
+#line  2945 "VBNET.ATG" 
 		if (p != null) parameter.Add(p); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			FormalParameter(
-//#line  2944 "VBNET.ATG" 
+#line  2947 "VBNET.ATG" 
 out p);
 
-//#line  2944 "VBNET.ATG" 
+#line  2947 "VBNET.ATG" 
 			if (p != null) parameter.Add(p); 
 		}
 	}
 
 	void MemberModifier(
-//#line  3720 "VBNET.ATG" 
+#line  3723 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 156: {
 			lexer.NextToken();
 
-//#line  3721 "VBNET.ATG" 
+#line  3724 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 102: {
 			lexer.NextToken();
 
-//#line  3722 "VBNET.ATG" 
+#line  3725 "VBNET.ATG" 
 			m.Add(Modifiers.Default, t.Location);
 			break;
 		}
 		case 125: {
 			lexer.NextToken();
 
-//#line  3723 "VBNET.ATG" 
+#line  3726 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location);
 			break;
 		}
 		case 199: {
 			lexer.NextToken();
 
-//#line  3724 "VBNET.ATG" 
+#line  3727 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location);
 			break;
 		}
 		case 181: {
 			lexer.NextToken();
 
-//#line  3725 "VBNET.ATG" 
+#line  3728 "VBNET.ATG" 
 			m.Add(Modifiers.Override, t.Location);
 			break;
 		}
 		case 157: {
 			lexer.NextToken();
 
-//#line  3726 "VBNET.ATG" 
+#line  3729 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 185: {
 			lexer.NextToken();
 
-//#line  3727 "VBNET.ATG" 
+#line  3730 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location);
 			break;
 		}
 		case 187: {
 			lexer.NextToken();
 
-//#line  3728 "VBNET.ATG" 
+#line  3731 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location);
 			break;
 		}
 		case 188: {
 			lexer.NextToken();
 
-//#line  3729 "VBNET.ATG" 
+#line  3732 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location);
 			break;
 		}
 		case 166: {
 			lexer.NextToken();
 
-//#line  3730 "VBNET.ATG" 
+#line  3733 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 167: {
 			lexer.NextToken();
 
-//#line  3731 "VBNET.ATG" 
+#line  3734 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 200: {
 			lexer.NextToken();
 
-//#line  3732 "VBNET.ATG" 
+#line  3735 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location);
 			break;
 		}
 		case 180: {
 			lexer.NextToken();
 
-//#line  3733 "VBNET.ATG" 
+#line  3736 "VBNET.ATG" 
 			m.Add(Modifiers.Virtual, t.Location);
 			break;
 		}
 		case 179: {
 			lexer.NextToken();
 
-//#line  3734 "VBNET.ATG" 
+#line  3737 "VBNET.ATG" 
 			m.Add(Modifiers.Overloads, t.Location);
 			break;
 		}
 		case 190: {
 			lexer.NextToken();
 
-//#line  3735 "VBNET.ATG" 
+#line  3738 "VBNET.ATG" 
 			m.Add(Modifiers.ReadOnly, t.Location);
 			break;
 		}
 		case 235: {
 			lexer.NextToken();
 
-//#line  3736 "VBNET.ATG" 
+#line  3739 "VBNET.ATG" 
 			m.Add(Modifiers.WriteOnly, t.Location);
 			break;
 		}
 		case 234: {
 			lexer.NextToken();
 
-//#line  3737 "VBNET.ATG" 
+#line  3740 "VBNET.ATG" 
 			m.Add(Modifiers.WithEvents, t.Location);
 			break;
 		}
 		case 105: {
 			lexer.NextToken();
 
-//#line  3738 "VBNET.ATG" 
+#line  3741 "VBNET.ATG" 
 			m.Add(Modifiers.Dim, t.Location);
 			break;
 		}
 		case 183: {
 			lexer.NextToken();
 
-//#line  3739 "VBNET.ATG" 
+#line  3742 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location);
 			break;
 		}
@@ -1466,18 +1466,18 @@ ModifierList m) {
 	}
 
 	void ClassMemberDecl(
-//#line  793 "VBNET.ATG" 
+#line  793 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 		StructureMemberDecl(
-//#line  794 "VBNET.ATG" 
+#line  794 "VBNET.ATG" 
 m, attributes);
 	}
 
 	void StructureMemberDecl(
-//#line  807 "VBNET.ATG" 
+#line  807 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 
-//#line  809 "VBNET.ATG" 
+#line  809 "VBNET.ATG" 
 		TypeReference type = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		Statement stmt = null;
@@ -1487,37 +1487,37 @@ ModifierList m, List<AttributeSection> attributes) {
 		switch (la.kind) {
 		case 84: case 103: case 115: case 142: case 155: case 209: {
 			NonModuleDeclaration(
-//#line  816 "VBNET.ATG" 
+#line  816 "VBNET.ATG" 
 m, attributes);
 			break;
 		}
 		case 210: {
 			lexer.NextToken();
 
-//#line  820 "VBNET.ATG" 
+#line  820 "VBNET.ATG" 
 			Location startPos = t.Location;
 			
 			if (StartOf(4)) {
 
-//#line  824 "VBNET.ATG" 
+#line  824 "VBNET.ATG" 
 				string name = String.Empty;
 				MethodDeclaration methodDeclaration; List<string> handlesClause = null;
 				List<InterfaceImplementation> implementsClause = null;
 				
 				Identifier();
 
-//#line  830 "VBNET.ATG" 
+#line  830 "VBNET.ATG" 
 				name = t.val;
 				m.Check(Modifiers.VBMethods);
 				
 				TypeParameterList(
-//#line  833 "VBNET.ATG" 
+#line  833 "VBNET.ATG" 
 templates);
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  834 "VBNET.ATG" 
+#line  834 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
@@ -1525,23 +1525,23 @@ p);
 				if (la.kind == 134 || la.kind == 136) {
 					if (la.kind == 136) {
 						ImplementsClause(
-//#line  837 "VBNET.ATG" 
+#line  837 "VBNET.ATG" 
 out implementsClause);
 					} else {
 						HandlesClause(
-//#line  839 "VBNET.ATG" 
+#line  839 "VBNET.ATG" 
 out handlesClause);
 					}
 				}
 
-//#line  842 "VBNET.ATG" 
+#line  842 "VBNET.ATG" 
 				Location endLocation = t.EndLocation; 
 				if (
-//#line  845 "VBNET.ATG" 
+#line  845 "VBNET.ATG" 
 IsMustOverride(m)) {
 					EndOfStmt();
 
-//#line  848 "VBNET.ATG" 
+#line  848 "VBNET.ATG" 
 					methodDeclaration = new MethodDeclaration {
 					Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
 					StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
@@ -1555,7 +1555,7 @@ IsMustOverride(m)) {
 				} else if (la.kind == 1) {
 					lexer.NextToken();
 
-//#line  861 "VBNET.ATG" 
+#line  861 "VBNET.ATG" 
 					methodDeclaration = new MethodDeclaration {
 					Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
 					StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
@@ -1567,25 +1567,25 @@ IsMustOverride(m)) {
 					AddChild(methodDeclaration);
 					
 
-//#line  872 "VBNET.ATG" 
+#line  872 "VBNET.ATG" 
 					if (ParseMethodBodies) { 
 					Block(
-//#line  873 "VBNET.ATG" 
+#line  873 "VBNET.ATG" 
 out stmt);
 					Expect(113);
 					Expect(210);
 
-//#line  875 "VBNET.ATG" 
+#line  875 "VBNET.ATG" 
 					} else {
 					// don't parse method body
 					lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
 					  }
 					
 
-//#line  881 "VBNET.ATG" 
+#line  881 "VBNET.ATG" 
 					methodDeclaration.Body  = (BlockStatement)stmt; 
 
-//#line  882 "VBNET.ATG" 
+#line  882 "VBNET.ATG" 
 					methodDeclaration.Body.EndLocation = t.EndLocation; 
 					EndOfStmt();
 				} else SynErr(256);
@@ -1595,39 +1595,39 @@ out stmt);
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  886 "VBNET.ATG" 
+#line  886 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
 				}
 
-//#line  887 "VBNET.ATG" 
+#line  887 "VBNET.ATG" 
 				m.Check(Modifiers.Constructors); 
 
-//#line  888 "VBNET.ATG" 
+#line  888 "VBNET.ATG" 
 				Location constructorEndLocation = t.EndLocation; 
 				Expect(1);
 
-//#line  891 "VBNET.ATG" 
+#line  891 "VBNET.ATG" 
 				if (ParseMethodBodies) { 
 				Block(
-//#line  892 "VBNET.ATG" 
+#line  892 "VBNET.ATG" 
 out stmt);
 				Expect(113);
 				Expect(210);
 
-//#line  894 "VBNET.ATG" 
+#line  894 "VBNET.ATG" 
 				} else {
 				// don't parse method body
 				lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
 				  }
 				
 
-//#line  900 "VBNET.ATG" 
+#line  900 "VBNET.ATG" 
 				Location endLocation = t.EndLocation; 
 				EndOfStmt();
 
-//#line  903 "VBNET.ATG" 
+#line  903 "VBNET.ATG" 
 				ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes);
 				cd.StartLocation = m.GetDeclarationLocation(startPos);
 				cd.EndLocation   = constructorEndLocation;
@@ -1641,7 +1641,7 @@ out stmt);
 		case 127: {
 			lexer.NextToken();
 
-//#line  915 "VBNET.ATG" 
+#line  915 "VBNET.ATG" 
 			m.Check(Modifiers.VBMethods);
 			string name = String.Empty;
 			Location startPos = t.Location;
@@ -1651,16 +1651,16 @@ out stmt);
 			
 			Identifier();
 
-//#line  922 "VBNET.ATG" 
+#line  922 "VBNET.ATG" 
 			name = t.val; 
 			TypeParameterList(
-//#line  923 "VBNET.ATG" 
+#line  923 "VBNET.ATG" 
 templates);
 			if (la.kind == 37) {
 				lexer.NextToken();
 				if (StartOf(6)) {
 					FormalParameterList(
-//#line  924 "VBNET.ATG" 
+#line  924 "VBNET.ATG" 
 p);
 				}
 				Expect(38);
@@ -1669,10 +1669,10 @@ p);
 				lexer.NextToken();
 				while (la.kind == 40) {
 					AttributeSection(
-//#line  926 "VBNET.ATG" 
+#line  926 "VBNET.ATG" 
 out returnTypeAttributeSection);
 
-//#line  928 "VBNET.ATG" 
+#line  928 "VBNET.ATG" 
 					if (returnTypeAttributeSection != null) {
 					returnTypeAttributeSection.AttributeTarget = "return";
 					attributes.Add(returnTypeAttributeSection);
@@ -1680,11 +1680,11 @@ out returnTypeAttributeSection);
 					
 				}
 				TypeName(
-//#line  934 "VBNET.ATG" 
+#line  934 "VBNET.ATG" 
 out type);
 			}
 
-//#line  936 "VBNET.ATG" 
+#line  936 "VBNET.ATG" 
 			if(type == null) {
 			type = new TypeReference("System.Object", true);
 			}
@@ -1692,23 +1692,23 @@ out type);
 			if (la.kind == 134 || la.kind == 136) {
 				if (la.kind == 136) {
 					ImplementsClause(
-//#line  942 "VBNET.ATG" 
+#line  942 "VBNET.ATG" 
 out implementsClause);
 				} else {
 					HandlesClause(
-//#line  944 "VBNET.ATG" 
+#line  944 "VBNET.ATG" 
 out handlesClause);
 				}
 			}
 
-//#line  947 "VBNET.ATG" 
+#line  947 "VBNET.ATG" 
 			Location endLocation = t.EndLocation; 
 			if (
-//#line  950 "VBNET.ATG" 
+#line  950 "VBNET.ATG" 
 IsMustOverride(m)) {
 				EndOfStmt();
 
-//#line  953 "VBNET.ATG" 
+#line  953 "VBNET.ATG" 
 				methodDeclaration = new MethodDeclaration {
 				Name = name, Modifier = m.Modifier, TypeReference = type,
 				Parameters = p, Attributes = attributes,
@@ -1724,7 +1724,7 @@ IsMustOverride(m)) {
 			} else if (la.kind == 1) {
 				lexer.NextToken();
 
-//#line  968 "VBNET.ATG" 
+#line  968 "VBNET.ATG" 
 				methodDeclaration = new MethodDeclaration {
 				Name = name, Modifier = m.Modifier, TypeReference = type,
 				Parameters = p, Attributes = attributes,
@@ -1739,12 +1739,12 @@ IsMustOverride(m)) {
 				
 				if (ParseMethodBodies) { 
 				Block(
-//#line  981 "VBNET.ATG" 
+#line  981 "VBNET.ATG" 
 out stmt);
 				Expect(113);
 				Expect(127);
 
-//#line  983 "VBNET.ATG" 
+#line  983 "VBNET.ATG" 
 				} else {
 				// don't parse method body
 				lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
@@ -1760,7 +1760,7 @@ out stmt);
 		case 101: {
 			lexer.NextToken();
 
-//#line  997 "VBNET.ATG" 
+#line  997 "VBNET.ATG" 
 			m.Check(Modifiers.VBExternalMethods);
 			Location startPos = t.Location;
 			CharsetModifier charsetModifer = CharsetModifier.None;
@@ -1770,39 +1770,39 @@ out stmt);
 			
 			if (StartOf(15)) {
 				Charset(
-//#line  1004 "VBNET.ATG" 
+#line  1004 "VBNET.ATG" 
 out charsetModifer);
 			}
 			if (la.kind == 210) {
 				lexer.NextToken();
 				Identifier();
 
-//#line  1007 "VBNET.ATG" 
+#line  1007 "VBNET.ATG" 
 				name = t.val; 
 				Expect(149);
 				Expect(3);
 
-//#line  1008 "VBNET.ATG" 
+#line  1008 "VBNET.ATG" 
 				library = t.literalValue as string; 
 				if (la.kind == 59) {
 					lexer.NextToken();
 					Expect(3);
 
-//#line  1009 "VBNET.ATG" 
+#line  1009 "VBNET.ATG" 
 					alias = t.literalValue as string; 
 				}
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  1010 "VBNET.ATG" 
+#line  1010 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
 				}
 				EndOfStmt();
 
-//#line  1013 "VBNET.ATG" 
+#line  1013 "VBNET.ATG" 
 				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
 				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				declareDeclaration.EndLocation   = t.EndLocation;
@@ -1812,25 +1812,25 @@ p);
 				lexer.NextToken();
 				Identifier();
 
-//#line  1020 "VBNET.ATG" 
+#line  1020 "VBNET.ATG" 
 				name = t.val; 
 				Expect(149);
 				Expect(3);
 
-//#line  1021 "VBNET.ATG" 
+#line  1021 "VBNET.ATG" 
 				library = t.literalValue as string; 
 				if (la.kind == 59) {
 					lexer.NextToken();
 					Expect(3);
 
-//#line  1022 "VBNET.ATG" 
+#line  1022 "VBNET.ATG" 
 					alias = t.literalValue as string; 
 				}
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  1023 "VBNET.ATG" 
+#line  1023 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
@@ -1838,12 +1838,12 @@ p);
 				if (la.kind == 63) {
 					lexer.NextToken();
 					TypeName(
-//#line  1024 "VBNET.ATG" 
+#line  1024 "VBNET.ATG" 
 out type);
 				}
 				EndOfStmt();
 
-//#line  1027 "VBNET.ATG" 
+#line  1027 "VBNET.ATG" 
 				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
 				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				declareDeclaration.EndLocation   = t.EndLocation;
@@ -1855,7 +1855,7 @@ out type);
 		case 119: {
 			lexer.NextToken();
 
-//#line  1037 "VBNET.ATG" 
+#line  1037 "VBNET.ATG" 
 			m.Check(Modifiers.VBEvents);
 			Location startPos = t.Location;
 			EventDeclaration eventDeclaration;
@@ -1864,19 +1864,19 @@ out type);
 			
 			Identifier();
 
-//#line  1043 "VBNET.ATG" 
+#line  1043 "VBNET.ATG" 
 			name= t.val; 
 			if (la.kind == 63) {
 				lexer.NextToken();
 				TypeName(
-//#line  1045 "VBNET.ATG" 
+#line  1045 "VBNET.ATG" 
 out type);
 			} else if (StartOf(16)) {
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  1047 "VBNET.ATG" 
+#line  1047 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
@@ -1884,11 +1884,11 @@ p);
 			} else SynErr(260);
 			if (la.kind == 136) {
 				ImplementsClause(
-//#line  1049 "VBNET.ATG" 
+#line  1049 "VBNET.ATG" 
 out implementsClause);
 			}
 
-//#line  1051 "VBNET.ATG" 
+#line  1051 "VBNET.ATG" 
 			eventDeclaration = new EventDeclaration {
 			Name = name, TypeReference = type, Modifier = m.Modifier, 
 			Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
@@ -1902,29 +1902,29 @@ out implementsClause);
 		}
 		case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
 
-//#line  1062 "VBNET.ATG" 
+#line  1062 "VBNET.ATG" 
 			m.Check(Modifiers.Fields);
 			FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);
 			
 			IdentifierForFieldDeclaration();
 
-//#line  1065 "VBNET.ATG" 
+#line  1065 "VBNET.ATG" 
 			string name = t.val; 
 
-//#line  1066 "VBNET.ATG" 
+#line  1066 "VBNET.ATG" 
 			fd.StartLocation = m.GetDeclarationLocation(t.Location); 
 			VariableDeclaratorPartAfterIdentifier(
-//#line  1068 "VBNET.ATG" 
+#line  1068 "VBNET.ATG" 
 variableDeclarators, name);
 			while (la.kind == 22) {
 				lexer.NextToken();
 				VariableDeclarator(
-//#line  1069 "VBNET.ATG" 
+#line  1069 "VBNET.ATG" 
 variableDeclarators);
 			}
 			EndOfStmt();
 
-//#line  1072 "VBNET.ATG" 
+#line  1072 "VBNET.ATG" 
 			fd.EndLocation = t.EndLocation;
 			fd.Fields = variableDeclarators;
 			AddChild(fd);
@@ -1933,35 +1933,35 @@ variableDeclarators);
 		}
 		case 88: {
 
-//#line  1077 "VBNET.ATG" 
+#line  1077 "VBNET.ATG" 
 			m.Check(Modifiers.Fields); 
 			lexer.NextToken();
 
-//#line  1078 "VBNET.ATG" 
+#line  1078 "VBNET.ATG" 
 			m.Add(Modifiers.Const, t.Location);  
 
-//#line  1080 "VBNET.ATG" 
+#line  1080 "VBNET.ATG" 
 			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
 			fd.StartLocation = m.GetDeclarationLocation(t.Location);
 			List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();
 			
 			ConstantDeclarator(
-//#line  1084 "VBNET.ATG" 
+#line  1084 "VBNET.ATG" 
 constantDeclarators);
 			while (la.kind == 22) {
 				lexer.NextToken();
 				ConstantDeclarator(
-//#line  1085 "VBNET.ATG" 
+#line  1085 "VBNET.ATG" 
 constantDeclarators);
 			}
 
-//#line  1087 "VBNET.ATG" 
+#line  1087 "VBNET.ATG" 
 			fd.Fields = constantDeclarators;
 			fd.EndLocation = t.Location;
 			
 			EndOfStmt();
 
-//#line  1092 "VBNET.ATG" 
+#line  1092 "VBNET.ATG" 
 			fd.EndLocation = t.EndLocation;
 			AddChild(fd);
 			
@@ -1970,7 +1970,7 @@ constantDeclarators);
 		case 186: {
 			lexer.NextToken();
 
-//#line  1098 "VBNET.ATG" 
+#line  1098 "VBNET.ATG" 
 			m.Check(Modifiers.VBProperties);
 			Location startPos = t.Location;
 			List<InterfaceImplementation> implementsClause = null;
@@ -1979,13 +1979,13 @@ constantDeclarators);
 			
 			Identifier();
 
-//#line  1104 "VBNET.ATG" 
+#line  1104 "VBNET.ATG" 
 			string propertyName = t.val; 
 			if (la.kind == 37) {
 				lexer.NextToken();
 				if (StartOf(6)) {
 					FormalParameterList(
-//#line  1105 "VBNET.ATG" 
+#line  1105 "VBNET.ATG" 
 p);
 				}
 				Expect(38);
@@ -1994,10 +1994,10 @@ p);
 				lexer.NextToken();
 				while (la.kind == 40) {
 					AttributeSection(
-//#line  1108 "VBNET.ATG" 
+#line  1108 "VBNET.ATG" 
 out returnTypeAttributeSection);
 
-//#line  1110 "VBNET.ATG" 
+#line  1110 "VBNET.ATG" 
 					if (returnTypeAttributeSection != null) {
 					returnTypeAttributeSection.AttributeTarget = "return";
 					attributes.Add(returnTypeAttributeSection);
@@ -2005,13 +2005,13 @@ out returnTypeAttributeSection);
 					
 				}
 				if (
-//#line  1117 "VBNET.ATG" 
+#line  1117 "VBNET.ATG" 
 IsNewExpression()) {
 					ObjectCreateExpression(
-//#line  1117 "VBNET.ATG" 
+#line  1117 "VBNET.ATG" 
 out initializer);
 
-//#line  1119 "VBNET.ATG" 
+#line  1119 "VBNET.ATG" 
 					if (initializer is ObjectCreateExpression) {
 					type = ((ObjectCreateExpression)initializer).CreateType.Clone();
 					} else {
@@ -2020,27 +2020,27 @@ out initializer);
 					
 				} else if (StartOf(8)) {
 					TypeName(
-//#line  1126 "VBNET.ATG" 
+#line  1126 "VBNET.ATG" 
 out type);
 				} else SynErr(261);
 			}
 			if (la.kind == 20) {
 				lexer.NextToken();
 				Expr(
-//#line  1129 "VBNET.ATG" 
+#line  1129 "VBNET.ATG" 
 out initializer);
 			}
 			if (la.kind == 136) {
 				ImplementsClause(
-//#line  1130 "VBNET.ATG" 
+#line  1130 "VBNET.ATG" 
 out implementsClause);
 			}
 			EndOfStmt();
 			if (
-//#line  1134 "VBNET.ATG" 
+#line  1134 "VBNET.ATG" 
 IsMustOverride(m) || IsAutomaticProperty()) {
 
-//#line  1136 "VBNET.ATG" 
+#line  1136 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -2053,7 +2053,7 @@ IsMustOverride(m) || IsAutomaticProperty()) {
 				
 			} else if (StartOf(17)) {
 
-//#line  1148 "VBNET.ATG" 
+#line  1148 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -2065,13 +2065,13 @@ IsMustOverride(m) || IsAutomaticProperty()) {
 				PropertySetRegion setRegion;
 				
 				AccessorDecls(
-//#line  1158 "VBNET.ATG" 
+#line  1158 "VBNET.ATG" 
 out getRegion, out setRegion);
 				Expect(113);
 				Expect(186);
 				EndOfStmt();
 
-//#line  1162 "VBNET.ATG" 
+#line  1162 "VBNET.ATG" 
 				pDecl.GetRegion = getRegion;
 				pDecl.SetRegion = setRegion;
 				pDecl.BodyEnd = t.Location; // t = EndOfStmt; not "Property"
@@ -2083,11 +2083,11 @@ out getRegion, out setRegion);
 		case 98: {
 			lexer.NextToken();
 
-//#line  1169 "VBNET.ATG" 
+#line  1169 "VBNET.ATG" 
 			Location startPos = t.Location; 
 			Expect(119);
 
-//#line  1171 "VBNET.ATG" 
+#line  1171 "VBNET.ATG" 
 			m.Check(Modifiers.VBCustomEvents);
 			EventAddRemoveRegion eventAccessorDeclaration;
 			EventAddRegion addHandlerAccessorDeclaration = null;
@@ -2097,24 +2097,24 @@ out getRegion, out setRegion);
 			
 			Identifier();
 
-//#line  1178 "VBNET.ATG" 
+#line  1178 "VBNET.ATG" 
 			string customEventName = t.val; 
 			Expect(63);
 			TypeName(
-//#line  1179 "VBNET.ATG" 
+#line  1179 "VBNET.ATG" 
 out type);
 			if (la.kind == 136) {
 				ImplementsClause(
-//#line  1180 "VBNET.ATG" 
+#line  1180 "VBNET.ATG" 
 out implementsClause);
 			}
 			EndOfStmt();
 			while (StartOf(18)) {
 				EventAccessorDeclaration(
-//#line  1183 "VBNET.ATG" 
+#line  1183 "VBNET.ATG" 
 out eventAccessorDeclaration);
 
-//#line  1185 "VBNET.ATG" 
+#line  1185 "VBNET.ATG" 
 				if(eventAccessorDeclaration is EventAddRegion)
 				{
 					addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
@@ -2133,7 +2133,7 @@ out eventAccessorDeclaration);
 			Expect(119);
 			EndOfStmt();
 
-//#line  1201 "VBNET.ATG" 
+#line  1201 "VBNET.ATG" 
 			if(addHandlerAccessorDeclaration == null)
 			{
 				Error("Need to provide AddHandler accessor.");
@@ -2164,24 +2164,24 @@ out eventAccessorDeclaration);
 		}
 		case 161: case 172: case 232: {
 
-//#line  1227 "VBNET.ATG" 
+#line  1227 "VBNET.ATG" 
 			ConversionType opConversionType = ConversionType.None; 
 			if (la.kind == 161 || la.kind == 232) {
 				if (la.kind == 232) {
 					lexer.NextToken();
 
-//#line  1228 "VBNET.ATG" 
+#line  1228 "VBNET.ATG" 
 					opConversionType = ConversionType.Implicit; 
 				} else {
 					lexer.NextToken();
 
-//#line  1229 "VBNET.ATG" 
+#line  1229 "VBNET.ATG" 
 					opConversionType = ConversionType.Explicit;
 				}
 			}
 			Expect(172);
 
-//#line  1232 "VBNET.ATG" 
+#line  1232 "VBNET.ATG" 
 			m.Check(Modifiers.VBOperators);
 			Location startPos = t.Location;
 			TypeReference returnType = NullTypeReference.Instance;
@@ -2192,63 +2192,64 @@ out eventAccessorDeclaration);
 			List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
 			
 			OverloadableOperator(
-//#line  1241 "VBNET.ATG" 
+#line  1241 "VBNET.ATG" 
 out operatorType);
 			Expect(37);
 			FormalParameter(
-//#line  1243 "VBNET.ATG" 
+#line  1243 "VBNET.ATG" 
 out param);
 
-//#line  1244 "VBNET.ATG" 
+#line  1244 "VBNET.ATG" 
 			if (param != null) parameters.Add(param); 
 			if (la.kind == 22) {
 				lexer.NextToken();
 				FormalParameter(
-//#line  1246 "VBNET.ATG" 
+#line  1246 "VBNET.ATG" 
 out param);
 
-//#line  1247 "VBNET.ATG" 
+#line  1247 "VBNET.ATG" 
 				if (param != null) parameters.Add(param); 
 			}
 			Expect(38);
 
-//#line  1250 "VBNET.ATG" 
+#line  1250 "VBNET.ATG" 
 			Location endPos = t.EndLocation; 
 			if (la.kind == 63) {
 				lexer.NextToken();
 				while (la.kind == 40) {
 					AttributeSection(
-//#line  1251 "VBNET.ATG" 
+#line  1251 "VBNET.ATG" 
 out section);
 
-//#line  1252 "VBNET.ATG" 
+#line  1252 "VBNET.ATG" 
 					if (section != null) {
 					section.AttributeTarget = "return";
 					attributes.Add(section);
 					} 
 				}
 				TypeName(
-//#line  1256 "VBNET.ATG" 
+#line  1256 "VBNET.ATG" 
 out returnType);
 
-//#line  1256 "VBNET.ATG" 
+#line  1256 "VBNET.ATG" 
 				endPos = t.EndLocation; 
 			}
 			Expect(1);
 			Block(
-//#line  1258 "VBNET.ATG" 
+#line  1258 "VBNET.ATG" 
 out stmt);
 			Expect(113);
 			Expect(172);
 			EndOfStmt();
 
-//#line  1260 "VBNET.ATG" 
+#line  1260 "VBNET.ATG" 
 			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
 			Modifier = m.Modifier,
 			Attributes = attributes,
 			Parameters = parameters,
 			TypeReference = returnType,
 			OverloadableOperator = operatorType,
+			Name = GetReflectionNameForOperator(operatorType, opConversionType),
 			ConversionType = opConversionType,
 			Body = (BlockStatement)stmt,
 			StartLocation = m.GetDeclarationLocation(startPos),
@@ -2265,25 +2266,25 @@ out stmt);
 	}
 
 	void EnumMemberDecl(
-//#line  774 "VBNET.ATG" 
+#line  774 "VBNET.ATG" 
 out FieldDeclaration f) {
 
-//#line  776 "VBNET.ATG" 
+#line  776 "VBNET.ATG" 
 		Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
 		AttributeSection section = null;
 		VariableDeclaration varDecl = null;
 		
 		while (la.kind == 40) {
 			AttributeSection(
-//#line  780 "VBNET.ATG" 
+#line  780 "VBNET.ATG" 
 out section);
 
-//#line  780 "VBNET.ATG" 
+#line  780 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		Identifier();
 
-//#line  783 "VBNET.ATG" 
+#line  783 "VBNET.ATG" 
 		f = new FieldDeclaration(attributes);
 		varDecl = new VariableDeclaration(t.val);
 		f.Fields.Add(varDecl);
@@ -2292,21 +2293,21 @@ out section);
 		if (la.kind == 20) {
 			lexer.NextToken();
 			Expr(
-//#line  788 "VBNET.ATG" 
+#line  788 "VBNET.ATG" 
 out expr);
 
-//#line  788 "VBNET.ATG" 
+#line  788 "VBNET.ATG" 
 			varDecl.Initializer = expr; 
 		}
 
-//#line  789 "VBNET.ATG" 
+#line  789 "VBNET.ATG" 
 		f.EndLocation = varDecl.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void InterfaceMemberDecl() {
 
-//#line  665 "VBNET.ATG" 
+#line  665 "VBNET.ATG" 
 		TypeReference type =null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		List<TemplateDefinition> templates = new List<TemplateDefinition>();
@@ -2318,33 +2319,33 @@ out expr);
 		if (StartOf(19)) {
 			while (la.kind == 40) {
 				AttributeSection(
-//#line  673 "VBNET.ATG" 
+#line  673 "VBNET.ATG" 
 out section);
 
-//#line  673 "VBNET.ATG" 
+#line  673 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(10)) {
 				MemberModifier(
-//#line  676 "VBNET.ATG" 
+#line  676 "VBNET.ATG" 
 mod);
 			}
 			if (la.kind == 119) {
 				lexer.NextToken();
 
-//#line  680 "VBNET.ATG" 
+#line  680 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceEvents);
 				Location startLocation = t.Location;
 				
 				Identifier();
 
-//#line  683 "VBNET.ATG" 
+#line  683 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  684 "VBNET.ATG" 
+#line  684 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
@@ -2352,12 +2353,12 @@ p);
 				if (la.kind == 63) {
 					lexer.NextToken();
 					TypeName(
-//#line  685 "VBNET.ATG" 
+#line  685 "VBNET.ATG" 
 out type);
 				}
 				EndOfStmt();
 
-//#line  688 "VBNET.ATG" 
+#line  688 "VBNET.ATG" 
 				EventDeclaration ed = new EventDeclaration {
 				Name = name, TypeReference = type, Modifier = mod.Modifier,
 				Parameters = p, Attributes = attributes,
@@ -2368,29 +2369,29 @@ out type);
 			} else if (la.kind == 210) {
 				lexer.NextToken();
 
-//#line  698 "VBNET.ATG" 
+#line  698 "VBNET.ATG" 
 				Location startLocation =  t.Location;
 				mod.Check(Modifiers.VBInterfaceMethods);
 				
 				Identifier();
 
-//#line  701 "VBNET.ATG" 
+#line  701 "VBNET.ATG" 
 				name = t.val; 
 				TypeParameterList(
-//#line  702 "VBNET.ATG" 
+#line  702 "VBNET.ATG" 
 templates);
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  703 "VBNET.ATG" 
+#line  703 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
 				}
 				EndOfStmt();
 
-//#line  706 "VBNET.ATG" 
+#line  706 "VBNET.ATG" 
 				MethodDeclaration md = new MethodDeclaration {
 				Name = name, 
 				Modifier = mod.Modifier, 
@@ -2406,22 +2407,22 @@ p);
 			} else if (la.kind == 127) {
 				lexer.NextToken();
 
-//#line  721 "VBNET.ATG" 
+#line  721 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceMethods);
 				Location startLocation = t.Location;
 				
 				Identifier();
 
-//#line  724 "VBNET.ATG" 
+#line  724 "VBNET.ATG" 
 				name = t.val; 
 				TypeParameterList(
-//#line  725 "VBNET.ATG" 
+#line  725 "VBNET.ATG" 
 templates);
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  726 "VBNET.ATG" 
+#line  726 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
@@ -2430,15 +2431,15 @@ p);
 					lexer.NextToken();
 					while (la.kind == 40) {
 						AttributeSection(
-//#line  727 "VBNET.ATG" 
+#line  727 "VBNET.ATG" 
 out returnTypeAttributeSection);
 					}
 					TypeName(
-//#line  727 "VBNET.ATG" 
+#line  727 "VBNET.ATG" 
 out type);
 				}
 
-//#line  729 "VBNET.ATG" 
+#line  729 "VBNET.ATG" 
 				if(type == null) {
 				type = new TypeReference("System.Object", true);
 				}
@@ -2459,19 +2460,19 @@ out type);
 			} else if (la.kind == 186) {
 				lexer.NextToken();
 
-//#line  749 "VBNET.ATG" 
+#line  749 "VBNET.ATG" 
 				Location startLocation = t.Location;
 				mod.Check(Modifiers.VBInterfaceProperties);
 				
 				Identifier();
 
-//#line  752 "VBNET.ATG" 
+#line  752 "VBNET.ATG" 
 				name = t.val;  
 				if (la.kind == 37) {
 					lexer.NextToken();
 					if (StartOf(6)) {
 						FormalParameterList(
-//#line  753 "VBNET.ATG" 
+#line  753 "VBNET.ATG" 
 p);
 					}
 					Expect(38);
@@ -2479,18 +2480,18 @@ p);
 				if (la.kind == 63) {
 					lexer.NextToken();
 					TypeName(
-//#line  754 "VBNET.ATG" 
+#line  754 "VBNET.ATG" 
 out type);
 				}
 
-//#line  756 "VBNET.ATG" 
+#line  756 "VBNET.ATG" 
 				if(type == null) {
 				type = new TypeReference("System.Object", true);
 				}
 				
 				EndOfStmt();
 
-//#line  762 "VBNET.ATG" 
+#line  762 "VBNET.ATG" 
 				PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes);
 				pd.Parameters = p;
 				pd.EndLocation = t.EndLocation;
@@ -2500,34 +2501,34 @@ out type);
 			} else SynErr(264);
 		} else if (StartOf(20)) {
 			NonModuleDeclaration(
-//#line  770 "VBNET.ATG" 
+#line  770 "VBNET.ATG" 
 mod, attributes);
 		} else SynErr(265);
 	}
 
 	void Expr(
-//#line  1661 "VBNET.ATG" 
+#line  1664 "VBNET.ATG" 
 out Expression expr) {
 
-//#line  1662 "VBNET.ATG" 
+#line  1665 "VBNET.ATG" 
 		expr = null; Location startLocation = la.Location; 
 		if (
-//#line  1665 "VBNET.ATG" 
+#line  1668 "VBNET.ATG" 
 IsQueryExpression() ) {
 			QueryExpr(
-//#line  1666 "VBNET.ATG" 
+#line  1669 "VBNET.ATG" 
 out expr);
 		} else if (la.kind == 127 || la.kind == 210) {
 			LambdaExpr(
-//#line  1667 "VBNET.ATG" 
+#line  1670 "VBNET.ATG" 
 out expr);
 		} else if (StartOf(21)) {
 			DisjunctionExpr(
-//#line  1668 "VBNET.ATG" 
+#line  1671 "VBNET.ATG" 
 out expr);
 		} else SynErr(266);
 
-//#line  1671 "VBNET.ATG" 
+#line  1674 "VBNET.ATG" 
 		if (expr != null) {
 		expr.StartLocation = startLocation;
 		expr.EndLocation = t.EndLocation;
@@ -2536,87 +2537,87 @@ out expr);
 	}
 
 	void ImplementsClause(
-//#line  1634 "VBNET.ATG" 
+#line  1637 "VBNET.ATG" 
 out List<InterfaceImplementation> baseInterfaces) {
 
-//#line  1636 "VBNET.ATG" 
+#line  1639 "VBNET.ATG" 
 		baseInterfaces = new List<InterfaceImplementation>();
 		TypeReference type = null;
 		string memberName = null;
 		
 		Expect(136);
 		NonArrayTypeName(
-//#line  1641 "VBNET.ATG" 
+#line  1644 "VBNET.ATG" 
 out type, false);
 
-//#line  1642 "VBNET.ATG" 
+#line  1645 "VBNET.ATG" 
 		if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-//#line  1643 "VBNET.ATG" 
+#line  1646 "VBNET.ATG" 
 		baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			NonArrayTypeName(
-//#line  1645 "VBNET.ATG" 
+#line  1648 "VBNET.ATG" 
 out type, false);
 
-//#line  1646 "VBNET.ATG" 
+#line  1649 "VBNET.ATG" 
 			if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-//#line  1647 "VBNET.ATG" 
+#line  1650 "VBNET.ATG" 
 			baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		}
 	}
 
 	void HandlesClause(
-//#line  1592 "VBNET.ATG" 
+#line  1595 "VBNET.ATG" 
 out List<string> handlesClause) {
 
-//#line  1594 "VBNET.ATG" 
+#line  1597 "VBNET.ATG" 
 		handlesClause = new List<string>();
 		string name;
 		
 		Expect(134);
 		EventMemberSpecifier(
-//#line  1597 "VBNET.ATG" 
+#line  1600 "VBNET.ATG" 
 out name);
 
-//#line  1597 "VBNET.ATG" 
+#line  1600 "VBNET.ATG" 
 		if (name != null) handlesClause.Add(name); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			EventMemberSpecifier(
-//#line  1598 "VBNET.ATG" 
+#line  1601 "VBNET.ATG" 
 out name);
 
-//#line  1598 "VBNET.ATG" 
+#line  1601 "VBNET.ATG" 
 			if (name != null) handlesClause.Add(name); 
 		}
 	}
 
 	void Block(
-//#line  2987 "VBNET.ATG" 
+#line  2990 "VBNET.ATG" 
 out Statement stmt) {
 
-//#line  2990 "VBNET.ATG" 
+#line  2993 "VBNET.ATG" 
 		BlockStatement blockStmt = new BlockStatement();
 		/* in snippet parsing mode, t might be null */
 		if (t != null) blockStmt.StartLocation = t.EndLocation;
 		BlockStart(blockStmt);
 		
 		while (StartOf(22) || 
-//#line  2996 "VBNET.ATG" 
+#line  2999 "VBNET.ATG" 
 IsEndStmtAhead()) {
 			if (
-//#line  2996 "VBNET.ATG" 
+#line  2999 "VBNET.ATG" 
 IsEndStmtAhead()) {
 
-//#line  2997 "VBNET.ATG" 
+#line  3000 "VBNET.ATG" 
 				Token first = la; 
 				Expect(113);
 				EndOfStmt();
 
-//#line  3000 "VBNET.ATG" 
+#line  3003 "VBNET.ATG" 
 				AddChild(new EndStatement() {
 				StartLocation = first.Location,
 				EndLocation = first.EndLocation }
@@ -2628,7 +2629,7 @@ IsEndStmtAhead()) {
 			}
 		}
 
-//#line  3009 "VBNET.ATG" 
+#line  3012 "VBNET.ATG" 
 		stmt = blockStmt;
 		if (t != null) blockStmt.EndLocation = t.EndLocation;
 		BlockEnd();
@@ -2636,26 +2637,26 @@ IsEndStmtAhead()) {
 	}
 
 	void Charset(
-//#line  1584 "VBNET.ATG" 
+#line  1587 "VBNET.ATG" 
 out CharsetModifier charsetModifier) {
 
-//#line  1585 "VBNET.ATG" 
+#line  1588 "VBNET.ATG" 
 		charsetModifier = CharsetModifier.None; 
 		if (la.kind == 127 || la.kind == 210) {
 		} else if (la.kind == 62) {
 			lexer.NextToken();
 
-//#line  1586 "VBNET.ATG" 
+#line  1589 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Ansi; 
 		} else if (la.kind == 66) {
 			lexer.NextToken();
 
-//#line  1587 "VBNET.ATG" 
+#line  1590 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Auto; 
 		} else if (la.kind == 223) {
 			lexer.NextToken();
 
-//#line  1588 "VBNET.ATG" 
+#line  1591 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Unicode; 
 		} else SynErr(267);
 	}
@@ -2783,10 +2784,10 @@ out CharsetModifier charsetModifier) {
 	}
 
 	void VariableDeclaratorPartAfterIdentifier(
-//#line  1463 "VBNET.ATG" 
+#line  1466 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration, string name) {
 
-//#line  1465 "VBNET.ATG" 
+#line  1468 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		ArrayList rank = null;
@@ -2794,28 +2795,28 @@ List<VariableDeclaration> fieldDeclaration, string name) {
 		Location startLocation = t.Location;
 		
 		if (
-//#line  1471 "VBNET.ATG" 
+#line  1474 "VBNET.ATG" 
 IsSize() && !IsDims()) {
 			ArrayInitializationModifier(
-//#line  1471 "VBNET.ATG" 
+#line  1474 "VBNET.ATG" 
 out dimension);
 		}
 		if (
-//#line  1472 "VBNET.ATG" 
+#line  1475 "VBNET.ATG" 
 IsDims()) {
 			ArrayNameModifier(
-//#line  1472 "VBNET.ATG" 
+#line  1475 "VBNET.ATG" 
 out rank);
 		}
 		if (
-//#line  1474 "VBNET.ATG" 
+#line  1477 "VBNET.ATG" 
 IsObjectCreation()) {
 			Expect(63);
 			ObjectCreateExpression(
-//#line  1474 "VBNET.ATG" 
+#line  1477 "VBNET.ATG" 
 out expr);
 
-//#line  1476 "VBNET.ATG" 
+#line  1479 "VBNET.ATG" 
 			if (expr is ObjectCreateExpression) {
 			type = ((ObjectCreateExpression)expr).CreateType.Clone();
 			} else {
@@ -2826,10 +2827,10 @@ out expr);
 			if (la.kind == 63) {
 				lexer.NextToken();
 				TypeName(
-//#line  1483 "VBNET.ATG" 
+#line  1486 "VBNET.ATG" 
 out type);
 
-//#line  1485 "VBNET.ATG" 
+#line  1488 "VBNET.ATG" 
 				if (type != null) {
 				for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
 					VariableDeclaration vd = fieldDeclaration[i];
@@ -2842,7 +2843,7 @@ out type);
 				 
 			}
 
-//#line  1497 "VBNET.ATG" 
+#line  1500 "VBNET.ATG" 
 			if (type == null && (dimension != null || rank != null)) {
 			type = new TypeReference("");
 			}
@@ -2869,12 +2870,12 @@ out type);
 			if (la.kind == 20) {
 				lexer.NextToken();
 				Expr(
-//#line  1520 "VBNET.ATG" 
+#line  1523 "VBNET.ATG" 
 out expr);
 			}
 		} else SynErr(269);
 
-//#line  1523 "VBNET.ATG" 
+#line  1526 "VBNET.ATG" 
 		VariableDeclaration varDecl = new VariableDeclaration(name, expr, type);
 		varDecl.StartLocation = startLocation;
 		varDecl.EndLocation = t.Location;
@@ -2883,22 +2884,22 @@ out expr);
 	}
 
 	void VariableDeclarator(
-//#line  1457 "VBNET.ATG" 
+#line  1460 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration) {
 		Identifier();
 
-//#line  1459 "VBNET.ATG" 
+#line  1462 "VBNET.ATG" 
 		string name = t.val; 
 		VariableDeclaratorPartAfterIdentifier(
-//#line  1460 "VBNET.ATG" 
+#line  1463 "VBNET.ATG" 
 fieldDeclaration, name);
 	}
 
 	void ConstantDeclarator(
-//#line  1438 "VBNET.ATG" 
+#line  1441 "VBNET.ATG" 
 List<VariableDeclaration> constantDeclaration) {
 
-//#line  1440 "VBNET.ATG" 
+#line  1443 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		string name = String.Empty;
@@ -2906,20 +2907,20 @@ List<VariableDeclaration> constantDeclaration) {
 		
 		Identifier();
 
-//#line  1445 "VBNET.ATG" 
+#line  1448 "VBNET.ATG" 
 		name = t.val; location = t.Location; 
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-//#line  1446 "VBNET.ATG" 
+#line  1449 "VBNET.ATG" 
 out type);
 		}
 		Expect(20);
 		Expr(
-//#line  1447 "VBNET.ATG" 
+#line  1450 "VBNET.ATG" 
 out expr);
 
-//#line  1449 "VBNET.ATG" 
+#line  1452 "VBNET.ATG" 
 		VariableDeclaration f = new VariableDeclaration(name, expr);
 		f.TypeReference = type;
 		f.StartLocation = location;
@@ -2928,10 +2929,10 @@ out expr);
 	}
 
 	void ObjectCreateExpression(
-//#line  2123 "VBNET.ATG" 
+#line  2126 "VBNET.ATG" 
 out Expression oce) {
 
-//#line  2125 "VBNET.ATG" 
+#line  2128 "VBNET.ATG" 
 		TypeReference type = null;
 		CollectionInitializerExpression initializer = null;
 		List<Expression> arguments = null;
@@ -2943,39 +2944,39 @@ out Expression oce) {
 		Expect(162);
 		if (StartOf(8)) {
 			NonArrayTypeName(
-//#line  2134 "VBNET.ATG" 
+#line  2137 "VBNET.ATG" 
 out type, false);
 			if (la.kind == 37) {
 				lexer.NextToken();
 				NormalOrReDimArgumentList(
-//#line  2135 "VBNET.ATG" 
+#line  2138 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeReDim);
 				Expect(38);
 				if (la.kind == 35 || 
-//#line  2136 "VBNET.ATG" 
+#line  2139 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 					if (
-//#line  2136 "VBNET.ATG" 
+#line  2139 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 						ArrayTypeModifiers(
-//#line  2137 "VBNET.ATG" 
+#line  2140 "VBNET.ATG" 
 out dimensions);
 						CollectionInitializer(
-//#line  2138 "VBNET.ATG" 
+#line  2141 "VBNET.ATG" 
 out initializer);
 					} else {
 						CollectionInitializer(
-//#line  2139 "VBNET.ATG" 
+#line  2142 "VBNET.ATG" 
 out initializer);
 					}
 				}
 
-//#line  2141 "VBNET.ATG" 
+#line  2144 "VBNET.ATG" 
 				if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); 
 			}
 		}
 
-//#line  2145 "VBNET.ATG" 
+#line  2148 "VBNET.ATG" 
 		if (initializer == null) {
 		oce = new ObjectCreateExpression(type, arguments);
 		} else {
@@ -2990,53 +2991,53 @@ out initializer);
 		if (la.kind == 126 || la.kind == 233) {
 			if (la.kind == 233) {
 
-//#line  2160 "VBNET.ATG" 
+#line  2163 "VBNET.ATG" 
 				MemberInitializerExpression memberInitializer = null;
 				Expression anonymousMember = null;
 				
 				lexer.NextToken();
 
-//#line  2165 "VBNET.ATG" 
+#line  2168 "VBNET.ATG" 
 				CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
 				memberInitializers.StartLocation = la.Location;
 				
 				Expect(35);
 				if (la.kind == 26 || la.kind == 147) {
 					MemberInitializer(
-//#line  2170 "VBNET.ATG" 
+#line  2173 "VBNET.ATG" 
 out memberInitializer);
 
-//#line  2171 "VBNET.ATG" 
+#line  2174 "VBNET.ATG" 
 					memberInitializers.CreateExpressions.Add(memberInitializer); 
 				} else if (StartOf(24)) {
 					Expr(
-//#line  2172 "VBNET.ATG" 
+#line  2175 "VBNET.ATG" 
 out anonymousMember);
 
-//#line  2173 "VBNET.ATG" 
+#line  2176 "VBNET.ATG" 
 					memberInitializers.CreateExpressions.Add(anonymousMember); 
 				} else SynErr(270);
 				while (la.kind == 22) {
 					lexer.NextToken();
 					if (la.kind == 26 || la.kind == 147) {
 						MemberInitializer(
-//#line  2177 "VBNET.ATG" 
+#line  2180 "VBNET.ATG" 
 out memberInitializer);
 
-//#line  2178 "VBNET.ATG" 
+#line  2181 "VBNET.ATG" 
 						memberInitializers.CreateExpressions.Add(memberInitializer); 
 					} else if (StartOf(24)) {
 						Expr(
-//#line  2179 "VBNET.ATG" 
+#line  2182 "VBNET.ATG" 
 out anonymousMember);
 
-//#line  2180 "VBNET.ATG" 
+#line  2183 "VBNET.ATG" 
 						memberInitializers.CreateExpressions.Add(anonymousMember); 
 					} else SynErr(271);
 				}
 				Expect(36);
 
-//#line  2185 "VBNET.ATG" 
+#line  2188 "VBNET.ATG" 
 				memberInitializers.EndLocation = t.Location;
 				if(oce is ObjectCreateExpression)
 				{
@@ -3046,17 +3047,17 @@ out anonymousMember);
 			} else {
 				lexer.NextToken();
 				CollectionInitializer(
-//#line  2195 "VBNET.ATG" 
+#line  2198 "VBNET.ATG" 
 out initializer);
 
-//#line  2197 "VBNET.ATG" 
+#line  2200 "VBNET.ATG" 
 				if(oce is ObjectCreateExpression)
 				((ObjectCreateExpression)oce).ObjectInitializer = initializer;
 				
 			}
 		}
 
-//#line  2203 "VBNET.ATG" 
+#line  2206 "VBNET.ATG" 
 		if (oce != null) {
 		oce.StartLocation = startLocation;
 		oce.EndLocation = t.EndLocation;
@@ -3065,10 +3066,10 @@ out initializer);
 	}
 
 	void AccessorDecls(
-//#line  1372 "VBNET.ATG" 
+#line  1375 "VBNET.ATG" 
 out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 
-//#line  1374 "VBNET.ATG" 
+#line  1377 "VBNET.ATG" 
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		AttributeSection section;
 		getBlock = null;
@@ -3076,60 +3077,60 @@ out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 		
 		while (la.kind == 40) {
 			AttributeSection(
-//#line  1379 "VBNET.ATG" 
+#line  1382 "VBNET.ATG" 
 out section);
 
-//#line  1379 "VBNET.ATG" 
+#line  1382 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		if (StartOf(25)) {
 			GetAccessorDecl(
-//#line  1381 "VBNET.ATG" 
+#line  1384 "VBNET.ATG" 
 out getBlock, attributes);
 			if (StartOf(26)) {
 
-//#line  1383 "VBNET.ATG" 
+#line  1386 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 40) {
 					AttributeSection(
-//#line  1384 "VBNET.ATG" 
+#line  1387 "VBNET.ATG" 
 out section);
 
-//#line  1384 "VBNET.ATG" 
+#line  1387 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				SetAccessorDecl(
-//#line  1385 "VBNET.ATG" 
+#line  1388 "VBNET.ATG" 
 out setBlock, attributes);
 			}
 		} else if (StartOf(27)) {
 			SetAccessorDecl(
-//#line  1388 "VBNET.ATG" 
+#line  1391 "VBNET.ATG" 
 out setBlock, attributes);
 			if (StartOf(28)) {
 
-//#line  1390 "VBNET.ATG" 
+#line  1393 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 40) {
 					AttributeSection(
-//#line  1391 "VBNET.ATG" 
+#line  1394 "VBNET.ATG" 
 out section);
 
-//#line  1391 "VBNET.ATG" 
+#line  1394 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				GetAccessorDecl(
-//#line  1392 "VBNET.ATG" 
+#line  1395 "VBNET.ATG" 
 out getBlock, attributes);
 			}
 		} else SynErr(272);
 	}
 
 	void EventAccessorDeclaration(
-//#line  1335 "VBNET.ATG" 
+#line  1338 "VBNET.ATG" 
 out EventAddRemoveRegion eventAccessorDeclaration) {
 
-//#line  1337 "VBNET.ATG" 
+#line  1340 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		AttributeSection section;
@@ -3138,10 +3139,10 @@ out EventAddRemoveRegion eventAccessorDeclaration) {
 		
 		while (la.kind == 40) {
 			AttributeSection(
-//#line  1343 "VBNET.ATG" 
+#line  1346 "VBNET.ATG" 
 out section);
 
-//#line  1343 "VBNET.ATG" 
+#line  1346 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		if (la.kind == 56) {
@@ -3150,20 +3151,20 @@ out section);
 				lexer.NextToken();
 				if (StartOf(6)) {
 					FormalParameterList(
-//#line  1345 "VBNET.ATG" 
+#line  1348 "VBNET.ATG" 
 p);
 				}
 				Expect(38);
 			}
 			Expect(1);
 			Block(
-//#line  1346 "VBNET.ATG" 
+#line  1349 "VBNET.ATG" 
 out stmt);
 			Expect(113);
 			Expect(56);
 			EndOfStmt();
 
-//#line  1348 "VBNET.ATG" 
+#line  1351 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventAddRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -3174,20 +3175,20 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(6)) {
 					FormalParameterList(
-//#line  1353 "VBNET.ATG" 
+#line  1356 "VBNET.ATG" 
 p);
 				}
 				Expect(38);
 			}
 			Expect(1);
 			Block(
-//#line  1354 "VBNET.ATG" 
+#line  1357 "VBNET.ATG" 
 out stmt);
 			Expect(113);
 			Expect(193);
 			EndOfStmt();
 
-//#line  1356 "VBNET.ATG" 
+#line  1359 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRemoveRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -3198,20 +3199,20 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(6)) {
 					FormalParameterList(
-//#line  1361 "VBNET.ATG" 
+#line  1364 "VBNET.ATG" 
 p);
 				}
 				Expect(38);
 			}
 			Expect(1);
 			Block(
-//#line  1362 "VBNET.ATG" 
+#line  1365 "VBNET.ATG" 
 out stmt);
 			Expect(113);
 			Expect(189);
 			EndOfStmt();
 
-//#line  1364 "VBNET.ATG" 
+#line  1367 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRaiseRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -3220,163 +3221,170 @@ out stmt);
 	}
 
 	void OverloadableOperator(
-//#line  1277 "VBNET.ATG" 
+#line  1278 "VBNET.ATG" 
 out OverloadableOperatorType operatorType) {
 
-//#line  1278 "VBNET.ATG" 
+#line  1279 "VBNET.ATG" 
 		operatorType = OverloadableOperatorType.None; 
 		switch (la.kind) {
 		case 31: {
 			lexer.NextToken();
 
-//#line  1280 "VBNET.ATG" 
+#line  1281 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Add; 
 			break;
 		}
 		case 30: {
 			lexer.NextToken();
 
-//#line  1282 "VBNET.ATG" 
+#line  1283 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Subtract; 
 			break;
 		}
 		case 34: {
 			lexer.NextToken();
 
-//#line  1284 "VBNET.ATG" 
+#line  1285 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Multiply; 
 			break;
 		}
 		case 24: {
 			lexer.NextToken();
 
-//#line  1286 "VBNET.ATG" 
+#line  1287 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Divide; 
 			break;
 		}
 		case 25: {
 			lexer.NextToken();
 
-//#line  1288 "VBNET.ATG" 
+#line  1289 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.DivideInteger; 
 			break;
 		}
 		case 23: {
 			lexer.NextToken();
 
-//#line  1290 "VBNET.ATG" 
+#line  1291 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Concat; 
 			break;
 		}
 		case 150: {
 			lexer.NextToken();
 
-//#line  1292 "VBNET.ATG" 
+#line  1293 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Like; 
 			break;
 		}
 		case 154: {
 			lexer.NextToken();
 
-//#line  1294 "VBNET.ATG" 
+#line  1295 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Modulus; 
 			break;
 		}
 		case 60: {
 			lexer.NextToken();
 
-//#line  1296 "VBNET.ATG" 
+#line  1297 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseAnd; 
 			break;
 		}
 		case 175: {
 			lexer.NextToken();
 
-//#line  1298 "VBNET.ATG" 
+#line  1299 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseOr; 
 			break;
 		}
 		case 236: {
 			lexer.NextToken();
 
-//#line  1300 "VBNET.ATG" 
+#line  1301 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ExclusiveOr; 
 			break;
 		}
+		case 164: {
+			lexer.NextToken();
+
+#line  1303 "VBNET.ATG" 
+			operatorType = OverloadableOperatorType.BitNot; 
+			break;
+		}
 		case 32: {
 			lexer.NextToken();
 
-//#line  1302 "VBNET.ATG" 
+#line  1305 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Power; 
 			break;
 		}
 		case 44: {
 			lexer.NextToken();
 
-//#line  1304 "VBNET.ATG" 
+#line  1307 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftLeft; 
 			break;
 		}
 		case 45: {
 			lexer.NextToken();
 
-//#line  1306 "VBNET.ATG" 
+#line  1309 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftRight; 
 			break;
 		}
 		case 20: {
 			lexer.NextToken();
 
-//#line  1308 "VBNET.ATG" 
+#line  1311 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Equality; 
 			break;
 		}
 		case 41: {
 			lexer.NextToken();
 
-//#line  1310 "VBNET.ATG" 
+#line  1313 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.InEquality; 
 			break;
 		}
 		case 40: {
 			lexer.NextToken();
 
-//#line  1312 "VBNET.ATG" 
+#line  1315 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThan; 
 			break;
 		}
 		case 43: {
 			lexer.NextToken();
 
-//#line  1314 "VBNET.ATG" 
+#line  1317 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThanOrEqual; 
 			break;
 		}
 		case 39: {
 			lexer.NextToken();
 
-//#line  1316 "VBNET.ATG" 
+#line  1319 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThan; 
 			break;
 		}
 		case 42: {
 			lexer.NextToken();
 
-//#line  1318 "VBNET.ATG" 
+#line  1321 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThanOrEqual; 
 			break;
 		}
 		case 94: {
 			lexer.NextToken();
 
-//#line  1320 "VBNET.ATG" 
+#line  1323 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.CType; 
 			break;
 		}
 		case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 98: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
 			Identifier();
 
-//#line  1324 "VBNET.ATG" 
+#line  1327 "VBNET.ATG" 
 			string opName = t.val; 
 			if (string.Equals(opName, "istrue", StringComparison.InvariantCultureIgnoreCase)) {
 				operatorType = OverloadableOperatorType.IsTrue;
@@ -3393,10 +3401,10 @@ out OverloadableOperatorType operatorType) {
 	}
 
 	void FormalParameter(
-//#line  2948 "VBNET.ATG" 
+#line  2951 "VBNET.ATG" 
 out ParameterDeclarationExpression p) {
 
-//#line  2950 "VBNET.ATG" 
+#line  2953 "VBNET.ATG" 
 		AttributeSection section;
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		TypeReference type = null;
@@ -3408,36 +3416,36 @@ out ParameterDeclarationExpression p) {
 		
 		while (la.kind == 40) {
 			AttributeSection(
-//#line  2960 "VBNET.ATG" 
+#line  2963 "VBNET.ATG" 
 out section);
 
-//#line  2960 "VBNET.ATG" 
+#line  2963 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		while (StartOf(29)) {
 			ParameterModifier(
-//#line  2961 "VBNET.ATG" 
+#line  2964 "VBNET.ATG" 
 mod);
 		}
 		Identifier();
 
-//#line  2962 "VBNET.ATG" 
+#line  2965 "VBNET.ATG" 
 		string parameterName = t.val; 
 		if (
-//#line  2963 "VBNET.ATG" 
+#line  2966 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-//#line  2963 "VBNET.ATG" 
+#line  2966 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-//#line  2964 "VBNET.ATG" 
+#line  2967 "VBNET.ATG" 
 out type);
 		}
 
-//#line  2966 "VBNET.ATG" 
+#line  2969 "VBNET.ATG" 
 		if(type != null) {
 		if (arrayModifiers != null) {
 			if (type.RankSpecifier != null) {
@@ -3451,11 +3459,11 @@ out type);
 		if (la.kind == 20) {
 			lexer.NextToken();
 			Expr(
-//#line  2976 "VBNET.ATG" 
+#line  2979 "VBNET.ATG" 
 out expr);
 		}
 
-//#line  2978 "VBNET.ATG" 
+#line  2981 "VBNET.ATG" 
 		mod.Check();
 		p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
 		p.Attributes = attributes;
@@ -3465,67 +3473,67 @@ out expr);
 	}
 
 	void GetAccessorDecl(
-//#line  1398 "VBNET.ATG" 
+#line  1401 "VBNET.ATG" 
 out PropertyGetRegion getBlock, List<AttributeSection> attributes) {
 
-//#line  1399 "VBNET.ATG" 
+#line  1402 "VBNET.ATG" 
 		Statement stmt = null; Modifiers m; 
 		PropertyAccessorAccessModifier(
-//#line  1401 "VBNET.ATG" 
+#line  1404 "VBNET.ATG" 
 out m);
 		Expect(128);
 
-//#line  1403 "VBNET.ATG" 
+#line  1406 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		Expect(1);
 		Block(
-//#line  1405 "VBNET.ATG" 
+#line  1408 "VBNET.ATG" 
 out stmt);
 
-//#line  1406 "VBNET.ATG" 
+#line  1409 "VBNET.ATG" 
 		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); 
 		Expect(113);
 		Expect(128);
 
-//#line  1408 "VBNET.ATG" 
+#line  1411 "VBNET.ATG" 
 		getBlock.Modifier = m; 
 
-//#line  1409 "VBNET.ATG" 
+#line  1412 "VBNET.ATG" 
 		getBlock.StartLocation = startLocation; getBlock.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void SetAccessorDecl(
-//#line  1414 "VBNET.ATG" 
+#line  1417 "VBNET.ATG" 
 out PropertySetRegion setBlock, List<AttributeSection> attributes) {
 
-//#line  1416 "VBNET.ATG" 
+#line  1419 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		Modifiers m;
 		
 		PropertyAccessorAccessModifier(
-//#line  1421 "VBNET.ATG" 
+#line  1424 "VBNET.ATG" 
 out m);
 		Expect(198);
 
-//#line  1423 "VBNET.ATG" 
+#line  1426 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		if (la.kind == 37) {
 			lexer.NextToken();
 			if (StartOf(6)) {
 				FormalParameterList(
-//#line  1424 "VBNET.ATG" 
+#line  1427 "VBNET.ATG" 
 p);
 			}
 			Expect(38);
 		}
 		Expect(1);
 		Block(
-//#line  1426 "VBNET.ATG" 
+#line  1429 "VBNET.ATG" 
 out stmt);
 
-//#line  1428 "VBNET.ATG" 
+#line  1431 "VBNET.ATG" 
 		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
 		setBlock.Modifier = m;
 		setBlock.Parameters = p;
@@ -3533,116 +3541,116 @@ out stmt);
 		Expect(113);
 		Expect(198);
 
-//#line  1433 "VBNET.ATG" 
+#line  1436 "VBNET.ATG" 
 		setBlock.StartLocation = startLocation; setBlock.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void PropertyAccessorAccessModifier(
-//#line  3742 "VBNET.ATG" 
+#line  3745 "VBNET.ATG" 
 out Modifiers m) {
 
-//#line  3743 "VBNET.ATG" 
+#line  3746 "VBNET.ATG" 
 		m = Modifiers.None; 
 		while (StartOf(30)) {
 			if (la.kind == 188) {
 				lexer.NextToken();
 
-//#line  3745 "VBNET.ATG" 
+#line  3748 "VBNET.ATG" 
 				m |= Modifiers.Public; 
 			} else if (la.kind == 187) {
 				lexer.NextToken();
 
-//#line  3746 "VBNET.ATG" 
+#line  3749 "VBNET.ATG" 
 				m |= Modifiers.Protected; 
 			} else if (la.kind == 125) {
 				lexer.NextToken();
 
-//#line  3747 "VBNET.ATG" 
+#line  3750 "VBNET.ATG" 
 				m |= Modifiers.Internal; 
 			} else {
 				lexer.NextToken();
 
-//#line  3748 "VBNET.ATG" 
+#line  3751 "VBNET.ATG" 
 				m |= Modifiers.Private; 
 			}
 		}
 	}
 
 	void ArrayInitializationModifier(
-//#line  1531 "VBNET.ATG" 
+#line  1534 "VBNET.ATG" 
 out List<Expression> arrayModifiers) {
 
-//#line  1533 "VBNET.ATG" 
+#line  1536 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		Expect(37);
 		InitializationRankList(
-//#line  1535 "VBNET.ATG" 
+#line  1538 "VBNET.ATG" 
 out arrayModifiers);
 		Expect(38);
 	}
 
 	void ArrayNameModifier(
-//#line  2775 "VBNET.ATG" 
+#line  2778 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-//#line  2777 "VBNET.ATG" 
+#line  2780 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		ArrayTypeModifiers(
-//#line  2779 "VBNET.ATG" 
+#line  2782 "VBNET.ATG" 
 out arrayModifiers);
 	}
 
 	void InitializationRankList(
-//#line  1539 "VBNET.ATG" 
+#line  1542 "VBNET.ATG" 
 out List<Expression> rank) {
 
-//#line  1541 "VBNET.ATG" 
+#line  1544 "VBNET.ATG" 
 		rank = new List<Expression>();
 		Expression expr = null;
 		
 		Expr(
-//#line  1544 "VBNET.ATG" 
+#line  1547 "VBNET.ATG" 
 out expr);
 		if (la.kind == 216) {
 			lexer.NextToken();
 
-//#line  1545 "VBNET.ATG" 
+#line  1548 "VBNET.ATG" 
 			EnsureIsZero(expr); 
 			Expr(
-//#line  1546 "VBNET.ATG" 
+#line  1549 "VBNET.ATG" 
 out expr);
 		}
 
-//#line  1548 "VBNET.ATG" 
+#line  1551 "VBNET.ATG" 
 		if (expr != null) { rank.Add(expr); } 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			Expr(
-//#line  1550 "VBNET.ATG" 
+#line  1553 "VBNET.ATG" 
 out expr);
 			if (la.kind == 216) {
 				lexer.NextToken();
 
-//#line  1551 "VBNET.ATG" 
+#line  1554 "VBNET.ATG" 
 				EnsureIsZero(expr); 
 				Expr(
-//#line  1552 "VBNET.ATG" 
+#line  1555 "VBNET.ATG" 
 out expr);
 			}
 
-//#line  1554 "VBNET.ATG" 
+#line  1557 "VBNET.ATG" 
 			if (expr != null) { rank.Add(expr); } 
 		}
 	}
 
 	void CollectionInitializer(
-//#line  1559 "VBNET.ATG" 
+#line  1562 "VBNET.ATG" 
 out CollectionInitializerExpression outExpr) {
 
-//#line  1561 "VBNET.ATG" 
+#line  1564 "VBNET.ATG" 
 		Expression expr = null;
 		CollectionInitializerExpression initializer = new CollectionInitializerExpression();
 		Location startLocation = la.Location;
@@ -3650,27 +3658,27 @@ out CollectionInitializerExpression outExpr) {
 		Expect(35);
 		if (StartOf(24)) {
 			Expr(
-//#line  1567 "VBNET.ATG" 
+#line  1570 "VBNET.ATG" 
 out expr);
 
-//#line  1569 "VBNET.ATG" 
+#line  1572 "VBNET.ATG" 
 			if (expr != null) { initializer.CreateExpressions.Add(expr); }
 			
 			while (
-//#line  1572 "VBNET.ATG" 
+#line  1575 "VBNET.ATG" 
 NotFinalComma()) {
 				Expect(22);
 				Expr(
-//#line  1572 "VBNET.ATG" 
+#line  1575 "VBNET.ATG" 
 out expr);
 
-//#line  1573 "VBNET.ATG" 
+#line  1576 "VBNET.ATG" 
 				if (expr != null) { initializer.CreateExpressions.Add(expr); } 
 			}
 		}
 		Expect(36);
 
-//#line  1578 "VBNET.ATG" 
+#line  1581 "VBNET.ATG" 
 		outExpr = initializer;
 		outExpr.StartLocation = startLocation;
 		outExpr.EndLocation = t.EndLocation;
@@ -3678,10 +3686,10 @@ out expr);
 	}
 
 	void EventMemberSpecifier(
-//#line  1651 "VBNET.ATG" 
+#line  1654 "VBNET.ATG" 
 out string name) {
 
-//#line  1652 "VBNET.ATG" 
+#line  1655 "VBNET.ATG" 
 		string eventName; 
 		if (StartOf(4)) {
 			Identifier();
@@ -3691,182 +3699,182 @@ out string name) {
 			lexer.NextToken();
 		} else SynErr(275);
 
-//#line  1655 "VBNET.ATG" 
+#line  1658 "VBNET.ATG" 
 		name = t.val; 
 		Expect(26);
 		IdentifierOrKeyword(
-//#line  1657 "VBNET.ATG" 
+#line  1660 "VBNET.ATG" 
 out eventName);
 
-//#line  1658 "VBNET.ATG" 
+#line  1661 "VBNET.ATG" 
 		name = name + "." + eventName; 
 	}
 
 	void IdentifierOrKeyword(
-//#line  3675 "VBNET.ATG" 
+#line  3678 "VBNET.ATG" 
 out string name) {
 		lexer.NextToken();
 
-//#line  3677 "VBNET.ATG" 
+#line  3680 "VBNET.ATG" 
 		name = t.val;  
 	}
 
 	void QueryExpr(
-//#line  2296 "VBNET.ATG" 
+#line  2299 "VBNET.ATG" 
 out Expression expr) {
 
-//#line  2298 "VBNET.ATG" 
+#line  2301 "VBNET.ATG" 
 		QueryExpressionVB qexpr = new QueryExpressionVB();
 		qexpr.StartLocation = la.Location;
 		expr = qexpr;
 		
 		FromOrAggregateQueryOperator(
-//#line  2302 "VBNET.ATG" 
+#line  2305 "VBNET.ATG" 
 qexpr.Clauses);
 		while (StartOf(31)) {
 			QueryOperator(
-//#line  2303 "VBNET.ATG" 
+#line  2306 "VBNET.ATG" 
 qexpr.Clauses);
 		}
 
-//#line  2305 "VBNET.ATG" 
+#line  2308 "VBNET.ATG" 
 		qexpr.EndLocation = t.EndLocation;
 		
 	}
 
 	void LambdaExpr(
-//#line  2210 "VBNET.ATG" 
+#line  2213 "VBNET.ATG" 
 out Expression expr) {
 
-//#line  2212 "VBNET.ATG" 
+#line  2215 "VBNET.ATG" 
 		LambdaExpression lambda = null;
 		
 		if (la.kind == 210) {
 			SubLambdaExpression(
-//#line  2214 "VBNET.ATG" 
+#line  2217 "VBNET.ATG" 
 out lambda);
 		} else if (la.kind == 127) {
 			FunctionLambdaExpression(
-//#line  2215 "VBNET.ATG" 
+#line  2218 "VBNET.ATG" 
 out lambda);
 		} else SynErr(276);
 
-//#line  2216 "VBNET.ATG" 
+#line  2219 "VBNET.ATG" 
 		expr = lambda; 
 	}
 
 	void DisjunctionExpr(
-//#line  1960 "VBNET.ATG" 
+#line  1963 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  1962 "VBNET.ATG" 
+#line  1965 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		Location startLocation = la.Location;
 		
 		ConjunctionExpr(
-//#line  1966 "VBNET.ATG" 
+#line  1969 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 175 || la.kind == 177 || la.kind == 236) {
 			if (la.kind == 175) {
 				lexer.NextToken();
 
-//#line  1969 "VBNET.ATG" 
+#line  1972 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseOr; 
 			} else if (la.kind == 177) {
 				lexer.NextToken();
 
-//#line  1970 "VBNET.ATG" 
+#line  1973 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalOr; 
 			} else {
 				lexer.NextToken();
 
-//#line  1971 "VBNET.ATG" 
+#line  1974 "VBNET.ATG" 
 				op = BinaryOperatorType.ExclusiveOr; 
 			}
 			ConjunctionExpr(
-//#line  1973 "VBNET.ATG" 
+#line  1976 "VBNET.ATG" 
 out expr);
 
-//#line  1973 "VBNET.ATG" 
+#line  1976 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void AssignmentOperator(
-//#line  1678 "VBNET.ATG" 
+#line  1681 "VBNET.ATG" 
 out AssignmentOperatorType op) {
 
-//#line  1679 "VBNET.ATG" 
+#line  1682 "VBNET.ATG" 
 		op = AssignmentOperatorType.None; 
 		switch (la.kind) {
 		case 20: {
 			lexer.NextToken();
 
-//#line  1680 "VBNET.ATG" 
+#line  1683 "VBNET.ATG" 
 			op = AssignmentOperatorType.Assign; 
 			break;
 		}
 		case 54: {
 			lexer.NextToken();
 
-//#line  1681 "VBNET.ATG" 
+#line  1684 "VBNET.ATG" 
 			op = AssignmentOperatorType.ConcatString; 
 			break;
 		}
 		case 46: {
 			lexer.NextToken();
 
-//#line  1682 "VBNET.ATG" 
+#line  1685 "VBNET.ATG" 
 			op = AssignmentOperatorType.Add; 
 			break;
 		}
 		case 48: {
 			lexer.NextToken();
 
-//#line  1683 "VBNET.ATG" 
+#line  1686 "VBNET.ATG" 
 			op = AssignmentOperatorType.Subtract; 
 			break;
 		}
 		case 49: {
 			lexer.NextToken();
 
-//#line  1684 "VBNET.ATG" 
+#line  1687 "VBNET.ATG" 
 			op = AssignmentOperatorType.Multiply; 
 			break;
 		}
 		case 50: {
 			lexer.NextToken();
 
-//#line  1685 "VBNET.ATG" 
+#line  1688 "VBNET.ATG" 
 			op = AssignmentOperatorType.Divide; 
 			break;
 		}
 		case 51: {
 			lexer.NextToken();
 
-//#line  1686 "VBNET.ATG" 
+#line  1689 "VBNET.ATG" 
 			op = AssignmentOperatorType.DivideInteger; 
 			break;
 		}
 		case 47: {
 			lexer.NextToken();
 
-//#line  1687 "VBNET.ATG" 
+#line  1690 "VBNET.ATG" 
 			op = AssignmentOperatorType.Power; 
 			break;
 		}
 		case 52: {
 			lexer.NextToken();
 
-//#line  1688 "VBNET.ATG" 
+#line  1691 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftLeft; 
 			break;
 		}
 		case 53: {
 			lexer.NextToken();
 
-//#line  1689 "VBNET.ATG" 
+#line  1692 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftRight; 
 			break;
 		}
@@ -3875,13 +3883,13 @@ out AssignmentOperatorType op) {
 	}
 
 	void SimpleExpr(
-//#line  1693 "VBNET.ATG" 
+#line  1696 "VBNET.ATG" 
 out Expression pexpr) {
 
-//#line  1694 "VBNET.ATG" 
+#line  1697 "VBNET.ATG" 
 		string name; Location startLocation = la.Location; 
 		SimpleNonInvocationExpression(
-//#line  1697 "VBNET.ATG" 
+#line  1700 "VBNET.ATG" 
 out pexpr);
 		while (StartOf(32)) {
 			if (la.kind == 26) {
@@ -3889,73 +3897,73 @@ out pexpr);
 				if (la.kind == 10) {
 					lexer.NextToken();
 					IdentifierOrKeyword(
-//#line  1700 "VBNET.ATG" 
+#line  1703 "VBNET.ATG" 
 out name);
 					Expect(11);
 
-//#line  1701 "VBNET.ATG" 
+#line  1704 "VBNET.ATG" 
 					pexpr = new XmlMemberAccessExpression(pexpr, XmlAxisType.Element, name, true); 
 				} else if (StartOf(33)) {
 					IdentifierOrKeyword(
-//#line  1702 "VBNET.ATG" 
+#line  1705 "VBNET.ATG" 
 out name);
 
-//#line  1703 "VBNET.ATG" 
+#line  1706 "VBNET.ATG" 
 					pexpr = new MemberReferenceExpression(pexpr, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 				} else SynErr(278);
 				if (
-//#line  1705 "VBNET.ATG" 
+#line  1708 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 					lexer.NextToken();
 					Expect(169);
 					TypeArgumentList(
-//#line  1706 "VBNET.ATG" 
+#line  1709 "VBNET.ATG" 
 ((MemberReferenceExpression)pexpr).TypeArguments);
 					Expect(38);
 				}
 			} else if (la.kind == 29) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-//#line  1708 "VBNET.ATG" 
+#line  1711 "VBNET.ATG" 
 out name);
 
-//#line  1708 "VBNET.ATG" 
+#line  1711 "VBNET.ATG" 
 				pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); 
 			} else if (la.kind == 27 || la.kind == 28) {
 
-//#line  1709 "VBNET.ATG" 
+#line  1712 "VBNET.ATG" 
 				XmlAxisType type = XmlAxisType.Attribute; bool isXmlName = false; 
 				if (la.kind == 28) {
 					lexer.NextToken();
 				} else if (la.kind == 27) {
 					lexer.NextToken();
 
-//#line  1710 "VBNET.ATG" 
+#line  1713 "VBNET.ATG" 
 					type = XmlAxisType.Descendents; 
 				} else SynErr(279);
 				if (la.kind == 10) {
 					lexer.NextToken();
 
-//#line  1710 "VBNET.ATG" 
+#line  1713 "VBNET.ATG" 
 					isXmlName = true; 
 				}
 				IdentifierOrKeyword(
-//#line  1710 "VBNET.ATG" 
+#line  1713 "VBNET.ATG" 
 out name);
 				if (la.kind == 11) {
 					lexer.NextToken();
 				}
 
-//#line  1711 "VBNET.ATG" 
+#line  1714 "VBNET.ATG" 
 				pexpr = new XmlMemberAccessExpression(pexpr, type, name, isXmlName); 
 			} else {
 				InvocationExpression(
-//#line  1712 "VBNET.ATG" 
+#line  1715 "VBNET.ATG" 
 ref pexpr);
 			}
 		}
 
-//#line  1716 "VBNET.ATG" 
+#line  1719 "VBNET.ATG" 
 		if (pexpr != null) {
 		pexpr.StartLocation = startLocation;
 		pexpr.EndLocation = t.EndLocation;
@@ -3964,10 +3972,10 @@ ref pexpr);
 	}
 
 	void SimpleNonInvocationExpression(
-//#line  1723 "VBNET.ATG" 
+#line  1726 "VBNET.ATG" 
 out Expression pexpr) {
 
-//#line  1725 "VBNET.ATG" 
+#line  1728 "VBNET.ATG" 
 		Expression expr;
 		CollectionInitializerExpression cie;
 		TypeReference type = null;
@@ -3980,98 +3988,98 @@ out Expression pexpr) {
 			case 3: {
 				lexer.NextToken();
 
-//#line  1735 "VBNET.ATG" 
+#line  1738 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 4: {
 				lexer.NextToken();
 
-//#line  1736 "VBNET.ATG" 
+#line  1739 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 7: {
 				lexer.NextToken();
 
-//#line  1737 "VBNET.ATG" 
+#line  1740 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 6: {
 				lexer.NextToken();
 
-//#line  1738 "VBNET.ATG" 
+#line  1741 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 5: {
 				lexer.NextToken();
 
-//#line  1739 "VBNET.ATG" 
+#line  1742 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 9: {
 				lexer.NextToken();
 
-//#line  1740 "VBNET.ATG" 
+#line  1743 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 8: {
 				lexer.NextToken();
 
-//#line  1741 "VBNET.ATG" 
+#line  1744 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 217: {
 				lexer.NextToken();
 
-//#line  1743 "VBNET.ATG" 
+#line  1746 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(true, "true");  
 				break;
 			}
 			case 122: {
 				lexer.NextToken();
 
-//#line  1744 "VBNET.ATG" 
+#line  1747 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(false, "false"); 
 				break;
 			}
 			case 165: {
 				lexer.NextToken();
 
-//#line  1745 "VBNET.ATG" 
+#line  1748 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(null, "null");  
 				break;
 			}
 			case 37: {
 				lexer.NextToken();
 				Expr(
-//#line  1746 "VBNET.ATG" 
+#line  1749 "VBNET.ATG" 
 out expr);
 				Expect(38);
 
-//#line  1746 "VBNET.ATG" 
+#line  1749 "VBNET.ATG" 
 				pexpr = new ParenthesizedExpression(expr); 
 				break;
 			}
 			case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 98: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
 				Identifier();
 
-//#line  1748 "VBNET.ATG" 
+#line  1751 "VBNET.ATG" 
 				pexpr = new IdentifierExpression(t.val);
 				pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
 				
 				if (
-//#line  1751 "VBNET.ATG" 
+#line  1754 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 					lexer.NextToken();
 					Expect(169);
 					TypeArgumentList(
-//#line  1752 "VBNET.ATG" 
+#line  1755 "VBNET.ATG" 
 ((IdentifierExpression)pexpr).TypeArguments);
 					Expect(38);
 				}
@@ -4079,51 +4087,51 @@ la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			}
 			case 68: case 71: case 82: case 99: case 100: case 109: case 141: case 151: case 168: case 196: case 201: case 202: case 208: case 221: case 222: case 225: {
 
-//#line  1754 "VBNET.ATG" 
+#line  1757 "VBNET.ATG" 
 				string val = String.Empty; 
 				if (StartOf(12)) {
 					PrimitiveTypeName(
-//#line  1755 "VBNET.ATG" 
+#line  1758 "VBNET.ATG" 
 out val);
 				} else if (la.kind == 168) {
 					lexer.NextToken();
 
-//#line  1755 "VBNET.ATG" 
+#line  1758 "VBNET.ATG" 
 					val = "System.Object"; 
 				} else SynErr(280);
 
-//#line  1756 "VBNET.ATG" 
+#line  1759 "VBNET.ATG" 
 				pexpr = new TypeReferenceExpression(new TypeReference(val, true)); 
 				break;
 			}
 			case 153: {
 				lexer.NextToken();
 
-//#line  1757 "VBNET.ATG" 
+#line  1760 "VBNET.ATG" 
 				pexpr = new ThisReferenceExpression(); 
 				break;
 			}
 			case 158: case 159: {
 
-//#line  1758 "VBNET.ATG" 
+#line  1761 "VBNET.ATG" 
 				Expression retExpr = null; 
 				if (la.kind == 158) {
 					lexer.NextToken();
 
-//#line  1759 "VBNET.ATG" 
+#line  1762 "VBNET.ATG" 
 					retExpr = new BaseReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation }; 
 				} else if (la.kind == 159) {
 					lexer.NextToken();
 
-//#line  1760 "VBNET.ATG" 
+#line  1763 "VBNET.ATG" 
 					retExpr = new ClassReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation }; 
 				} else SynErr(281);
 				Expect(26);
 				IdentifierOrKeyword(
-//#line  1762 "VBNET.ATG" 
+#line  1765 "VBNET.ATG" 
 out name);
 
-//#line  1762 "VBNET.ATG" 
+#line  1765 "VBNET.ATG" 
 				pexpr = new MemberReferenceExpression(retExpr, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 				break;
 			}
@@ -4132,86 +4140,86 @@ out name);
 				Expect(26);
 				Identifier();
 
-//#line  1764 "VBNET.ATG" 
+#line  1767 "VBNET.ATG" 
 				type = new TypeReference(t.val ?? ""); 
 
-//#line  1766 "VBNET.ATG" 
+#line  1769 "VBNET.ATG" 
 				type.IsGlobal = true; 
 
-//#line  1767 "VBNET.ATG" 
+#line  1770 "VBNET.ATG" 
 				pexpr = new TypeReferenceExpression(type); 
 				break;
 			}
 			case 162: {
 				ObjectCreateExpression(
-//#line  1768 "VBNET.ATG" 
+#line  1771 "VBNET.ATG" 
 out expr);
 
-//#line  1768 "VBNET.ATG" 
+#line  1771 "VBNET.ATG" 
 				pexpr = expr; 
 				break;
 			}
 			case 35: {
 				CollectionInitializer(
-//#line  1769 "VBNET.ATG" 
+#line  1772 "VBNET.ATG" 
 out cie);
 
-//#line  1769 "VBNET.ATG" 
+#line  1772 "VBNET.ATG" 
 				pexpr = cie; 
 				break;
 			}
 			case 94: case 106: case 219: {
 
-//#line  1771 "VBNET.ATG" 
+#line  1774 "VBNET.ATG" 
 				CastType castType = CastType.Cast; 
 				if (la.kind == 106) {
 					lexer.NextToken();
 				} else if (la.kind == 94) {
 					lexer.NextToken();
 
-//#line  1773 "VBNET.ATG" 
+#line  1776 "VBNET.ATG" 
 					castType = CastType.Conversion; 
 				} else if (la.kind == 219) {
 					lexer.NextToken();
 
-//#line  1774 "VBNET.ATG" 
+#line  1777 "VBNET.ATG" 
 					castType = CastType.TryCast; 
 				} else SynErr(282);
 				Expect(37);
 				Expr(
-//#line  1776 "VBNET.ATG" 
+#line  1779 "VBNET.ATG" 
 out expr);
 				Expect(22);
 				TypeName(
-//#line  1776 "VBNET.ATG" 
+#line  1779 "VBNET.ATG" 
 out type);
 				Expect(38);
 
-//#line  1777 "VBNET.ATG" 
+#line  1780 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, castType); 
 				break;
 			}
 			case 76: case 77: case 78: case 79: case 80: case 81: case 83: case 85: case 86: case 90: case 91: case 92: case 93: case 95: case 96: case 97: {
 				CastTarget(
-//#line  1778 "VBNET.ATG" 
+#line  1781 "VBNET.ATG" 
 out type);
 				Expect(37);
 				Expr(
-//#line  1778 "VBNET.ATG" 
+#line  1781 "VBNET.ATG" 
 out expr);
 				Expect(38);
 
-//#line  1778 "VBNET.ATG" 
+#line  1781 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); 
 				break;
 			}
 			case 57: {
 				lexer.NextToken();
 				Expr(
-//#line  1779 "VBNET.ATG" 
+#line  1782 "VBNET.ATG" 
 out expr);
 
-//#line  1779 "VBNET.ATG" 
+#line  1782 "VBNET.ATG" 
 				pexpr = new AddressOfExpression(expr); 
 				break;
 			}
@@ -4219,37 +4227,37 @@ out expr);
 				lexer.NextToken();
 				Expect(37);
 				GetTypeTypeName(
-//#line  1780 "VBNET.ATG" 
+#line  1783 "VBNET.ATG" 
 out type);
 				Expect(38);
 
-//#line  1780 "VBNET.ATG" 
+#line  1783 "VBNET.ATG" 
 				pexpr = new TypeOfExpression(type); 
 				break;
 			}
 			case 220: {
 				lexer.NextToken();
 				SimpleExpr(
-//#line  1781 "VBNET.ATG" 
+#line  1784 "VBNET.ATG" 
 out expr);
 				Expect(144);
 				TypeName(
-//#line  1781 "VBNET.ATG" 
+#line  1784 "VBNET.ATG" 
 out type);
 
-//#line  1781 "VBNET.ATG" 
+#line  1784 "VBNET.ATG" 
 				pexpr = new TypeOfIsExpression(expr, type); 
 				break;
 			}
 			case 135: {
 				ConditionalExpression(
-//#line  1782 "VBNET.ATG" 
+#line  1785 "VBNET.ATG" 
 out pexpr);
 				break;
 			}
 			case 10: case 16: case 17: case 18: case 19: {
 				XmlLiteralExpression(
-//#line  1783 "VBNET.ATG" 
+#line  1786 "VBNET.ATG" 
 out pexpr);
 				break;
 			}
@@ -4260,62 +4268,62 @@ out pexpr);
 				if (la.kind == 10) {
 					lexer.NextToken();
 					IdentifierOrKeyword(
-//#line  1789 "VBNET.ATG" 
+#line  1792 "VBNET.ATG" 
 out name);
 					Expect(11);
 
-//#line  1790 "VBNET.ATG" 
+#line  1793 "VBNET.ATG" 
 					pexpr = new XmlMemberAccessExpression(null, XmlAxisType.Element, name, true) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 				} else if (StartOf(33)) {
 					IdentifierOrKeyword(
-//#line  1791 "VBNET.ATG" 
+#line  1794 "VBNET.ATG" 
 out name);
 
-//#line  1792 "VBNET.ATG" 
+#line  1795 "VBNET.ATG" 
 					pexpr = new MemberReferenceExpression(null, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 				} else SynErr(283);
 			} else if (la.kind == 29) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-//#line  1794 "VBNET.ATG" 
+#line  1797 "VBNET.ATG" 
 out name);
 
-//#line  1794 "VBNET.ATG" 
+#line  1797 "VBNET.ATG" 
 				pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); 
 			} else {
 
-//#line  1795 "VBNET.ATG" 
+#line  1798 "VBNET.ATG" 
 				XmlAxisType axisType = XmlAxisType.Element; bool isXmlIdentifier = false; 
 				if (la.kind == 27) {
 					lexer.NextToken();
 
-//#line  1796 "VBNET.ATG" 
+#line  1799 "VBNET.ATG" 
 					axisType = XmlAxisType.Descendents; 
 				} else if (la.kind == 28) {
 					lexer.NextToken();
 
-//#line  1796 "VBNET.ATG" 
+#line  1799 "VBNET.ATG" 
 					axisType = XmlAxisType.Attribute; 
 				} else SynErr(284);
 				if (la.kind == 10) {
 					lexer.NextToken();
 
-//#line  1797 "VBNET.ATG" 
+#line  1800 "VBNET.ATG" 
 					isXmlIdentifier = true; 
 				}
 				IdentifierOrKeyword(
-//#line  1797 "VBNET.ATG" 
+#line  1800 "VBNET.ATG" 
 out name);
 				if (la.kind == 11) {
 					lexer.NextToken();
 				}
 
-//#line  1798 "VBNET.ATG" 
+#line  1801 "VBNET.ATG" 
 				pexpr = new XmlMemberAccessExpression(null, axisType, name, isXmlIdentifier); 
 			}
 		} else SynErr(285);
 
-//#line  1803 "VBNET.ATG" 
+#line  1806 "VBNET.ATG" 
 		if (pexpr != null) {
 		pexpr.StartLocation = startLocation;
 		pexpr.EndLocation = t.EndLocation;
@@ -4324,161 +4332,161 @@ out name);
 	}
 
 	void TypeArgumentList(
-//#line  2811 "VBNET.ATG" 
+#line  2814 "VBNET.ATG" 
 List<TypeReference> typeArguments) {
 
-//#line  2813 "VBNET.ATG" 
+#line  2816 "VBNET.ATG" 
 		TypeReference typeref;
 		
 		TypeName(
-//#line  2815 "VBNET.ATG" 
+#line  2818 "VBNET.ATG" 
 out typeref);
 
-//#line  2815 "VBNET.ATG" 
+#line  2818 "VBNET.ATG" 
 		if (typeref != null) typeArguments.Add(typeref); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			TypeName(
-//#line  2818 "VBNET.ATG" 
+#line  2821 "VBNET.ATG" 
 out typeref);
 
-//#line  2818 "VBNET.ATG" 
+#line  2821 "VBNET.ATG" 
 			if (typeref != null) typeArguments.Add(typeref); 
 		}
 	}
 
 	void InvocationExpression(
-//#line  1924 "VBNET.ATG" 
+#line  1927 "VBNET.ATG" 
 ref Expression pexpr) {
 
-//#line  1925 "VBNET.ATG" 
+#line  1928 "VBNET.ATG" 
 		List<Expression> parameters = null; 
 		Expect(37);
 
-//#line  1927 "VBNET.ATG" 
+#line  1930 "VBNET.ATG" 
 		Location start = t.Location; 
 		ArgumentList(
-//#line  1928 "VBNET.ATG" 
+#line  1931 "VBNET.ATG" 
 out parameters);
 		Expect(38);
 
-//#line  1931 "VBNET.ATG" 
+#line  1934 "VBNET.ATG" 
 		pexpr = new InvocationExpression(pexpr, parameters);
 		
 
-//#line  1933 "VBNET.ATG" 
+#line  1936 "VBNET.ATG" 
 		pexpr.StartLocation = start; pexpr.EndLocation = t.Location; 
 	}
 
 	void PrimitiveTypeName(
-//#line  3682 "VBNET.ATG" 
+#line  3685 "VBNET.ATG" 
 out string type) {
 
-//#line  3683 "VBNET.ATG" 
+#line  3686 "VBNET.ATG" 
 		type = String.Empty; 
 		switch (la.kind) {
 		case 68: {
 			lexer.NextToken();
 
-//#line  3684 "VBNET.ATG" 
+#line  3687 "VBNET.ATG" 
 			type = "System.Boolean"; 
 			break;
 		}
 		case 99: {
 			lexer.NextToken();
 
-//#line  3685 "VBNET.ATG" 
+#line  3688 "VBNET.ATG" 
 			type = "System.DateTime"; 
 			break;
 		}
 		case 82: {
 			lexer.NextToken();
 
-//#line  3686 "VBNET.ATG" 
+#line  3689 "VBNET.ATG" 
 			type = "System.Char"; 
 			break;
 		}
 		case 208: {
 			lexer.NextToken();
 
-//#line  3687 "VBNET.ATG" 
+#line  3690 "VBNET.ATG" 
 			type = "System.String"; 
 			break;
 		}
 		case 100: {
 			lexer.NextToken();
 
-//#line  3688 "VBNET.ATG" 
+#line  3691 "VBNET.ATG" 
 			type = "System.Decimal"; 
 			break;
 		}
 		case 71: {
 			lexer.NextToken();
 
-//#line  3689 "VBNET.ATG" 
+#line  3692 "VBNET.ATG" 
 			type = "System.Byte"; 
 			break;
 		}
 		case 201: {
 			lexer.NextToken();
 
-//#line  3690 "VBNET.ATG" 
+#line  3693 "VBNET.ATG" 
 			type = "System.Int16"; 
 			break;
 		}
 		case 141: {
 			lexer.NextToken();
 
-//#line  3691 "VBNET.ATG" 
+#line  3694 "VBNET.ATG" 
 			type = "System.Int32"; 
 			break;
 		}
 		case 151: {
 			lexer.NextToken();
 
-//#line  3692 "VBNET.ATG" 
+#line  3695 "VBNET.ATG" 
 			type = "System.Int64"; 
 			break;
 		}
 		case 202: {
 			lexer.NextToken();
 
-//#line  3693 "VBNET.ATG" 
+#line  3696 "VBNET.ATG" 
 			type = "System.Single"; 
 			break;
 		}
 		case 109: {
 			lexer.NextToken();
 
-//#line  3694 "VBNET.ATG" 
+#line  3697 "VBNET.ATG" 
 			type = "System.Double"; 
 			break;
 		}
 		case 221: {
 			lexer.NextToken();
 
-//#line  3695 "VBNET.ATG" 
+#line  3698 "VBNET.ATG" 
 			type = "System.UInt32"; 
 			break;
 		}
 		case 222: {
 			lexer.NextToken();
 
-//#line  3696 "VBNET.ATG" 
+#line  3699 "VBNET.ATG" 
 			type = "System.UInt64"; 
 			break;
 		}
 		case 225: {
 			lexer.NextToken();
 
-//#line  3697 "VBNET.ATG" 
+#line  3700 "VBNET.ATG" 
 			type = "System.UInt16"; 
 			break;
 		}
 		case 196: {
 			lexer.NextToken();
 
-//#line  3698 "VBNET.ATG" 
+#line  3701 "VBNET.ATG" 
 			type = "System.SByte"; 
 			break;
 		}
@@ -4487,122 +4495,122 @@ out string type) {
 	}
 
 	void CastTarget(
-//#line  1938 "VBNET.ATG" 
+#line  1941 "VBNET.ATG" 
 out TypeReference type) {
 
-//#line  1940 "VBNET.ATG" 
+#line  1943 "VBNET.ATG" 
 		type = null;
 		
 		switch (la.kind) {
 		case 76: {
 			lexer.NextToken();
 
-//#line  1942 "VBNET.ATG" 
+#line  1945 "VBNET.ATG" 
 			type = new TypeReference("System.Boolean", true); 
 			break;
 		}
 		case 77: {
 			lexer.NextToken();
 
-//#line  1943 "VBNET.ATG" 
+#line  1946 "VBNET.ATG" 
 			type = new TypeReference("System.Byte", true); 
 			break;
 		}
 		case 90: {
 			lexer.NextToken();
 
-//#line  1944 "VBNET.ATG" 
+#line  1947 "VBNET.ATG" 
 			type = new TypeReference("System.SByte", true); 
 			break;
 		}
 		case 78: {
 			lexer.NextToken();
 
-//#line  1945 "VBNET.ATG" 
+#line  1948 "VBNET.ATG" 
 			type = new TypeReference("System.Char", true); 
 			break;
 		}
 		case 79: {
 			lexer.NextToken();
 
-//#line  1946 "VBNET.ATG" 
+#line  1949 "VBNET.ATG" 
 			type = new TypeReference("System.DateTime", true); 
 			break;
 		}
 		case 81: {
 			lexer.NextToken();
 
-//#line  1947 "VBNET.ATG" 
+#line  1950 "VBNET.ATG" 
 			type = new TypeReference("System.Decimal", true); 
 			break;
 		}
 		case 80: {
 			lexer.NextToken();
 
-//#line  1948 "VBNET.ATG" 
+#line  1951 "VBNET.ATG" 
 			type = new TypeReference("System.Double", true); 
 			break;
 		}
 		case 91: {
 			lexer.NextToken();
 
-//#line  1949 "VBNET.ATG" 
+#line  1952 "VBNET.ATG" 
 			type = new TypeReference("System.Int16", true); 
 			break;
 		}
 		case 83: {
 			lexer.NextToken();
 
-//#line  1950 "VBNET.ATG" 
+#line  1953 "VBNET.ATG" 
 			type = new TypeReference("System.Int32", true); 
 			break;
 		}
 		case 85: {
 			lexer.NextToken();
 
-//#line  1951 "VBNET.ATG" 
+#line  1954 "VBNET.ATG" 
 			type = new TypeReference("System.Int64", true); 
 			break;
 		}
 		case 97: {
 			lexer.NextToken();
 
-//#line  1952 "VBNET.ATG" 
+#line  1955 "VBNET.ATG" 
 			type = new TypeReference("System.UInt16", true); 
 			break;
 		}
 		case 95: {
 			lexer.NextToken();
 
-//#line  1953 "VBNET.ATG" 
+#line  1956 "VBNET.ATG" 
 			type = new TypeReference("System.UInt32", true); 
 			break;
 		}
 		case 96: {
 			lexer.NextToken();
 
-//#line  1954 "VBNET.ATG" 
+#line  1957 "VBNET.ATG" 
 			type = new TypeReference("System.UInt64", true); 
 			break;
 		}
 		case 86: {
 			lexer.NextToken();
 
-//#line  1955 "VBNET.ATG" 
+#line  1958 "VBNET.ATG" 
 			type = new TypeReference("System.Object", true); 
 			break;
 		}
 		case 92: {
 			lexer.NextToken();
 
-//#line  1956 "VBNET.ATG" 
+#line  1959 "VBNET.ATG" 
 			type = new TypeReference("System.Single", true); 
 			break;
 		}
 		case 93: {
 			lexer.NextToken();
 
-//#line  1957 "VBNET.ATG" 
+#line  1960 "VBNET.ATG" 
 			type = new TypeReference("System.String", true); 
 			break;
 		}
@@ -4611,19 +4619,19 @@ out TypeReference type) {
 	}
 
 	void GetTypeTypeName(
-//#line  2710 "VBNET.ATG" 
+#line  2713 "VBNET.ATG" 
 out TypeReference typeref) {
 
-//#line  2711 "VBNET.ATG" 
+#line  2714 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-//#line  2713 "VBNET.ATG" 
+#line  2716 "VBNET.ATG" 
 out typeref, true);
 		ArrayTypeModifiers(
-//#line  2714 "VBNET.ATG" 
+#line  2717 "VBNET.ATG" 
 out rank);
 
-//#line  2715 "VBNET.ATG" 
+#line  2718 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -4631,10 +4639,10 @@ out rank);
 	}
 
 	void ConditionalExpression(
-//#line  1890 "VBNET.ATG" 
+#line  1893 "VBNET.ATG" 
 out Expression expr) {
 
-//#line  1892 "VBNET.ATG" 
+#line  1895 "VBNET.ATG" 
 		ConditionalExpression conditionalExpression = new ConditionalExpression();
 		BinaryOperatorExpression binaryOperatorExpression = new BinaryOperatorExpression();
 		conditionalExpression.StartLocation = binaryOperatorExpression.StartLocation = la.Location;
@@ -4646,21 +4654,21 @@ out Expression expr) {
 		Expect(135);
 		Expect(37);
 		Expr(
-//#line  1901 "VBNET.ATG" 
+#line  1904 "VBNET.ATG" 
 out condition);
 		Expect(22);
 		Expr(
-//#line  1901 "VBNET.ATG" 
+#line  1904 "VBNET.ATG" 
 out trueExpr);
 		if (la.kind == 22) {
 			lexer.NextToken();
 			Expr(
-//#line  1901 "VBNET.ATG" 
+#line  1904 "VBNET.ATG" 
 out falseExpr);
 		}
 		Expect(38);
 
-//#line  1903 "VBNET.ATG" 
+#line  1906 "VBNET.ATG" 
 		if(falseExpr != null)
 		{
 			conditionalExpression.Condition = condition;
@@ -4683,50 +4691,50 @@ out falseExpr);
 	}
 
 	void XmlLiteralExpression(
-//#line  1810 "VBNET.ATG" 
+#line  1813 "VBNET.ATG" 
 out Expression pexpr) {
 
-//#line  1812 "VBNET.ATG" 
+#line  1815 "VBNET.ATG" 
 		List<XmlExpression> exprs = new List<XmlExpression>();
 		XmlExpression currentExpression = null;
 		
 		if (StartOf(36)) {
 			XmlContentExpression(
-//#line  1817 "VBNET.ATG" 
+#line  1820 "VBNET.ATG" 
 exprs);
 			while (StartOf(36)) {
 				XmlContentExpression(
-//#line  1817 "VBNET.ATG" 
+#line  1820 "VBNET.ATG" 
 exprs);
 			}
 			if (la.kind == 10) {
 				XmlElement(
-//#line  1817 "VBNET.ATG" 
+#line  1820 "VBNET.ATG" 
 out currentExpression);
 
-//#line  1817 "VBNET.ATG" 
+#line  1820 "VBNET.ATG" 
 				exprs.Add(currentExpression); 
 				while (StartOf(36)) {
 					XmlContentExpression(
-//#line  1817 "VBNET.ATG" 
+#line  1820 "VBNET.ATG" 
 exprs);
 				}
 			}
 		} else if (la.kind == 10) {
 			XmlElement(
-//#line  1819 "VBNET.ATG" 
+#line  1822 "VBNET.ATG" 
 out currentExpression);
 
-//#line  1819 "VBNET.ATG" 
+#line  1822 "VBNET.ATG" 
 			exprs.Add(currentExpression); 
 			while (StartOf(36)) {
 				XmlContentExpression(
-//#line  1819 "VBNET.ATG" 
+#line  1822 "VBNET.ATG" 
 exprs);
 			}
 		} else SynErr(288);
 
-//#line  1822 "VBNET.ATG" 
+#line  1825 "VBNET.ATG" 
 		if (exprs.Count > 1) {
 		pexpr = new XmlDocumentExpression() { Expressions = exprs };
 		} else {
@@ -4736,34 +4744,34 @@ exprs);
 	}
 
 	void XmlContentExpression(
-//#line  1830 "VBNET.ATG" 
+#line  1833 "VBNET.ATG" 
 List<XmlExpression> exprs) {
 
-//#line  1831 "VBNET.ATG" 
+#line  1834 "VBNET.ATG" 
 		XmlContentExpression expr = null; 
 		if (la.kind == 16) {
 			lexer.NextToken();
 
-//#line  1833 "VBNET.ATG" 
+#line  1836 "VBNET.ATG" 
 			expr = new XmlContentExpression(t.val, XmlContentType.Text); 
 		} else if (la.kind == 18) {
 			lexer.NextToken();
 
-//#line  1834 "VBNET.ATG" 
+#line  1837 "VBNET.ATG" 
 			expr = new XmlContentExpression(t.val, XmlContentType.CData); 
 		} else if (la.kind == 17) {
 			lexer.NextToken();
 
-//#line  1835 "VBNET.ATG" 
+#line  1838 "VBNET.ATG" 
 			expr = new XmlContentExpression(t.val, XmlContentType.Comment); 
 		} else if (la.kind == 19) {
 			lexer.NextToken();
 
-//#line  1836 "VBNET.ATG" 
+#line  1839 "VBNET.ATG" 
 			expr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction); 
 		} else SynErr(289);
 
-//#line  1839 "VBNET.ATG" 
+#line  1842 "VBNET.ATG" 
 		expr.StartLocation = t.Location;
 		expr.EndLocation = t.EndLocation;
 		exprs.Add(expr);
@@ -4771,54 +4779,54 @@ List<XmlExpression> exprs) {
 	}
 
 	void XmlElement(
-//#line  1865 "VBNET.ATG" 
+#line  1868 "VBNET.ATG" 
 out XmlExpression expr) {
 
-//#line  1866 "VBNET.ATG" 
+#line  1869 "VBNET.ATG" 
 		XmlElementExpression el = new XmlElementExpression(); 
 		Expect(10);
 
-//#line  1869 "VBNET.ATG" 
+#line  1872 "VBNET.ATG" 
 		el.StartLocation = t.Location; 
 		if (la.kind == 12) {
 			lexer.NextToken();
 
-//#line  1870 "VBNET.ATG" 
+#line  1873 "VBNET.ATG" 
 			Expression innerExpression; 
 			Expr(
-//#line  1870 "VBNET.ATG" 
+#line  1873 "VBNET.ATG" 
 out innerExpression);
 			Expect(13);
 
-//#line  1871 "VBNET.ATG" 
+#line  1874 "VBNET.ATG" 
 			el.NameExpression = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression }; 
 		} else if (StartOf(4)) {
 			Identifier();
 
-//#line  1872 "VBNET.ATG" 
+#line  1875 "VBNET.ATG" 
 			el.XmlName = t.val; 
 		} else SynErr(290);
 		while (StartOf(37)) {
 			XmlAttribute(
-//#line  1872 "VBNET.ATG" 
+#line  1875 "VBNET.ATG" 
 el.Attributes);
 		}
 		if (la.kind == 14) {
 			lexer.NextToken();
 
-//#line  1873 "VBNET.ATG" 
+#line  1876 "VBNET.ATG" 
 			el.EndLocation = t.EndLocation; 
 		} else if (la.kind == 11) {
 			lexer.NextToken();
 			while (StartOf(38)) {
 
-//#line  1873 "VBNET.ATG" 
+#line  1876 "VBNET.ATG" 
 				XmlExpression child; 
 				XmlNestedContent(
-//#line  1873 "VBNET.ATG" 
+#line  1876 "VBNET.ATG" 
 out child);
 
-//#line  1873 "VBNET.ATG" 
+#line  1876 "VBNET.ATG" 
 				el.Children.Add(child); 
 			}
 			Expect(15);
@@ -4827,73 +4835,73 @@ out child);
 			}
 			Expect(11);
 
-//#line  1873 "VBNET.ATG" 
+#line  1876 "VBNET.ATG" 
 			el.EndLocation = t.EndLocation; 
 		} else SynErr(291);
 
-//#line  1875 "VBNET.ATG" 
+#line  1878 "VBNET.ATG" 
 		expr = el; 
 	}
 
 	void XmlNestedContent(
-//#line  1845 "VBNET.ATG" 
+#line  1848 "VBNET.ATG" 
 out XmlExpression expr) {
 
-//#line  1846 "VBNET.ATG" 
+#line  1849 "VBNET.ATG" 
 		XmlExpression tmpExpr = null; Location start = la.Location; 
 		switch (la.kind) {
 		case 16: {
 			lexer.NextToken();
 
-//#line  1849 "VBNET.ATG" 
+#line  1852 "VBNET.ATG" 
 			tmpExpr = new XmlContentExpression(t.val, XmlContentType.Text); 
 			break;
 		}
 		case 18: {
 			lexer.NextToken();
 
-//#line  1850 "VBNET.ATG" 
+#line  1853 "VBNET.ATG" 
 			tmpExpr = new XmlContentExpression(t.val, XmlContentType.CData); 
 			break;
 		}
 		case 17: {
 			lexer.NextToken();
 
-//#line  1851 "VBNET.ATG" 
+#line  1854 "VBNET.ATG" 
 			tmpExpr = new XmlContentExpression(t.val, XmlContentType.Comment); 
 			break;
 		}
 		case 19: {
 			lexer.NextToken();
 
-//#line  1852 "VBNET.ATG" 
+#line  1855 "VBNET.ATG" 
 			tmpExpr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction); 
 			break;
 		}
 		case 12: {
 			lexer.NextToken();
 
-//#line  1853 "VBNET.ATG" 
+#line  1856 "VBNET.ATG" 
 			Expression innerExpression; 
 			Expr(
-//#line  1853 "VBNET.ATG" 
+#line  1856 "VBNET.ATG" 
 out innerExpression);
 			Expect(13);
 
-//#line  1853 "VBNET.ATG" 
+#line  1856 "VBNET.ATG" 
 			tmpExpr = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression }; 
 			break;
 		}
 		case 10: {
 			XmlElement(
-//#line  1854 "VBNET.ATG" 
+#line  1857 "VBNET.ATG" 
 out tmpExpr);
 			break;
 		}
 		default: SynErr(292); break;
 		}
 
-//#line  1857 "VBNET.ATG" 
+#line  1860 "VBNET.ATG" 
 		if (tmpExpr.StartLocation.IsEmpty)
 		tmpExpr.StartLocation = start;
 		if (tmpExpr.EndLocation.IsEmpty)
@@ -4903,401 +4911,401 @@ out tmpExpr);
 	}
 
 	void XmlAttribute(
-//#line  1878 "VBNET.ATG" 
+#line  1881 "VBNET.ATG" 
 List<XmlExpression> attrs) {
 
-//#line  1879 "VBNET.ATG" 
+#line  1882 "VBNET.ATG" 
 		Location start = la.Location; 
 		if (StartOf(4)) {
 			Identifier();
 
-//#line  1881 "VBNET.ATG" 
+#line  1884 "VBNET.ATG" 
 			string name = t.val; 
 			Expect(20);
 
-//#line  1882 "VBNET.ATG" 
+#line  1885 "VBNET.ATG" 
 			string literalValue = null; Expression expressionValue = null; bool useDoubleQuotes = false; 
 			if (la.kind == 3) {
 				lexer.NextToken();
 
-//#line  1883 "VBNET.ATG" 
+#line  1886 "VBNET.ATG" 
 				literalValue = t.literalValue.ToString(); useDoubleQuotes = t.val[0] == '"'; 
 			} else if (la.kind == 12) {
 				lexer.NextToken();
 				Expr(
-//#line  1883 "VBNET.ATG" 
+#line  1886 "VBNET.ATG" 
 out expressionValue);
 				Expect(13);
 			} else SynErr(293);
 
-//#line  1884 "VBNET.ATG" 
+#line  1887 "VBNET.ATG" 
 			attrs.Add(new XmlAttributeExpression() { Name = name, ExpressionValue = expressionValue, LiteralValue = literalValue, UseDoubleQuotes = useDoubleQuotes, StartLocation = start, EndLocation = t.EndLocation }); 
 		} else if (la.kind == 12) {
 			lexer.NextToken();
 
-//#line  1886 "VBNET.ATG" 
+#line  1889 "VBNET.ATG" 
 			Expression innerExpression; 
 			Expr(
-//#line  1886 "VBNET.ATG" 
+#line  1889 "VBNET.ATG" 
 out innerExpression);
 			Expect(13);
 
-//#line  1887 "VBNET.ATG" 
+#line  1890 "VBNET.ATG" 
 			attrs.Add(new XmlEmbeddedExpression() { InlineVBExpression = innerExpression, StartLocation = start, EndLocation = t.EndLocation }); 
 		} else SynErr(294);
 	}
 
 	void ArgumentList(
-//#line  2639 "VBNET.ATG" 
+#line  2642 "VBNET.ATG" 
 out List<Expression> arguments) {
 
-//#line  2641 "VBNET.ATG" 
+#line  2644 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		Expression expr = null;
 		
 		if (StartOf(24)) {
 			Argument(
-//#line  2644 "VBNET.ATG" 
+#line  2647 "VBNET.ATG" 
 out expr);
 		}
 		while (la.kind == 22) {
 			lexer.NextToken();
 
-//#line  2645 "VBNET.ATG" 
+#line  2648 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 			if (StartOf(24)) {
 				Argument(
-//#line  2646 "VBNET.ATG" 
+#line  2649 "VBNET.ATG" 
 out expr);
 			}
 
-//#line  2647 "VBNET.ATG" 
+#line  2650 "VBNET.ATG" 
 			if (expr == null) expr = Expression.Null; 
 		}
 
-//#line  2649 "VBNET.ATG" 
+#line  2652 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); 
 	}
 
 	void ConjunctionExpr(
-//#line  1977 "VBNET.ATG" 
+#line  1980 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  1979 "VBNET.ATG" 
+#line  1982 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		Location startLocation = la.Location;
 		
 		NotExpr(
-//#line  1983 "VBNET.ATG" 
+#line  1986 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 60 || la.kind == 61) {
 			if (la.kind == 60) {
 				lexer.NextToken();
 
-//#line  1986 "VBNET.ATG" 
+#line  1989 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseAnd; 
 			} else {
 				lexer.NextToken();
 
-//#line  1987 "VBNET.ATG" 
+#line  1990 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalAnd; 
 			}
 			NotExpr(
-//#line  1989 "VBNET.ATG" 
+#line  1992 "VBNET.ATG" 
 out expr);
 
-//#line  1989 "VBNET.ATG" 
+#line  1992 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void NotExpr(
-//#line  1993 "VBNET.ATG" 
+#line  1996 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  1994 "VBNET.ATG" 
+#line  1997 "VBNET.ATG" 
 		UnaryOperatorType uop = UnaryOperatorType.None; 
 		while (la.kind == 164) {
 			lexer.NextToken();
 
-//#line  1995 "VBNET.ATG" 
+#line  1998 "VBNET.ATG" 
 			uop = UnaryOperatorType.Not; 
 		}
 		ComparisonExpr(
-//#line  1996 "VBNET.ATG" 
+#line  1999 "VBNET.ATG" 
 out outExpr);
 
-//#line  1997 "VBNET.ATG" 
+#line  2000 "VBNET.ATG" 
 		if (uop != UnaryOperatorType.None)
 		outExpr = new UnaryOperatorExpression(outExpr, uop);
 		
 	}
 
 	void ComparisonExpr(
-//#line  2002 "VBNET.ATG" 
+#line  2005 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2004 "VBNET.ATG" 
+#line  2007 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		Location startLocation = la.Location;
 		
 		ShiftExpr(
-//#line  2008 "VBNET.ATG" 
+#line  2011 "VBNET.ATG" 
 out outExpr);
 		while (StartOf(40)) {
 			switch (la.kind) {
 			case 40: {
 				lexer.NextToken();
 
-//#line  2011 "VBNET.ATG" 
+#line  2014 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 39: {
 				lexer.NextToken();
 
-//#line  2012 "VBNET.ATG" 
+#line  2015 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 43: {
 				lexer.NextToken();
 
-//#line  2013 "VBNET.ATG" 
+#line  2016 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 42: {
 				lexer.NextToken();
 
-//#line  2014 "VBNET.ATG" 
+#line  2017 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 41: {
 				lexer.NextToken();
 
-//#line  2015 "VBNET.ATG" 
+#line  2018 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			case 20: {
 				lexer.NextToken();
 
-//#line  2016 "VBNET.ATG" 
+#line  2019 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 150: {
 				lexer.NextToken();
 
-//#line  2017 "VBNET.ATG" 
+#line  2020 "VBNET.ATG" 
 				op = BinaryOperatorType.Like; 
 				break;
 			}
 			case 144: {
 				lexer.NextToken();
 
-//#line  2018 "VBNET.ATG" 
+#line  2021 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceEquality; 
 				break;
 			}
 			case 145: {
 				lexer.NextToken();
 
-//#line  2019 "VBNET.ATG" 
+#line  2022 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceInequality; 
 				break;
 			}
 			}
 			if (StartOf(41)) {
 				ShiftExpr(
-//#line  2022 "VBNET.ATG" 
+#line  2025 "VBNET.ATG" 
 out expr);
 
-//#line  2022 "VBNET.ATG" 
+#line  2025 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 			} else if (la.kind == 164) {
 
-//#line  2023 "VBNET.ATG" 
+#line  2026 "VBNET.ATG" 
 				Location startLocation2 = la.Location; 
 				lexer.NextToken();
 				ShiftExpr(
-//#line  2025 "VBNET.ATG" 
+#line  2028 "VBNET.ATG" 
 out expr);
 
-//#line  2025 "VBNET.ATG" 
+#line  2028 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not) { StartLocation = startLocation2, EndLocation = t.EndLocation }) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 			} else SynErr(295);
 		}
 	}
 
 	void ShiftExpr(
-//#line  2030 "VBNET.ATG" 
+#line  2033 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2032 "VBNET.ATG" 
+#line  2035 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		Location startLocation = la.Location;
 		
 		ConcatenationExpr(
-//#line  2036 "VBNET.ATG" 
+#line  2039 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 44 || la.kind == 45) {
 			if (la.kind == 44) {
 				lexer.NextToken();
 
-//#line  2039 "VBNET.ATG" 
+#line  2042 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftLeft; 
 			} else {
 				lexer.NextToken();
 
-//#line  2040 "VBNET.ATG" 
+#line  2043 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftRight; 
 			}
 			ConcatenationExpr(
-//#line  2042 "VBNET.ATG" 
+#line  2045 "VBNET.ATG" 
 out expr);
 
-//#line  2042 "VBNET.ATG" 
+#line  2045 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void ConcatenationExpr(
-//#line  2046 "VBNET.ATG" 
+#line  2049 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2047 "VBNET.ATG" 
+#line  2050 "VBNET.ATG" 
 		Expression expr; Location startLocation = la.Location; 
 		AdditiveExpr(
-//#line  2049 "VBNET.ATG" 
+#line  2052 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 23) {
 			lexer.NextToken();
 			AdditiveExpr(
-//#line  2049 "VBNET.ATG" 
+#line  2052 "VBNET.ATG" 
 out expr);
 
-//#line  2049 "VBNET.ATG" 
+#line  2052 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void AdditiveExpr(
-//#line  2052 "VBNET.ATG" 
+#line  2055 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2054 "VBNET.ATG" 
+#line  2057 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		Location startLocation = la.Location;
 		
 		ModuloExpr(
-//#line  2058 "VBNET.ATG" 
+#line  2061 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 30 || la.kind == 31) {
 			if (la.kind == 31) {
 				lexer.NextToken();
 
-//#line  2061 "VBNET.ATG" 
+#line  2064 "VBNET.ATG" 
 				op = BinaryOperatorType.Add; 
 			} else {
 				lexer.NextToken();
 
-//#line  2062 "VBNET.ATG" 
+#line  2065 "VBNET.ATG" 
 				op = BinaryOperatorType.Subtract; 
 			}
 			ModuloExpr(
-//#line  2064 "VBNET.ATG" 
+#line  2067 "VBNET.ATG" 
 out expr);
 
-//#line  2064 "VBNET.ATG" 
+#line  2067 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void ModuloExpr(
-//#line  2068 "VBNET.ATG" 
+#line  2071 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2069 "VBNET.ATG" 
+#line  2072 "VBNET.ATG" 
 		Expression expr; Location startLocation = la.Location; 
 		IntegerDivisionExpr(
-//#line  2071 "VBNET.ATG" 
+#line  2074 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 154) {
 			lexer.NextToken();
 			IntegerDivisionExpr(
-//#line  2071 "VBNET.ATG" 
+#line  2074 "VBNET.ATG" 
 out expr);
 
-//#line  2071 "VBNET.ATG" 
+#line  2074 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void IntegerDivisionExpr(
-//#line  2074 "VBNET.ATG" 
+#line  2077 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2075 "VBNET.ATG" 
+#line  2078 "VBNET.ATG" 
 		Expression expr; Location startLocation = la.Location; 
 		MultiplicativeExpr(
-//#line  2077 "VBNET.ATG" 
+#line  2080 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 25) {
 			lexer.NextToken();
 			MultiplicativeExpr(
-//#line  2077 "VBNET.ATG" 
+#line  2080 "VBNET.ATG" 
 out expr);
 
-//#line  2077 "VBNET.ATG" 
+#line  2080 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void MultiplicativeExpr(
-//#line  2080 "VBNET.ATG" 
+#line  2083 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2082 "VBNET.ATG" 
+#line  2085 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		Location startLocation = la.Location;
 		
 		UnaryExpr(
-//#line  2086 "VBNET.ATG" 
+#line  2089 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 24 || la.kind == 34) {
 			if (la.kind == 34) {
 				lexer.NextToken();
 
-//#line  2089 "VBNET.ATG" 
+#line  2092 "VBNET.ATG" 
 				op = BinaryOperatorType.Multiply; 
 			} else {
 				lexer.NextToken();
 
-//#line  2090 "VBNET.ATG" 
+#line  2093 "VBNET.ATG" 
 				op = BinaryOperatorType.Divide; 
 			}
 			UnaryExpr(
-//#line  2092 "VBNET.ATG" 
+#line  2095 "VBNET.ATG" 
 out expr);
 
-//#line  2092 "VBNET.ATG" 
+#line  2095 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 		}
 	}
 
 	void UnaryExpr(
-//#line  2096 "VBNET.ATG" 
+#line  2099 "VBNET.ATG" 
 out Expression uExpr) {
 
-//#line  2098 "VBNET.ATG" 
+#line  2101 "VBNET.ATG" 
 		Expression expr;
 		UnaryOperatorType uop = UnaryOperatorType.None;
 		Location startLocation = la.Location;
@@ -5307,25 +5315,25 @@ out Expression uExpr) {
 			if (la.kind == 31) {
 				lexer.NextToken();
 
-//#line  2103 "VBNET.ATG" 
+#line  2106 "VBNET.ATG" 
 				uop = UnaryOperatorType.Plus; isUOp = true; 
 			} else if (la.kind == 30) {
 				lexer.NextToken();
 
-//#line  2104 "VBNET.ATG" 
+#line  2107 "VBNET.ATG" 
 				uop = UnaryOperatorType.Minus; isUOp = true; 
 			} else {
 				lexer.NextToken();
 
-//#line  2105 "VBNET.ATG" 
+#line  2108 "VBNET.ATG" 
 				uop = UnaryOperatorType.Dereference;  isUOp = true;
 			}
 		}
 		ExponentiationExpr(
-//#line  2107 "VBNET.ATG" 
+#line  2110 "VBNET.ATG" 
 out expr);
 
-//#line  2109 "VBNET.ATG" 
+#line  2112 "VBNET.ATG" 
 		if (isUOp) {
 		uExpr = new UnaryOperatorExpression(expr, uop) { StartLocation = startLocation, EndLocation = t.EndLocation };
 		} else {
@@ -5335,107 +5343,107 @@ out expr);
 	}
 
 	void ExponentiationExpr(
-//#line  2117 "VBNET.ATG" 
+#line  2120 "VBNET.ATG" 
 out Expression outExpr) {
 
-//#line  2118 "VBNET.ATG" 
+#line  2121 "VBNET.ATG" 
 		Expression expr; Location startLocation = la.Location; 
 		SimpleExpr(
-//#line  2120 "VBNET.ATG" 
+#line  2123 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 32) {
 			lexer.NextToken();
 			SimpleExpr(
-//#line  2120 "VBNET.ATG" 
+#line  2123 "VBNET.ATG" 
 out expr);
 
-//#line  2120 "VBNET.ATG" 
+#line  2123 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void NormalOrReDimArgumentList(
-//#line  2653 "VBNET.ATG" 
+#line  2656 "VBNET.ATG" 
 out List<Expression> arguments, out bool canBeNormal, out bool canBeRedim) {
 
-//#line  2655 "VBNET.ATG" 
+#line  2658 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		canBeNormal = true; canBeRedim = !IsNamedAssign();
 		Expression expr = null;
 		
 		if (StartOf(24)) {
 			Argument(
-//#line  2660 "VBNET.ATG" 
+#line  2663 "VBNET.ATG" 
 out expr);
 			if (la.kind == 216) {
 				lexer.NextToken();
 
-//#line  2661 "VBNET.ATG" 
+#line  2664 "VBNET.ATG" 
 				EnsureIsZero(expr); canBeNormal = false; 
 				Expr(
-//#line  2662 "VBNET.ATG" 
+#line  2665 "VBNET.ATG" 
 out expr);
 			}
 		}
 		while (la.kind == 22) {
 			lexer.NextToken();
 
-//#line  2665 "VBNET.ATG" 
+#line  2668 "VBNET.ATG" 
 			if (expr == null) canBeRedim = false; 
 
-//#line  2666 "VBNET.ATG" 
+#line  2669 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 
-//#line  2667 "VBNET.ATG" 
+#line  2670 "VBNET.ATG" 
 			canBeRedim &= !IsNamedAssign(); 
 			if (StartOf(24)) {
 				Argument(
-//#line  2668 "VBNET.ATG" 
+#line  2671 "VBNET.ATG" 
 out expr);
 				if (la.kind == 216) {
 					lexer.NextToken();
 
-//#line  2669 "VBNET.ATG" 
+#line  2672 "VBNET.ATG" 
 					EnsureIsZero(expr); canBeNormal = false; 
 					Expr(
-//#line  2670 "VBNET.ATG" 
+#line  2673 "VBNET.ATG" 
 out expr);
 				}
 			}
 
-//#line  2672 "VBNET.ATG" 
+#line  2675 "VBNET.ATG" 
 			if (expr == null) { canBeRedim = false; expr = Expression.Null; } 
 		}
 
-//#line  2674 "VBNET.ATG" 
+#line  2677 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); else canBeRedim = false; 
 	}
 
 	void ArrayTypeModifiers(
-//#line  2784 "VBNET.ATG" 
+#line  2787 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-//#line  2786 "VBNET.ATG" 
+#line  2789 "VBNET.ATG" 
 		arrayModifiers = new ArrayList();
 		int i = 0;
 		
 		while (
-//#line  2789 "VBNET.ATG" 
+#line  2792 "VBNET.ATG" 
 IsDims()) {
 			Expect(37);
 			if (la.kind == 22 || la.kind == 38) {
 				RankList(
-//#line  2791 "VBNET.ATG" 
+#line  2794 "VBNET.ATG" 
 out i);
 			}
 
-//#line  2793 "VBNET.ATG" 
+#line  2796 "VBNET.ATG" 
 			arrayModifiers.Add(i);
 			
 			Expect(38);
 		}
 
-//#line  2798 "VBNET.ATG" 
+#line  2801 "VBNET.ATG" 
 		if(arrayModifiers.Count == 0) {
 		 arrayModifiers = null;
 		}
@@ -5443,10 +5451,10 @@ out i);
 	}
 
 	void MemberInitializer(
-//#line  2620 "VBNET.ATG" 
+#line  2623 "VBNET.ATG" 
 out MemberInitializerExpression memberInitializer) {
 
-//#line  2622 "VBNET.ATG" 
+#line  2625 "VBNET.ATG" 
 		memberInitializer = new MemberInitializerExpression();
 		memberInitializer.StartLocation = la.Location;
 		Expression initExpr = null;
@@ -5456,19 +5464,19 @@ out MemberInitializerExpression memberInitializer) {
 		if (la.kind == 147) {
 			lexer.NextToken();
 
-//#line  2628 "VBNET.ATG" 
+#line  2631 "VBNET.ATG" 
 			isKey = true; 
 		}
 		Expect(26);
 		IdentifierOrKeyword(
-//#line  2629 "VBNET.ATG" 
+#line  2632 "VBNET.ATG" 
 out name);
 		Expect(20);
 		Expr(
-//#line  2629 "VBNET.ATG" 
+#line  2632 "VBNET.ATG" 
 out initExpr);
 
-//#line  2631 "VBNET.ATG" 
+#line  2634 "VBNET.ATG" 
 		memberInitializer.Name = name;
 		memberInitializer.Expression = initExpr;
 		memberInitializer.IsKey = isKey;
@@ -5477,10 +5485,10 @@ out initExpr);
 	}
 
 	void SubLambdaExpression(
-//#line  2219 "VBNET.ATG" 
+#line  2222 "VBNET.ATG" 
 out LambdaExpression lambda) {
 
-//#line  2221 "VBNET.ATG" 
+#line  2224 "VBNET.ATG" 
 		lambda = new LambdaExpression();
 		lambda.ReturnType = new TypeReference("System.Void", true);
 		Expression inner = null;
@@ -5492,7 +5500,7 @@ out LambdaExpression lambda) {
 			lexer.NextToken();
 			if (StartOf(6)) {
 				FormalParameterList(
-//#line  2228 "VBNET.ATG" 
+#line  2231 "VBNET.ATG" 
 lambda.Parameters);
 			}
 			Expect(38);
@@ -5500,20 +5508,20 @@ lambda.Parameters);
 		if (StartOf(42)) {
 			if (StartOf(24)) {
 				Expr(
-//#line  2231 "VBNET.ATG" 
+#line  2234 "VBNET.ATG" 
 out inner);
 
-//#line  2233 "VBNET.ATG" 
+#line  2236 "VBNET.ATG" 
 				lambda.ExpressionBody = inner;
 				lambda.EndLocation = t.EndLocation; // la.Location?
 				lambda.ExtendedEndLocation = la.Location;
 				
 			} else {
 				EmbeddedStatement(
-//#line  2238 "VBNET.ATG" 
+#line  2241 "VBNET.ATG" 
 out statement);
 
-//#line  2240 "VBNET.ATG" 
+#line  2243 "VBNET.ATG" 
 				lambda.StatementBody = statement;
 				lambda.EndLocation = t.EndLocation;
 				lambda.ExtendedEndLocation = la.Location;
@@ -5522,12 +5530,12 @@ out statement);
 		} else if (la.kind == 1) {
 			lexer.NextToken();
 			Block(
-//#line  2247 "VBNET.ATG" 
+#line  2250 "VBNET.ATG" 
 out statement);
 			Expect(113);
 			Expect(210);
 
-//#line  2250 "VBNET.ATG" 
+#line  2253 "VBNET.ATG" 
 			lambda.StatementBody = statement;
 			lambda.EndLocation = t.EndLocation;
 			lambda.ExtendedEndLocation = la.Location;
@@ -5536,10 +5544,10 @@ out statement);
 	}
 
 	void FunctionLambdaExpression(
-//#line  2257 "VBNET.ATG" 
+#line  2260 "VBNET.ATG" 
 out LambdaExpression lambda) {
 
-//#line  2259 "VBNET.ATG" 
+#line  2262 "VBNET.ATG" 
 		lambda = new LambdaExpression();
 		TypeReference typeRef = null;
 		Expression inner = null;
@@ -5551,7 +5559,7 @@ out LambdaExpression lambda) {
 			lexer.NextToken();
 			if (StartOf(6)) {
 				FormalParameterList(
-//#line  2266 "VBNET.ATG" 
+#line  2269 "VBNET.ATG" 
 lambda.Parameters);
 			}
 			Expect(38);
@@ -5559,29 +5567,29 @@ lambda.Parameters);
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-//#line  2267 "VBNET.ATG" 
+#line  2270 "VBNET.ATG" 
 out typeRef);
 
-//#line  2267 "VBNET.ATG" 
+#line  2270 "VBNET.ATG" 
 			lambda.ReturnType = typeRef; 
 		}
 		if (StartOf(42)) {
 			if (StartOf(24)) {
 				Expr(
-//#line  2270 "VBNET.ATG" 
+#line  2273 "VBNET.ATG" 
 out inner);
 
-//#line  2272 "VBNET.ATG" 
+#line  2275 "VBNET.ATG" 
 				lambda.ExpressionBody = inner;
 				lambda.EndLocation = t.EndLocation;
 				lambda.ExtendedEndLocation = la.Location;
 				
 			} else {
 				EmbeddedStatement(
-//#line  2277 "VBNET.ATG" 
+#line  2280 "VBNET.ATG" 
 out statement);
 
-//#line  2279 "VBNET.ATG" 
+#line  2282 "VBNET.ATG" 
 				lambda.StatementBody = statement;
 				lambda.EndLocation = t.EndLocation;
 				lambda.ExtendedEndLocation = la.Location;
@@ -5590,12 +5598,12 @@ out statement);
 		} else if (la.kind == 1) {
 			lexer.NextToken();
 			Block(
-//#line  2286 "VBNET.ATG" 
+#line  2289 "VBNET.ATG" 
 out statement);
 			Expect(113);
 			Expect(127);
 
-//#line  2289 "VBNET.ATG" 
+#line  2292 "VBNET.ATG" 
 			lambda.StatementBody = statement;
 			lambda.EndLocation = t.EndLocation;
 			lambda.ExtendedEndLocation = la.Location;
@@ -5604,10 +5612,10 @@ out statement);
 	}
 
 	void EmbeddedStatement(
-//#line  3070 "VBNET.ATG" 
+#line  3073 "VBNET.ATG" 
 out Statement statement) {
 
-//#line  3072 "VBNET.ATG" 
+#line  3075 "VBNET.ATG" 
 		Statement embeddedStatement = null;
 		statement = null;
 		Expression expr = null;
@@ -5618,224 +5626,224 @@ out Statement statement) {
 		if (la.kind == 120) {
 			lexer.NextToken();
 
-//#line  3080 "VBNET.ATG" 
+#line  3083 "VBNET.ATG" 
 			ExitType exitType = ExitType.None; 
 			switch (la.kind) {
 			case 210: {
 				lexer.NextToken();
 
-//#line  3082 "VBNET.ATG" 
+#line  3085 "VBNET.ATG" 
 				exitType = ExitType.Sub; 
 				break;
 			}
 			case 127: {
 				lexer.NextToken();
 
-//#line  3084 "VBNET.ATG" 
+#line  3087 "VBNET.ATG" 
 				exitType = ExitType.Function; 
 				break;
 			}
 			case 186: {
 				lexer.NextToken();
 
-//#line  3086 "VBNET.ATG" 
+#line  3089 "VBNET.ATG" 
 				exitType = ExitType.Property; 
 				break;
 			}
 			case 108: {
 				lexer.NextToken();
 
-//#line  3088 "VBNET.ATG" 
+#line  3091 "VBNET.ATG" 
 				exitType = ExitType.Do; 
 				break;
 			}
 			case 124: {
 				lexer.NextToken();
 
-//#line  3090 "VBNET.ATG" 
+#line  3093 "VBNET.ATG" 
 				exitType = ExitType.For; 
 				break;
 			}
 			case 218: {
 				lexer.NextToken();
 
-//#line  3092 "VBNET.ATG" 
+#line  3095 "VBNET.ATG" 
 				exitType = ExitType.Try; 
 				break;
 			}
 			case 231: {
 				lexer.NextToken();
 
-//#line  3094 "VBNET.ATG" 
+#line  3097 "VBNET.ATG" 
 				exitType = ExitType.While; 
 				break;
 			}
 			case 197: {
 				lexer.NextToken();
 
-//#line  3096 "VBNET.ATG" 
+#line  3099 "VBNET.ATG" 
 				exitType = ExitType.Select; 
 				break;
 			}
 			default: SynErr(298); break;
 			}
 
-//#line  3098 "VBNET.ATG" 
+#line  3101 "VBNET.ATG" 
 			statement = new ExitStatement(exitType); 
 		} else if (la.kind == 218) {
 			TryStatement(
-//#line  3099 "VBNET.ATG" 
+#line  3102 "VBNET.ATG" 
 out statement);
 		} else if (la.kind == 89) {
 			lexer.NextToken();
 
-//#line  3100 "VBNET.ATG" 
+#line  3103 "VBNET.ATG" 
 			ContinueType continueType = ContinueType.None; 
 			if (la.kind == 108 || la.kind == 124 || la.kind == 231) {
 				if (la.kind == 108) {
 					lexer.NextToken();
 
-//#line  3100 "VBNET.ATG" 
+#line  3103 "VBNET.ATG" 
 					continueType = ContinueType.Do; 
 				} else if (la.kind == 124) {
 					lexer.NextToken();
 
-//#line  3100 "VBNET.ATG" 
+#line  3103 "VBNET.ATG" 
 					continueType = ContinueType.For; 
 				} else {
 					lexer.NextToken();
 
-//#line  3100 "VBNET.ATG" 
+#line  3103 "VBNET.ATG" 
 					continueType = ContinueType.While; 
 				}
 			}
 
-//#line  3100 "VBNET.ATG" 
+#line  3103 "VBNET.ATG" 
 			statement = new ContinueStatement(continueType); 
 		} else if (la.kind == 215) {
 			lexer.NextToken();
 			if (StartOf(24)) {
 				Expr(
-//#line  3102 "VBNET.ATG" 
+#line  3105 "VBNET.ATG" 
 out expr);
 			}
 
-//#line  3102 "VBNET.ATG" 
+#line  3105 "VBNET.ATG" 
 			statement = new ThrowStatement(expr); 
 		} else if (la.kind == 195) {
 			lexer.NextToken();
 			if (StartOf(24)) {
 				Expr(
-//#line  3104 "VBNET.ATG" 
+#line  3107 "VBNET.ATG" 
 out expr);
 			}
 
-//#line  3104 "VBNET.ATG" 
+#line  3107 "VBNET.ATG" 
 			statement = new ReturnStatement(expr); 
 		} else if (la.kind == 211) {
 			lexer.NextToken();
 			Expr(
-//#line  3106 "VBNET.ATG" 
+#line  3109 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-//#line  3106 "VBNET.ATG" 
+#line  3109 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(113);
 			Expect(211);
 
-//#line  3107 "VBNET.ATG" 
+#line  3110 "VBNET.ATG" 
 			statement = new LockStatement(expr, embeddedStatement); 
 		} else if (la.kind == 189) {
 			lexer.NextToken();
 			Identifier();
 
-//#line  3109 "VBNET.ATG" 
+#line  3112 "VBNET.ATG" 
 			name = t.val; 
 			if (la.kind == 37) {
 				lexer.NextToken();
 				if (StartOf(43)) {
 					ArgumentList(
-//#line  3110 "VBNET.ATG" 
+#line  3113 "VBNET.ATG" 
 out p);
 				}
 				Expect(38);
 			}
 
-//#line  3112 "VBNET.ATG" 
+#line  3115 "VBNET.ATG" 
 			statement = new RaiseEventStatement(name, p);
 			
 		} else if (la.kind == 233) {
 			WithStatement(
-//#line  3115 "VBNET.ATG" 
+#line  3118 "VBNET.ATG" 
 out statement);
 		} else if (la.kind == 56) {
 			lexer.NextToken();
 
-//#line  3117 "VBNET.ATG" 
+#line  3120 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-//#line  3118 "VBNET.ATG" 
+#line  3121 "VBNET.ATG" 
 out expr);
 			Expect(22);
 			Expr(
-//#line  3118 "VBNET.ATG" 
+#line  3121 "VBNET.ATG" 
 out handlerExpr);
 
-//#line  3120 "VBNET.ATG" 
+#line  3123 "VBNET.ATG" 
 			statement = new AddHandlerStatement(expr, handlerExpr);
 			
 		} else if (la.kind == 193) {
 			lexer.NextToken();
 
-//#line  3123 "VBNET.ATG" 
+#line  3126 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-//#line  3124 "VBNET.ATG" 
+#line  3127 "VBNET.ATG" 
 out expr);
 			Expect(22);
 			Expr(
-//#line  3124 "VBNET.ATG" 
+#line  3127 "VBNET.ATG" 
 out handlerExpr);
 
-//#line  3126 "VBNET.ATG" 
+#line  3129 "VBNET.ATG" 
 			statement = new RemoveHandlerStatement(expr, handlerExpr);
 			
 		} else if (la.kind == 231) {
 			lexer.NextToken();
 			Expr(
-//#line  3129 "VBNET.ATG" 
+#line  3132 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-//#line  3130 "VBNET.ATG" 
+#line  3133 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(113);
 			Expect(231);
 
-//#line  3132 "VBNET.ATG" 
+#line  3135 "VBNET.ATG" 
 			statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
 			
 		} else if (la.kind == 108) {
 			lexer.NextToken();
 
-//#line  3137 "VBNET.ATG" 
+#line  3140 "VBNET.ATG" 
 			ConditionType conditionType = ConditionType.None;
 			
 			if (la.kind == 224 || la.kind == 231) {
 				WhileOrUntil(
-//#line  3140 "VBNET.ATG" 
+#line  3143 "VBNET.ATG" 
 out conditionType);
 				Expr(
-//#line  3140 "VBNET.ATG" 
+#line  3143 "VBNET.ATG" 
 out expr);
 				EndOfStmt();
 				Block(
-//#line  3141 "VBNET.ATG" 
+#line  3144 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(152);
 
-//#line  3144 "VBNET.ATG" 
+#line  3147 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, 
 				                               embeddedStatement, 
 				                               conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, 
@@ -5844,26 +5852,26 @@ out embeddedStatement);
 			} else if (la.kind == 1 || la.kind == 21) {
 				EndOfStmt();
 				Block(
-//#line  3151 "VBNET.ATG" 
+#line  3154 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(152);
 				if (la.kind == 224 || la.kind == 231) {
 					WhileOrUntil(
-//#line  3152 "VBNET.ATG" 
+#line  3155 "VBNET.ATG" 
 out conditionType);
 					Expr(
-//#line  3152 "VBNET.ATG" 
+#line  3155 "VBNET.ATG" 
 out expr);
 				}
 
-//#line  3154 "VBNET.ATG" 
+#line  3157 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End);
 				
 			} else SynErr(299);
 		} else if (la.kind == 124) {
 			lexer.NextToken();
 
-//#line  3159 "VBNET.ATG" 
+#line  3162 "VBNET.ATG" 
 			Expression group = null;
 			TypeReference typeReference;
 			string        typeName;
@@ -5871,24 +5879,24 @@ out expr);
 			if (la.kind == 110) {
 				lexer.NextToken();
 				LoopControlVariable(
-//#line  3165 "VBNET.ATG" 
+#line  3168 "VBNET.ATG" 
 out typeReference, out typeName);
 				Expect(138);
 				Expr(
-//#line  3166 "VBNET.ATG" 
+#line  3169 "VBNET.ATG" 
 out group);
 				EndOfStmt();
 				Block(
-//#line  3167 "VBNET.ATG" 
+#line  3170 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(163);
 				if (StartOf(24)) {
 					Expr(
-//#line  3168 "VBNET.ATG" 
+#line  3171 "VBNET.ATG" 
 out expr);
 				}
 
-//#line  3170 "VBNET.ATG" 
+#line  3173 "VBNET.ATG" 
 				statement = new ForeachStatement(typeReference, 
 				                                typeName,
 				                                group, 
@@ -5900,7 +5908,7 @@ out expr);
 				
 			} else if (StartOf(44)) {
 
-//#line  3181 "VBNET.ATG" 
+#line  3184 "VBNET.ATG" 
 				Expression start = null;
 				Expression end = null;
 				Expression step = null;
@@ -5909,59 +5917,59 @@ out expr);
 				List<Expression> nextExpressions = null;
 				
 				if (
-//#line  3188 "VBNET.ATG" 
+#line  3191 "VBNET.ATG" 
 IsLoopVariableDeclaration()) {
 					LoopControlVariable(
-//#line  3189 "VBNET.ATG" 
+#line  3192 "VBNET.ATG" 
 out typeReference, out typeName);
 				} else {
 
-//#line  3191 "VBNET.ATG" 
+#line  3194 "VBNET.ATG" 
 					typeReference = null; typeName = null; 
 					SimpleExpr(
-//#line  3192 "VBNET.ATG" 
+#line  3195 "VBNET.ATG" 
 out variableExpr);
 				}
 				Expect(20);
 				Expr(
-//#line  3194 "VBNET.ATG" 
+#line  3197 "VBNET.ATG" 
 out start);
 				Expect(216);
 				Expr(
-//#line  3194 "VBNET.ATG" 
+#line  3197 "VBNET.ATG" 
 out end);
 				if (la.kind == 205) {
 					lexer.NextToken();
 					Expr(
-//#line  3194 "VBNET.ATG" 
+#line  3197 "VBNET.ATG" 
 out step);
 				}
 				EndOfStmt();
 				Block(
-//#line  3195 "VBNET.ATG" 
+#line  3198 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(163);
 				if (StartOf(24)) {
 					Expr(
-//#line  3198 "VBNET.ATG" 
+#line  3201 "VBNET.ATG" 
 out nextExpr);
 
-//#line  3200 "VBNET.ATG" 
+#line  3203 "VBNET.ATG" 
 					nextExpressions = new List<Expression>();
 					nextExpressions.Add(nextExpr);
 					
 					while (la.kind == 22) {
 						lexer.NextToken();
 						Expr(
-//#line  3203 "VBNET.ATG" 
+#line  3206 "VBNET.ATG" 
 out nextExpr);
 
-//#line  3203 "VBNET.ATG" 
+#line  3206 "VBNET.ATG" 
 						nextExpressions.Add(nextExpr); 
 					}
 				}
 
-//#line  3206 "VBNET.ATG" 
+#line  3209 "VBNET.ATG" 
 				statement = new ForNextStatement {
 				TypeReference = typeReference,
 				VariableName = typeName, 
@@ -5977,27 +5985,27 @@ out nextExpr);
 		} else if (la.kind == 118) {
 			lexer.NextToken();
 			Expr(
-//#line  3219 "VBNET.ATG" 
+#line  3222 "VBNET.ATG" 
 out expr);
 
-//#line  3219 "VBNET.ATG" 
+#line  3222 "VBNET.ATG" 
 			statement = new ErrorStatement(expr); 
 		} else if (la.kind == 191) {
 			lexer.NextToken();
 
-//#line  3221 "VBNET.ATG" 
+#line  3224 "VBNET.ATG" 
 			bool isPreserve = false; 
 			if (la.kind == 184) {
 				lexer.NextToken();
 
-//#line  3221 "VBNET.ATG" 
+#line  3224 "VBNET.ATG" 
 				isPreserve = true; 
 			}
 			ReDimClause(
-//#line  3222 "VBNET.ATG" 
+#line  3225 "VBNET.ATG" 
 out expr);
 
-//#line  3224 "VBNET.ATG" 
+#line  3227 "VBNET.ATG" 
 			ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
 			statement = reDimStatement;
 			SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
@@ -6005,48 +6013,48 @@ out expr);
 			while (la.kind == 22) {
 				lexer.NextToken();
 				ReDimClause(
-//#line  3228 "VBNET.ATG" 
+#line  3231 "VBNET.ATG" 
 out expr);
 
-//#line  3229 "VBNET.ATG" 
+#line  3232 "VBNET.ATG" 
 				SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression); 
 			}
 		} else if (la.kind == 117) {
 			lexer.NextToken();
 			Expr(
-//#line  3233 "VBNET.ATG" 
+#line  3236 "VBNET.ATG" 
 out expr);
 
-//#line  3235 "VBNET.ATG" 
+#line  3238 "VBNET.ATG" 
 			EraseStatement eraseStatement = new EraseStatement();
 			if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr);}
 			
 			while (la.kind == 22) {
 				lexer.NextToken();
 				Expr(
-//#line  3238 "VBNET.ATG" 
+#line  3241 "VBNET.ATG" 
 out expr);
 
-//#line  3238 "VBNET.ATG" 
+#line  3241 "VBNET.ATG" 
 				if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr); }
 			}
 
-//#line  3239 "VBNET.ATG" 
+#line  3242 "VBNET.ATG" 
 			statement = eraseStatement; 
 		} else if (la.kind == 206) {
 			lexer.NextToken();
 
-//#line  3241 "VBNET.ATG" 
+#line  3244 "VBNET.ATG" 
 			statement = new StopStatement(); 
 		} else if (
-//#line  3243 "VBNET.ATG" 
+#line  3246 "VBNET.ATG" 
 la.kind == Tokens.If) {
 			Expect(135);
 
-//#line  3244 "VBNET.ATG" 
+#line  3247 "VBNET.ATG" 
 			Location ifStartLocation = t.Location; 
 			Expr(
-//#line  3244 "VBNET.ATG" 
+#line  3247 "VBNET.ATG" 
 out expr);
 			if (la.kind == 214) {
 				lexer.NextToken();
@@ -6054,46 +6062,46 @@ out expr);
 			if (la.kind == 1 || la.kind == 21) {
 				EndOfStmt();
 				Block(
-//#line  3247 "VBNET.ATG" 
+#line  3250 "VBNET.ATG" 
 out embeddedStatement);
 
-//#line  3249 "VBNET.ATG" 
+#line  3252 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
 				ifStatement.StartLocation = ifStartLocation;
 				Location elseIfStart;
 				
 				while (la.kind == 112 || 
-//#line  3255 "VBNET.ATG" 
+#line  3258 "VBNET.ATG" 
 IsElseIf()) {
 					if (
-//#line  3255 "VBNET.ATG" 
+#line  3258 "VBNET.ATG" 
 IsElseIf()) {
 						Expect(111);
 
-//#line  3255 "VBNET.ATG" 
+#line  3258 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 						Expect(135);
 					} else {
 						lexer.NextToken();
 
-//#line  3256 "VBNET.ATG" 
+#line  3259 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 					}
 
-//#line  3258 "VBNET.ATG" 
+#line  3261 "VBNET.ATG" 
 					Expression condition = null; Statement block = null; 
 					Expr(
-//#line  3259 "VBNET.ATG" 
+#line  3262 "VBNET.ATG" 
 out condition);
 					if (la.kind == 214) {
 						lexer.NextToken();
 					}
 					EndOfStmt();
 					Block(
-//#line  3260 "VBNET.ATG" 
+#line  3263 "VBNET.ATG" 
 out block);
 
-//#line  3262 "VBNET.ATG" 
+#line  3265 "VBNET.ATG" 
 					ElseIfSection elseIfSection = new ElseIfSection(condition, block);
 					elseIfSection.StartLocation = elseIfStart;
 					elseIfSection.EndLocation = t.Location;
@@ -6107,39 +6115,39 @@ out block);
 						EndOfStmt();
 					}
 					Block(
-//#line  3271 "VBNET.ATG" 
+#line  3274 "VBNET.ATG" 
 out embeddedStatement);
 
-//#line  3273 "VBNET.ATG" 
+#line  3276 "VBNET.ATG" 
 					ifStatement.FalseStatement.Add(embeddedStatement);
 					
 				}
 				Expect(113);
 				Expect(135);
 
-//#line  3277 "VBNET.ATG" 
+#line  3280 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location;
 				statement = ifStatement;
 				
 			} else if (StartOf(45)) {
 
-//#line  3282 "VBNET.ATG" 
+#line  3285 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr);
 				ifStatement.StartLocation = ifStartLocation;
 				
 				SingleLineStatementList(
-//#line  3285 "VBNET.ATG" 
+#line  3288 "VBNET.ATG" 
 ifStatement.TrueStatement);
 				if (la.kind == 111) {
 					lexer.NextToken();
 					if (StartOf(45)) {
 						SingleLineStatementList(
-//#line  3288 "VBNET.ATG" 
+#line  3291 "VBNET.ATG" 
 ifStatement.FalseStatement);
 					}
 				}
 
-//#line  3290 "VBNET.ATG" 
+#line  3293 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location; statement = ifStatement; 
 			} else SynErr(301);
 		} else if (la.kind == 197) {
@@ -6148,82 +6156,82 @@ ifStatement.FalseStatement);
 				lexer.NextToken();
 			}
 			Expr(
-//#line  3293 "VBNET.ATG" 
+#line  3296 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 
-//#line  3294 "VBNET.ATG" 
+#line  3297 "VBNET.ATG" 
 			List<SwitchSection> selectSections = new List<SwitchSection>();
 			Statement block = null;
 			
 			while (la.kind == 74) {
 
-//#line  3298 "VBNET.ATG" 
+#line  3301 "VBNET.ATG" 
 				List<CaseLabel> caseClauses = null; Location caseLocation = la.Location; 
 				lexer.NextToken();
 				CaseClauses(
-//#line  3299 "VBNET.ATG" 
+#line  3302 "VBNET.ATG" 
 out caseClauses);
 				if (
-//#line  3299 "VBNET.ATG" 
+#line  3302 "VBNET.ATG" 
 IsNotStatementSeparator()) {
 					lexer.NextToken();
 				}
 				EndOfStmt();
 
-//#line  3301 "VBNET.ATG" 
+#line  3304 "VBNET.ATG" 
 				SwitchSection selectSection = new SwitchSection(caseClauses);
 				selectSection.StartLocation = caseLocation;
 				
 				Block(
-//#line  3304 "VBNET.ATG" 
+#line  3307 "VBNET.ATG" 
 out block);
 
-//#line  3306 "VBNET.ATG" 
+#line  3309 "VBNET.ATG" 
 				selectSection.Children = block.Children;
 				selectSection.EndLocation = t.EndLocation;
 				selectSections.Add(selectSection);
 				
 			}
 
-//#line  3312 "VBNET.ATG" 
+#line  3315 "VBNET.ATG" 
 			statement = new SwitchStatement(expr, selectSections);
 			
 			Expect(113);
 			Expect(197);
 		} else if (la.kind == 171) {
 
-//#line  3315 "VBNET.ATG" 
+#line  3318 "VBNET.ATG" 
 			OnErrorStatement onErrorStatement = null; 
 			OnErrorStatement(
-//#line  3316 "VBNET.ATG" 
+#line  3319 "VBNET.ATG" 
 out onErrorStatement);
 
-//#line  3316 "VBNET.ATG" 
+#line  3319 "VBNET.ATG" 
 			statement = onErrorStatement; 
 		} else if (la.kind == 132) {
 
-//#line  3317 "VBNET.ATG" 
+#line  3320 "VBNET.ATG" 
 			GotoStatement goToStatement = null; 
 			GotoStatement(
-//#line  3318 "VBNET.ATG" 
+#line  3321 "VBNET.ATG" 
 out goToStatement);
 
-//#line  3318 "VBNET.ATG" 
+#line  3321 "VBNET.ATG" 
 			statement = goToStatement; 
 		} else if (la.kind == 194) {
 
-//#line  3319 "VBNET.ATG" 
+#line  3322 "VBNET.ATG" 
 			ResumeStatement resumeStatement = null; 
 			ResumeStatement(
-//#line  3320 "VBNET.ATG" 
+#line  3323 "VBNET.ATG" 
 out resumeStatement);
 
-//#line  3320 "VBNET.ATG" 
+#line  3323 "VBNET.ATG" 
 			statement = resumeStatement; 
 		} else if (StartOf(44)) {
 
-//#line  3323 "VBNET.ATG" 
+#line  3326 "VBNET.ATG" 
 			Expression val = null;
 			AssignmentOperatorType op;
 			Location startLoc = la.Location;
@@ -6232,28 +6240,28 @@ out resumeStatement);
 			                        la.kind == Tokens.Not   || la.kind == Tokens.Times;
 			
 			SimpleExpr(
-//#line  3330 "VBNET.ATG" 
+#line  3333 "VBNET.ATG" 
 out expr);
 			if (StartOf(46)) {
 				AssignmentOperator(
-//#line  3332 "VBNET.ATG" 
+#line  3335 "VBNET.ATG" 
 out op);
 				Expr(
-//#line  3332 "VBNET.ATG" 
+#line  3335 "VBNET.ATG" 
 out val);
 
-//#line  3334 "VBNET.ATG" 
+#line  3337 "VBNET.ATG" 
 				expr = new AssignmentExpression(expr, op, val);
 				expr.StartLocation = startLoc;
 				expr.EndLocation = t.EndLocation;
 				
 			} else if (StartOf(47)) {
 
-//#line  3338 "VBNET.ATG" 
+#line  3341 "VBNET.ATG" 
 				if (mustBeAssignment) Error("error in assignment."); 
 			} else SynErr(302);
 
-//#line  3341 "VBNET.ATG" 
+#line  3344 "VBNET.ATG" 
 			// a field reference expression that stands alone is a
 			// invocation expression without parantheses and arguments
 			if(expr is MemberReferenceExpression || expr is IdentifierExpression) {
@@ -6267,58 +6275,58 @@ out val);
 		} else if (la.kind == 73) {
 			lexer.NextToken();
 			SimpleExpr(
-//#line  3351 "VBNET.ATG" 
+#line  3354 "VBNET.ATG" 
 out expr);
 
-//#line  3351 "VBNET.ATG" 
+#line  3354 "VBNET.ATG" 
 			statement = new ExpressionStatement(expr); 
 		} else if (la.kind == 226) {
 			lexer.NextToken();
 
-//#line  3353 "VBNET.ATG" 
+#line  3356 "VBNET.ATG" 
 			Statement block;  
 			if (
-//#line  3354 "VBNET.ATG" 
+#line  3357 "VBNET.ATG" 
 Peek(1).kind == Tokens.As) {
 
-//#line  3355 "VBNET.ATG" 
+#line  3358 "VBNET.ATG" 
 				LocalVariableDeclaration resourceAquisition = new LocalVariableDeclaration(Modifiers.None); 
 				VariableDeclarator(
-//#line  3356 "VBNET.ATG" 
+#line  3359 "VBNET.ATG" 
 resourceAquisition.Variables);
 				while (la.kind == 22) {
 					lexer.NextToken();
 					VariableDeclarator(
-//#line  3358 "VBNET.ATG" 
+#line  3361 "VBNET.ATG" 
 resourceAquisition.Variables);
 				}
 				Block(
-//#line  3360 "VBNET.ATG" 
+#line  3363 "VBNET.ATG" 
 out block);
 
-//#line  3362 "VBNET.ATG" 
+#line  3365 "VBNET.ATG" 
 				statement = new UsingStatement(resourceAquisition, block);
 				
 			} else if (StartOf(24)) {
 				Expr(
-//#line  3364 "VBNET.ATG" 
+#line  3367 "VBNET.ATG" 
 out expr);
 				Block(
-//#line  3365 "VBNET.ATG" 
+#line  3368 "VBNET.ATG" 
 out block);
 
-//#line  3366 "VBNET.ATG" 
+#line  3369 "VBNET.ATG" 
 				statement = new UsingStatement(new ExpressionStatement(expr), block); 
 			} else SynErr(303);
 			Expect(113);
 			Expect(226);
 		} else if (StartOf(48)) {
 			LocalDeclarationStatement(
-//#line  3369 "VBNET.ATG" 
+#line  3372 "VBNET.ATG" 
 out statement);
 		} else SynErr(304);
 
-//#line  3372 "VBNET.ATG" 
+#line  3375 "VBNET.ATG" 
 		if (statement != null) {
 		statement.StartLocation = startLocation;
 		statement.EndLocation = t.EndLocation;
@@ -6327,35 +6335,35 @@ out statement);
 	}
 
 	void FromOrAggregateQueryOperator(
-//#line  2309 "VBNET.ATG" 
+#line  2312 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-//#line  2311 "VBNET.ATG" 
+#line  2314 "VBNET.ATG" 
 		QueryExpressionFromClause fromClause = null;
 		QueryExpressionAggregateClause aggregateClause = null;
 		
 		if (la.kind == 126) {
 			FromQueryOperator(
-//#line  2314 "VBNET.ATG" 
+#line  2317 "VBNET.ATG" 
 out fromClause);
 
-//#line  2315 "VBNET.ATG" 
+#line  2318 "VBNET.ATG" 
 			middleClauses.Add(fromClause); 
 		} else if (la.kind == 58) {
 			AggregateQueryOperator(
-//#line  2316 "VBNET.ATG" 
+#line  2319 "VBNET.ATG" 
 out aggregateClause);
 
-//#line  2317 "VBNET.ATG" 
+#line  2320 "VBNET.ATG" 
 			middleClauses.Add(aggregateClause); 
 		} else SynErr(305);
 	}
 
 	void QueryOperator(
-//#line  2320 "VBNET.ATG" 
+#line  2323 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-//#line  2322 "VBNET.ATG" 
+#line  2325 "VBNET.ATG" 
 		QueryExpressionJoinVBClause joinClause = null;
 		QueryExpressionGroupVBClause groupByClause = null;
 		QueryExpressionPartitionVBClause partitionClause = null;
@@ -6365,94 +6373,94 @@ List<QueryExpressionClause> middleClauses) {
 		
 		if (la.kind == 126) {
 			FromQueryOperator(
-//#line  2329 "VBNET.ATG" 
+#line  2332 "VBNET.ATG" 
 out fromClause);
 
-//#line  2330 "VBNET.ATG" 
+#line  2333 "VBNET.ATG" 
 			middleClauses.Add(fromClause); 
 		} else if (la.kind == 58) {
 			AggregateQueryOperator(
-//#line  2331 "VBNET.ATG" 
+#line  2334 "VBNET.ATG" 
 out aggregateClause);
 
-//#line  2332 "VBNET.ATG" 
+#line  2335 "VBNET.ATG" 
 			middleClauses.Add(aggregateClause); 
 		} else if (la.kind == 197) {
 			SelectQueryOperator(
-//#line  2333 "VBNET.ATG" 
+#line  2336 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 107) {
 			DistinctQueryOperator(
-//#line  2334 "VBNET.ATG" 
+#line  2337 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 230) {
 			WhereQueryOperator(
-//#line  2335 "VBNET.ATG" 
+#line  2338 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 176) {
 			OrderByQueryOperator(
-//#line  2336 "VBNET.ATG" 
+#line  2339 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 203 || la.kind == 212) {
 			PartitionQueryOperator(
-//#line  2337 "VBNET.ATG" 
+#line  2340 "VBNET.ATG" 
 out partitionClause);
 
-//#line  2338 "VBNET.ATG" 
+#line  2341 "VBNET.ATG" 
 			middleClauses.Add(partitionClause); 
 		} else if (la.kind == 148) {
 			LetQueryOperator(
-//#line  2339 "VBNET.ATG" 
+#line  2342 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 146) {
 			JoinQueryOperator(
-//#line  2340 "VBNET.ATG" 
+#line  2343 "VBNET.ATG" 
 out joinClause);
 
-//#line  2341 "VBNET.ATG" 
+#line  2344 "VBNET.ATG" 
 			middleClauses.Add(joinClause); 
 		} else if (
-//#line  2342 "VBNET.ATG" 
+#line  2345 "VBNET.ATG" 
 la.kind == Tokens.Group && Peek(1).kind == Tokens.Join) {
 			GroupJoinQueryOperator(
-//#line  2342 "VBNET.ATG" 
+#line  2345 "VBNET.ATG" 
 out groupJoinClause);
 
-//#line  2343 "VBNET.ATG" 
+#line  2346 "VBNET.ATG" 
 			middleClauses.Add(groupJoinClause); 
 		} else if (la.kind == 133) {
 			GroupByQueryOperator(
-//#line  2344 "VBNET.ATG" 
+#line  2347 "VBNET.ATG" 
 out groupByClause);
 
-//#line  2345 "VBNET.ATG" 
+#line  2348 "VBNET.ATG" 
 			middleClauses.Add(groupByClause); 
 		} else SynErr(306);
 	}
 
 	void FromQueryOperator(
-//#line  2420 "VBNET.ATG" 
+#line  2423 "VBNET.ATG" 
 out QueryExpressionFromClause fromClause) {
 
-//#line  2422 "VBNET.ATG" 
+#line  2425 "VBNET.ATG" 
 		fromClause = new QueryExpressionFromClause();
 		fromClause.StartLocation = la.Location;
 		
 		Expect(126);
 		CollectionRangeVariableDeclarationList(
-//#line  2425 "VBNET.ATG" 
+#line  2428 "VBNET.ATG" 
 fromClause.Sources);
 
-//#line  2427 "VBNET.ATG" 
+#line  2430 "VBNET.ATG" 
 		fromClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void AggregateQueryOperator(
-//#line  2489 "VBNET.ATG" 
+#line  2492 "VBNET.ATG" 
 out QueryExpressionAggregateClause aggregateClause) {
 
-//#line  2491 "VBNET.ATG" 
+#line  2494 "VBNET.ATG" 
 		aggregateClause = new QueryExpressionAggregateClause();
 		aggregateClause.IntoVariables = new List<ExpressionRangeVariable>();
 		aggregateClause.StartLocation = la.Location;
@@ -6460,77 +6468,77 @@ out QueryExpressionAggregateClause aggregateClause) {
 		
 		Expect(58);
 		CollectionRangeVariableDeclaration(
-//#line  2496 "VBNET.ATG" 
+#line  2499 "VBNET.ATG" 
 out source);
 
-//#line  2498 "VBNET.ATG" 
+#line  2501 "VBNET.ATG" 
 		aggregateClause.Source = source;
 		
 		while (StartOf(31)) {
 			QueryOperator(
-//#line  2501 "VBNET.ATG" 
+#line  2504 "VBNET.ATG" 
 aggregateClause.MiddleClauses);
 		}
 		Expect(143);
 		ExpressionRangeVariableDeclarationList(
-//#line  2503 "VBNET.ATG" 
+#line  2506 "VBNET.ATG" 
 aggregateClause.IntoVariables);
 
-//#line  2505 "VBNET.ATG" 
+#line  2508 "VBNET.ATG" 
 		aggregateClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void SelectQueryOperator(
-//#line  2431 "VBNET.ATG" 
+#line  2434 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-//#line  2433 "VBNET.ATG" 
+#line  2436 "VBNET.ATG" 
 		QueryExpressionSelectVBClause selectClause = new QueryExpressionSelectVBClause();
 		selectClause.StartLocation = la.Location;
 		
 		Expect(197);
 		ExpressionRangeVariableDeclarationList(
-//#line  2436 "VBNET.ATG" 
+#line  2439 "VBNET.ATG" 
 selectClause.Variables);
 
-//#line  2438 "VBNET.ATG" 
+#line  2441 "VBNET.ATG" 
 		selectClause.EndLocation = t.Location;
 		middleClauses.Add(selectClause);
 		
 	}
 
 	void DistinctQueryOperator(
-//#line  2443 "VBNET.ATG" 
+#line  2446 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-//#line  2445 "VBNET.ATG" 
+#line  2448 "VBNET.ATG" 
 		QueryExpressionDistinctClause distinctClause = new QueryExpressionDistinctClause();
 		distinctClause.StartLocation = la.Location;
 		
 		Expect(107);
 
-//#line  2450 "VBNET.ATG" 
+#line  2453 "VBNET.ATG" 
 		distinctClause.EndLocation = t.EndLocation;
 		middleClauses.Add(distinctClause);
 		
 	}
 
 	void WhereQueryOperator(
-//#line  2455 "VBNET.ATG" 
+#line  2458 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-//#line  2457 "VBNET.ATG" 
+#line  2460 "VBNET.ATG" 
 		QueryExpressionWhereClause whereClause = new QueryExpressionWhereClause();
 		whereClause.StartLocation = la.Location;
 		Expression operand = null;
 		
 		Expect(230);
 		Expr(
-//#line  2461 "VBNET.ATG" 
+#line  2464 "VBNET.ATG" 
 out operand);
 
-//#line  2463 "VBNET.ATG" 
+#line  2466 "VBNET.ATG" 
 		whereClause.Condition = operand;
 		whereClause.EndLocation = t.EndLocation;
 		
@@ -6539,10 +6547,10 @@ out operand);
 	}
 
 	void OrderByQueryOperator(
-//#line  2348 "VBNET.ATG" 
+#line  2351 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-//#line  2350 "VBNET.ATG" 
+#line  2353 "VBNET.ATG" 
 		QueryExpressionOrderClause orderClause = new QueryExpressionOrderClause();
 		orderClause.StartLocation = la.Location;
 		List<QueryExpressionOrdering> orderings = null;
@@ -6550,10 +6558,10 @@ List<QueryExpressionClause> middleClauses) {
 		Expect(176);
 		Expect(70);
 		OrderExpressionList(
-//#line  2354 "VBNET.ATG" 
+#line  2357 "VBNET.ATG" 
 out orderings);
 
-//#line  2356 "VBNET.ATG" 
+#line  2359 "VBNET.ATG" 
 		orderClause.Orderings = orderings;
 		orderClause.EndLocation = t.EndLocation;
 		middleClauses.Add(orderClause);
@@ -6561,10 +6569,10 @@ out orderings);
 	}
 
 	void PartitionQueryOperator(
-//#line  2470 "VBNET.ATG" 
+#line  2473 "VBNET.ATG" 
 out QueryExpressionPartitionVBClause partitionClause) {
 
-//#line  2472 "VBNET.ATG" 
+#line  2475 "VBNET.ATG" 
 		partitionClause = new QueryExpressionPartitionVBClause();
 		partitionClause.StartLocation = la.Location;
 		Expression expr = null;
@@ -6572,60 +6580,60 @@ out QueryExpressionPartitionVBClause partitionClause) {
 		if (la.kind == 212) {
 			lexer.NextToken();
 
-//#line  2477 "VBNET.ATG" 
+#line  2480 "VBNET.ATG" 
 			partitionClause.PartitionType = QueryExpressionPartitionType.Take; 
 			if (la.kind == 231) {
 				lexer.NextToken();
 
-//#line  2478 "VBNET.ATG" 
+#line  2481 "VBNET.ATG" 
 				partitionClause.PartitionType = QueryExpressionPartitionType.TakeWhile; 
 			}
 		} else if (la.kind == 203) {
 			lexer.NextToken();
 
-//#line  2479 "VBNET.ATG" 
+#line  2482 "VBNET.ATG" 
 			partitionClause.PartitionType = QueryExpressionPartitionType.Skip; 
 			if (la.kind == 231) {
 				lexer.NextToken();
 
-//#line  2480 "VBNET.ATG" 
+#line  2483 "VBNET.ATG" 
 				partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile; 
 			}
 		} else SynErr(307);
 		Expr(
-//#line  2482 "VBNET.ATG" 
+#line  2485 "VBNET.ATG" 
 out expr);
 
-//#line  2484 "VBNET.ATG" 
+#line  2487 "VBNET.ATG" 
 		partitionClause.Expression = expr;
 		partitionClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void LetQueryOperator(
-//#line  2509 "VBNET.ATG" 
+#line  2512 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-//#line  2511 "VBNET.ATG" 
+#line  2514 "VBNET.ATG" 
 		QueryExpressionLetVBClause letClause = new QueryExpressionLetVBClause();
 		letClause.StartLocation = la.Location;
 		
 		Expect(148);
 		ExpressionRangeVariableDeclarationList(
-//#line  2514 "VBNET.ATG" 
+#line  2517 "VBNET.ATG" 
 letClause.Variables);
 
-//#line  2516 "VBNET.ATG" 
+#line  2519 "VBNET.ATG" 
 		letClause.EndLocation = t.EndLocation;
 		middleClauses.Add(letClause);
 		
 	}
 
 	void JoinQueryOperator(
-//#line  2553 "VBNET.ATG" 
+#line  2556 "VBNET.ATG" 
 out QueryExpressionJoinVBClause joinClause) {
 
-//#line  2555 "VBNET.ATG" 
+#line  2558 "VBNET.ATG" 
 		joinClause = new QueryExpressionJoinVBClause();
 		joinClause.StartLocation = la.Location;
 		CollectionRangeVariable joinVariable = null;
@@ -6635,203 +6643,203 @@ out QueryExpressionJoinVBClause joinClause) {
 		
 		Expect(146);
 		CollectionRangeVariableDeclaration(
-//#line  2562 "VBNET.ATG" 
+#line  2565 "VBNET.ATG" 
 out joinVariable);
 
-//#line  2563 "VBNET.ATG" 
+#line  2566 "VBNET.ATG" 
 		joinClause.JoinVariable = joinVariable; 
 		if (la.kind == 146) {
 			JoinQueryOperator(
-//#line  2565 "VBNET.ATG" 
+#line  2568 "VBNET.ATG" 
 out subJoin);
 
-//#line  2566 "VBNET.ATG" 
+#line  2569 "VBNET.ATG" 
 			joinClause.SubJoin = subJoin; 
 		}
 		Expect(171);
 		JoinCondition(
-//#line  2569 "VBNET.ATG" 
+#line  2572 "VBNET.ATG" 
 out condition);
 
-//#line  2570 "VBNET.ATG" 
+#line  2573 "VBNET.ATG" 
 		SafeAdd(joinClause, joinClause.Conditions, condition); 
 		while (la.kind == 60) {
 			lexer.NextToken();
 			JoinCondition(
-//#line  2572 "VBNET.ATG" 
+#line  2575 "VBNET.ATG" 
 out condition);
 
-//#line  2573 "VBNET.ATG" 
+#line  2576 "VBNET.ATG" 
 			SafeAdd(joinClause, joinClause.Conditions, condition); 
 		}
 
-//#line  2576 "VBNET.ATG" 
+#line  2579 "VBNET.ATG" 
 		joinClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void GroupJoinQueryOperator(
-//#line  2406 "VBNET.ATG" 
+#line  2409 "VBNET.ATG" 
 out QueryExpressionGroupJoinVBClause groupJoinClause) {
 
-//#line  2408 "VBNET.ATG" 
+#line  2411 "VBNET.ATG" 
 		groupJoinClause = new QueryExpressionGroupJoinVBClause();
 		groupJoinClause.StartLocation = la.Location;
 		QueryExpressionJoinVBClause joinClause = null;
 		
 		Expect(133);
 		JoinQueryOperator(
-//#line  2412 "VBNET.ATG" 
+#line  2415 "VBNET.ATG" 
 out joinClause);
 		Expect(143);
 		ExpressionRangeVariableDeclarationList(
-//#line  2413 "VBNET.ATG" 
+#line  2416 "VBNET.ATG" 
 groupJoinClause.IntoVariables);
 
-//#line  2415 "VBNET.ATG" 
+#line  2418 "VBNET.ATG" 
 		groupJoinClause.JoinClause = joinClause;
 		groupJoinClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void GroupByQueryOperator(
-//#line  2393 "VBNET.ATG" 
+#line  2396 "VBNET.ATG" 
 out QueryExpressionGroupVBClause groupByClause) {
 
-//#line  2395 "VBNET.ATG" 
+#line  2398 "VBNET.ATG" 
 		groupByClause = new QueryExpressionGroupVBClause();
 		groupByClause.StartLocation = la.Location;
 		
 		Expect(133);
 		ExpressionRangeVariableDeclarationList(
-//#line  2398 "VBNET.ATG" 
+#line  2401 "VBNET.ATG" 
 groupByClause.GroupVariables);
 		Expect(70);
 		ExpressionRangeVariableDeclarationList(
-//#line  2399 "VBNET.ATG" 
+#line  2402 "VBNET.ATG" 
 groupByClause.ByVariables);
 		Expect(143);
 		ExpressionRangeVariableDeclarationList(
-//#line  2400 "VBNET.ATG" 
+#line  2403 "VBNET.ATG" 
 groupByClause.IntoVariables);
 
-//#line  2402 "VBNET.ATG" 
+#line  2405 "VBNET.ATG" 
 		groupByClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void OrderExpressionList(
-//#line  2362 "VBNET.ATG" 
+#line  2365 "VBNET.ATG" 
 out List<QueryExpressionOrdering> orderings) {
 
-//#line  2364 "VBNET.ATG" 
+#line  2367 "VBNET.ATG" 
 		orderings = new List<QueryExpressionOrdering>();
 		QueryExpressionOrdering ordering = null;
 		
 		OrderExpression(
-//#line  2367 "VBNET.ATG" 
+#line  2370 "VBNET.ATG" 
 out ordering);
 
-//#line  2368 "VBNET.ATG" 
+#line  2371 "VBNET.ATG" 
 		orderings.Add(ordering); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			OrderExpression(
-//#line  2370 "VBNET.ATG" 
+#line  2373 "VBNET.ATG" 
 out ordering);
 
-//#line  2371 "VBNET.ATG" 
+#line  2374 "VBNET.ATG" 
 			orderings.Add(ordering); 
 		}
 	}
 
 	void OrderExpression(
-//#line  2375 "VBNET.ATG" 
+#line  2378 "VBNET.ATG" 
 out QueryExpressionOrdering ordering) {
 
-//#line  2377 "VBNET.ATG" 
+#line  2380 "VBNET.ATG" 
 		ordering = new QueryExpressionOrdering();
 		ordering.StartLocation = la.Location;
 		ordering.Direction = QueryExpressionOrderingDirection.None;
 		Expression orderExpr = null;
 		
 		Expr(
-//#line  2382 "VBNET.ATG" 
+#line  2385 "VBNET.ATG" 
 out orderExpr);
 
-//#line  2384 "VBNET.ATG" 
+#line  2387 "VBNET.ATG" 
 		ordering.Criteria = orderExpr;
 		
 		if (la.kind == 64 || la.kind == 104) {
 			if (la.kind == 64) {
 				lexer.NextToken();
 
-//#line  2387 "VBNET.ATG" 
+#line  2390 "VBNET.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Ascending; 
 			} else {
 				lexer.NextToken();
 
-//#line  2388 "VBNET.ATG" 
+#line  2391 "VBNET.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Descending; 
 			}
 		}
 
-//#line  2390 "VBNET.ATG" 
+#line  2393 "VBNET.ATG" 
 		ordering.EndLocation = t.EndLocation; 
 	}
 
 	void ExpressionRangeVariableDeclarationList(
-//#line  2521 "VBNET.ATG" 
+#line  2524 "VBNET.ATG" 
 List<ExpressionRangeVariable> variables) {
 
-//#line  2523 "VBNET.ATG" 
+#line  2526 "VBNET.ATG" 
 		ExpressionRangeVariable variable = null;
 		
 		ExpressionRangeVariableDeclaration(
-//#line  2525 "VBNET.ATG" 
+#line  2528 "VBNET.ATG" 
 out variable);
 
-//#line  2526 "VBNET.ATG" 
+#line  2529 "VBNET.ATG" 
 		variables.Add(variable); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			ExpressionRangeVariableDeclaration(
-//#line  2527 "VBNET.ATG" 
+#line  2530 "VBNET.ATG" 
 out variable);
 
-//#line  2527 "VBNET.ATG" 
+#line  2530 "VBNET.ATG" 
 			variables.Add(variable); 
 		}
 	}
 
 	void CollectionRangeVariableDeclarationList(
-//#line  2580 "VBNET.ATG" 
+#line  2583 "VBNET.ATG" 
 List<CollectionRangeVariable> rangeVariables) {
 
-//#line  2581 "VBNET.ATG" 
+#line  2584 "VBNET.ATG" 
 		CollectionRangeVariable variableDeclaration; 
 		CollectionRangeVariableDeclaration(
-//#line  2583 "VBNET.ATG" 
+#line  2586 "VBNET.ATG" 
 out variableDeclaration);
 
-//#line  2584 "VBNET.ATG" 
+#line  2587 "VBNET.ATG" 
 		rangeVariables.Add(variableDeclaration); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			CollectionRangeVariableDeclaration(
-//#line  2585 "VBNET.ATG" 
+#line  2588 "VBNET.ATG" 
 out variableDeclaration);
 
-//#line  2585 "VBNET.ATG" 
+#line  2588 "VBNET.ATG" 
 			rangeVariables.Add(variableDeclaration); 
 		}
 	}
 
 	void CollectionRangeVariableDeclaration(
-//#line  2588 "VBNET.ATG" 
+#line  2591 "VBNET.ATG" 
 out CollectionRangeVariable rangeVariable) {
 
-//#line  2590 "VBNET.ATG" 
+#line  2593 "VBNET.ATG" 
 		rangeVariable = new CollectionRangeVariable();
 		rangeVariable.StartLocation = la.Location;
 		TypeReference typeName = null;
@@ -6839,71 +6847,71 @@ out CollectionRangeVariable rangeVariable) {
 		
 		Identifier();
 
-//#line  2595 "VBNET.ATG" 
+#line  2598 "VBNET.ATG" 
 		rangeVariable.Identifier = t.val; 
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-//#line  2596 "VBNET.ATG" 
+#line  2599 "VBNET.ATG" 
 out typeName);
 
-//#line  2596 "VBNET.ATG" 
+#line  2599 "VBNET.ATG" 
 			rangeVariable.Type = typeName; 
 		}
 		Expect(138);
 		Expr(
-//#line  2597 "VBNET.ATG" 
+#line  2600 "VBNET.ATG" 
 out inExpr);
 
-//#line  2599 "VBNET.ATG" 
+#line  2602 "VBNET.ATG" 
 		rangeVariable.Expression = inExpr;
 		rangeVariable.EndLocation = t.EndLocation;
 		
 	}
 
 	void ExpressionRangeVariableDeclaration(
-//#line  2530 "VBNET.ATG" 
+#line  2533 "VBNET.ATG" 
 out ExpressionRangeVariable variable) {
 
-//#line  2532 "VBNET.ATG" 
+#line  2535 "VBNET.ATG" 
 		variable = new ExpressionRangeVariable();
 		variable.StartLocation = la.Location;
 		Expression rhs = null;
 		TypeReference typeName = null;
 		
 		if (
-//#line  2538 "VBNET.ATG" 
+#line  2541 "VBNET.ATG" 
 IsIdentifiedExpressionRange()) {
 			Identifier();
 
-//#line  2539 "VBNET.ATG" 
+#line  2542 "VBNET.ATG" 
 			variable.Identifier = t.val; 
 			if (la.kind == 63) {
 				lexer.NextToken();
 				TypeName(
-//#line  2541 "VBNET.ATG" 
+#line  2544 "VBNET.ATG" 
 out typeName);
 
-//#line  2542 "VBNET.ATG" 
+#line  2545 "VBNET.ATG" 
 				variable.Type = typeName; 
 			}
 			Expect(20);
 		}
 		Expr(
-//#line  2546 "VBNET.ATG" 
+#line  2549 "VBNET.ATG" 
 out rhs);
 
-//#line  2548 "VBNET.ATG" 
+#line  2551 "VBNET.ATG" 
 		variable.Expression = rhs;
 		variable.EndLocation = t.EndLocation;
 		
 	}
 
 	void JoinCondition(
-//#line  2604 "VBNET.ATG" 
+#line  2607 "VBNET.ATG" 
 out QueryExpressionJoinConditionVB condition) {
 
-//#line  2606 "VBNET.ATG" 
+#line  2609 "VBNET.ATG" 
 		condition = new QueryExpressionJoinConditionVB();
 		condition.StartLocation = la.Location;
 		
@@ -6911,14 +6919,14 @@ out QueryExpressionJoinConditionVB condition) {
 		Expression rhs = null;
 		
 		Expr(
-//#line  2612 "VBNET.ATG" 
+#line  2615 "VBNET.ATG" 
 out lhs);
 		Expect(116);
 		Expr(
-//#line  2612 "VBNET.ATG" 
+#line  2615 "VBNET.ATG" 
 out rhs);
 
-//#line  2614 "VBNET.ATG" 
+#line  2617 "VBNET.ATG" 
 		condition.LeftSide = lhs;
 		condition.RightSide = rhs;
 		condition.EndLocation = t.EndLocation;
@@ -6926,69 +6934,69 @@ out rhs);
 	}
 
 	void Argument(
-//#line  2678 "VBNET.ATG" 
+#line  2681 "VBNET.ATG" 
 out Expression argumentexpr) {
 
-//#line  2680 "VBNET.ATG" 
+#line  2683 "VBNET.ATG" 
 		Expression expr;
 		argumentexpr = null;
 		string name;
 		Location startLocation = la.Location;
 		
 		if (
-//#line  2685 "VBNET.ATG" 
+#line  2688 "VBNET.ATG" 
 IsNamedAssign()) {
 			Identifier();
 
-//#line  2685 "VBNET.ATG" 
+#line  2688 "VBNET.ATG" 
 			name = t.val;  
 			Expect(55);
 			Expr(
-//#line  2685 "VBNET.ATG" 
+#line  2688 "VBNET.ATG" 
 out expr);
 
-//#line  2687 "VBNET.ATG" 
+#line  2690 "VBNET.ATG" 
 			argumentexpr = new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };
 			
 		} else if (StartOf(24)) {
 			Expr(
-//#line  2690 "VBNET.ATG" 
+#line  2693 "VBNET.ATG" 
 out argumentexpr);
 		} else SynErr(308);
 	}
 
 	void QualIdentAndTypeArguments(
-//#line  2758 "VBNET.ATG" 
+#line  2761 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-//#line  2759 "VBNET.ATG" 
+#line  2762 "VBNET.ATG" 
 		string name; typeref = null; 
 		Qualident(
-//#line  2761 "VBNET.ATG" 
+#line  2764 "VBNET.ATG" 
 out name);
 
-//#line  2762 "VBNET.ATG" 
+#line  2765 "VBNET.ATG" 
 		typeref = new TypeReference(name); 
 		if (
-//#line  2763 "VBNET.ATG" 
+#line  2766 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			lexer.NextToken();
 			Expect(169);
 			if (
-//#line  2765 "VBNET.ATG" 
+#line  2768 "VBNET.ATG" 
 canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma)) {
 
-//#line  2766 "VBNET.ATG" 
+#line  2769 "VBNET.ATG" 
 				typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				while (la.kind == 22) {
 					lexer.NextToken();
 
-//#line  2767 "VBNET.ATG" 
+#line  2770 "VBNET.ATG" 
 					typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				}
 			} else if (StartOf(8)) {
 				TypeArgumentList(
-//#line  2768 "VBNET.ATG" 
+#line  2771 "VBNET.ATG" 
 typeref.GenericTypes);
 			} else SynErr(309);
 			Expect(38);
@@ -6996,24 +7004,24 @@ typeref.GenericTypes);
 	}
 
 	void RankList(
-//#line  2805 "VBNET.ATG" 
+#line  2808 "VBNET.ATG" 
 out int i) {
 
-//#line  2806 "VBNET.ATG" 
+#line  2809 "VBNET.ATG" 
 		i = 0; 
 		while (la.kind == 22) {
 			lexer.NextToken();
 
-//#line  2807 "VBNET.ATG" 
+#line  2810 "VBNET.ATG" 
 			++i; 
 		}
 	}
 
 	void Attribute(
-//#line  2846 "VBNET.ATG" 
+#line  2849 "VBNET.ATG" 
 out ASTAttribute attribute) {
 
-//#line  2848 "VBNET.ATG" 
+#line  2851 "VBNET.ATG" 
 		string name;
 		List<Expression> positional = new List<Expression>();
 		List<NamedArgumentExpression> named = new List<NamedArgumentExpression>();
@@ -7024,43 +7032,43 @@ out ASTAttribute attribute) {
 			Expect(26);
 		}
 		Qualident(
-//#line  2854 "VBNET.ATG" 
+#line  2857 "VBNET.ATG" 
 out name);
 		if (la.kind == 37) {
 			AttributeArguments(
-//#line  2855 "VBNET.ATG" 
+#line  2858 "VBNET.ATG" 
 positional, named);
 		}
 
-//#line  2857 "VBNET.ATG" 
+#line  2860 "VBNET.ATG" 
 		attribute  = new ASTAttribute(name, positional, named) { StartLocation = startLocation, EndLocation = t.EndLocation };
 		
 	}
 
 	void AttributeArguments(
-//#line  2862 "VBNET.ATG" 
+#line  2865 "VBNET.ATG" 
 List<Expression> positional, List<NamedArgumentExpression> named) {
 
-//#line  2864 "VBNET.ATG" 
+#line  2867 "VBNET.ATG" 
 		bool nameFound = false;
 		string name = "";
 		Expression expr;
 		
 		Expect(37);
 		if (
-//#line  2870 "VBNET.ATG" 
+#line  2873 "VBNET.ATG" 
 IsNotClosingParenthesis()) {
 
-//#line  2871 "VBNET.ATG" 
+#line  2874 "VBNET.ATG" 
 			Location startLocation = la.Location; 
 			if (
-//#line  2873 "VBNET.ATG" 
+#line  2876 "VBNET.ATG" 
 IsNamedAssign()) {
 
-//#line  2873 "VBNET.ATG" 
+#line  2876 "VBNET.ATG" 
 				nameFound = true; 
 				IdentifierOrKeyword(
-//#line  2874 "VBNET.ATG" 
+#line  2877 "VBNET.ATG" 
 out name);
 				if (la.kind == 55) {
 					lexer.NextToken();
@@ -7069,10 +7077,10 @@ out name);
 				} else SynErr(310);
 			}
 			Expr(
-//#line  2876 "VBNET.ATG" 
+#line  2879 "VBNET.ATG" 
 out expr);
 
-//#line  2878 "VBNET.ATG" 
+#line  2881 "VBNET.ATG" 
 			if (expr != null) {
 			if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
 			else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
@@ -7081,13 +7089,13 @@ out expr);
 			while (la.kind == 22) {
 				lexer.NextToken();
 				if (
-//#line  2886 "VBNET.ATG" 
+#line  2889 "VBNET.ATG" 
 IsNamedAssign()) {
 
-//#line  2886 "VBNET.ATG" 
+#line  2889 "VBNET.ATG" 
 					nameFound = true; 
 					IdentifierOrKeyword(
-//#line  2887 "VBNET.ATG" 
+#line  2890 "VBNET.ATG" 
 out name);
 					if (la.kind == 55) {
 						lexer.NextToken();
@@ -7096,14 +7104,14 @@ out name);
 					} else SynErr(311);
 				} else if (StartOf(24)) {
 
-//#line  2889 "VBNET.ATG" 
+#line  2892 "VBNET.ATG" 
 					if (nameFound) Error("no positional argument after named argument"); 
 				} else SynErr(312);
 				Expr(
-//#line  2890 "VBNET.ATG" 
+#line  2893 "VBNET.ATG" 
 out expr);
 
-//#line  2890 "VBNET.ATG" 
+#line  2893 "VBNET.ATG" 
 				if (expr != null) { if(name == "") positional.Add(expr);
 				else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
 				}
@@ -7114,34 +7122,34 @@ out expr);
 	}
 
 	void ParameterModifier(
-//#line  3701 "VBNET.ATG" 
+#line  3704 "VBNET.ATG" 
 ParamModifierList m) {
 		if (la.kind == 72) {
 			lexer.NextToken();
 
-//#line  3702 "VBNET.ATG" 
+#line  3705 "VBNET.ATG" 
 			m.Add(ParameterModifiers.In); 
 		} else if (la.kind == 69) {
 			lexer.NextToken();
 
-//#line  3703 "VBNET.ATG" 
+#line  3706 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Ref); 
 		} else if (la.kind == 174) {
 			lexer.NextToken();
 
-//#line  3704 "VBNET.ATG" 
+#line  3707 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Optional); 
 		} else if (la.kind == 182) {
 			lexer.NextToken();
 
-//#line  3705 "VBNET.ATG" 
+#line  3708 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Params); 
 		} else SynErr(313);
 	}
 
 	void Statement() {
 
-//#line  3017 "VBNET.ATG" 
+#line  3020 "VBNET.ATG" 
 		Statement stmt = null;
 		Location startPos = la.Location;
 		string label = String.Empty;
@@ -7149,27 +7157,27 @@ ParamModifierList m) {
 		
 		if (la.kind == 1 || la.kind == 21) {
 		} else if (
-//#line  3023 "VBNET.ATG" 
+#line  3026 "VBNET.ATG" 
 IsLabel()) {
 			LabelName(
-//#line  3023 "VBNET.ATG" 
+#line  3026 "VBNET.ATG" 
 out label);
 
-//#line  3025 "VBNET.ATG" 
+#line  3028 "VBNET.ATG" 
 			AddChild(new LabelStatement(t.val));
 			
 			Expect(21);
 			Statement();
 		} else if (StartOf(49)) {
 			EmbeddedStatement(
-//#line  3028 "VBNET.ATG" 
+#line  3031 "VBNET.ATG" 
 out stmt);
 
-//#line  3028 "VBNET.ATG" 
+#line  3031 "VBNET.ATG" 
 			AddChild(stmt); 
 		} else SynErr(314);
 
-//#line  3031 "VBNET.ATG" 
+#line  3034 "VBNET.ATG" 
 		if (stmt != null) {
 		stmt.StartLocation = startPos;
 		stmt.EndLocation = t.Location;
@@ -7178,30 +7186,30 @@ out stmt);
 	}
 
 	void LabelName(
-//#line  3471 "VBNET.ATG" 
+#line  3474 "VBNET.ATG" 
 out string name) {
 
-//#line  3473 "VBNET.ATG" 
+#line  3476 "VBNET.ATG" 
 		name = String.Empty;
 		
 		if (StartOf(4)) {
 			Identifier();
 
-//#line  3475 "VBNET.ATG" 
+#line  3478 "VBNET.ATG" 
 			name = t.val; 
 		} else if (la.kind == 5) {
 			lexer.NextToken();
 
-//#line  3476 "VBNET.ATG" 
+#line  3479 "VBNET.ATG" 
 			name = t.val; 
 		} else SynErr(315);
 	}
 
 	void LocalDeclarationStatement(
-//#line  3039 "VBNET.ATG" 
+#line  3042 "VBNET.ATG" 
 out Statement statement) {
 
-//#line  3041 "VBNET.ATG" 
+#line  3044 "VBNET.ATG" 
 		ModifierList m = new ModifierList();
 		LocalVariableDeclaration localVariableDeclaration;
 		bool dimfound = false;
@@ -7210,22 +7218,22 @@ out Statement statement) {
 			if (la.kind == 88) {
 				lexer.NextToken();
 
-//#line  3047 "VBNET.ATG" 
+#line  3050 "VBNET.ATG" 
 				m.Add(Modifiers.Const, t.Location); 
 			} else if (la.kind == 204) {
 				lexer.NextToken();
 
-//#line  3048 "VBNET.ATG" 
+#line  3051 "VBNET.ATG" 
 				m.Add(Modifiers.Static, t.Location); 
 			} else {
 				lexer.NextToken();
 
-//#line  3049 "VBNET.ATG" 
+#line  3052 "VBNET.ATG" 
 				dimfound = true; 
 			}
 		}
 
-//#line  3052 "VBNET.ATG" 
+#line  3055 "VBNET.ATG" 
 		if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
 		Error("Dim is not allowed on constants.");
 		}
@@ -7238,135 +7246,135 @@ out Statement statement) {
 		localVariableDeclaration.StartLocation = t.Location;
 		
 		VariableDeclarator(
-//#line  3063 "VBNET.ATG" 
+#line  3066 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		while (la.kind == 22) {
 			lexer.NextToken();
 			VariableDeclarator(
-//#line  3064 "VBNET.ATG" 
+#line  3067 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		}
 
-//#line  3066 "VBNET.ATG" 
+#line  3069 "VBNET.ATG" 
 		statement = localVariableDeclaration;
 		
 	}
 
 	void TryStatement(
-//#line  3589 "VBNET.ATG" 
+#line  3592 "VBNET.ATG" 
 out Statement tryStatement) {
 
-//#line  3591 "VBNET.ATG" 
+#line  3594 "VBNET.ATG" 
 		Statement blockStmt = null, finallyStmt = null;List<CatchClause> catchClauses = null;
 		
 		Expect(218);
 		EndOfStmt();
 		Block(
-//#line  3594 "VBNET.ATG" 
+#line  3597 "VBNET.ATG" 
 out blockStmt);
 		if (la.kind == 75 || la.kind == 113 || la.kind == 123) {
 			CatchClauses(
-//#line  3595 "VBNET.ATG" 
+#line  3598 "VBNET.ATG" 
 out catchClauses);
 		}
 		if (la.kind == 123) {
 			lexer.NextToken();
 			EndOfStmt();
 			Block(
-//#line  3596 "VBNET.ATG" 
+#line  3599 "VBNET.ATG" 
 out finallyStmt);
 		}
 		Expect(113);
 		Expect(218);
 
-//#line  3599 "VBNET.ATG" 
+#line  3602 "VBNET.ATG" 
 		tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
 		
 	}
 
 	void WithStatement(
-//#line  3569 "VBNET.ATG" 
+#line  3572 "VBNET.ATG" 
 out Statement withStatement) {
 
-//#line  3571 "VBNET.ATG" 
+#line  3574 "VBNET.ATG" 
 		Statement blockStmt = null;
 		Expression expr = null;
 		
 		Expect(233);
 
-//#line  3574 "VBNET.ATG" 
+#line  3577 "VBNET.ATG" 
 		Location start = t.Location; 
 		Expr(
-//#line  3575 "VBNET.ATG" 
+#line  3578 "VBNET.ATG" 
 out expr);
 		EndOfStmt();
 
-//#line  3577 "VBNET.ATG" 
+#line  3580 "VBNET.ATG" 
 		withStatement = new WithStatement(expr);
 		withStatement.StartLocation = start;
 		
 		Block(
-//#line  3580 "VBNET.ATG" 
+#line  3583 "VBNET.ATG" 
 out blockStmt);
 
-//#line  3582 "VBNET.ATG" 
+#line  3585 "VBNET.ATG" 
 		((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
 		
 		Expect(113);
 		Expect(233);
 
-//#line  3585 "VBNET.ATG" 
+#line  3588 "VBNET.ATG" 
 		withStatement.EndLocation = t.Location; 
 	}
 
 	void WhileOrUntil(
-//#line  3562 "VBNET.ATG" 
+#line  3565 "VBNET.ATG" 
 out ConditionType conditionType) {
 
-//#line  3563 "VBNET.ATG" 
+#line  3566 "VBNET.ATG" 
 		conditionType = ConditionType.None; 
 		if (la.kind == 231) {
 			lexer.NextToken();
 
-//#line  3564 "VBNET.ATG" 
+#line  3567 "VBNET.ATG" 
 			conditionType = ConditionType.While; 
 		} else if (la.kind == 224) {
 			lexer.NextToken();
 
-//#line  3565 "VBNET.ATG" 
+#line  3568 "VBNET.ATG" 
 			conditionType = ConditionType.Until; 
 		} else SynErr(316);
 	}
 
 	void LoopControlVariable(
-//#line  3393 "VBNET.ATG" 
+#line  3396 "VBNET.ATG" 
 out TypeReference type, out string name) {
 
-//#line  3394 "VBNET.ATG" 
+#line  3397 "VBNET.ATG" 
 		ArrayList arrayModifiers = null;
 		type = null;
 		
 		Qualident(
-//#line  3398 "VBNET.ATG" 
+#line  3401 "VBNET.ATG" 
 out name);
 		if (
-//#line  3399 "VBNET.ATG" 
+#line  3402 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-//#line  3399 "VBNET.ATG" 
+#line  3402 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-//#line  3400 "VBNET.ATG" 
+#line  3403 "VBNET.ATG" 
 out type);
 
-//#line  3400 "VBNET.ATG" 
+#line  3403 "VBNET.ATG" 
 			if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } 
 		}
 
-//#line  3402 "VBNET.ATG" 
+#line  3405 "VBNET.ATG" 
 		if (type != null) {
 		if(type.RankSpecifier != null && arrayModifiers != null) {
 			Error("array rank only allowed one time");
@@ -7378,34 +7386,34 @@ out type);
 	}
 
 	void ReDimClause(
-//#line  3480 "VBNET.ATG" 
+#line  3483 "VBNET.ATG" 
 out Expression expr) {
 		SimpleNonInvocationExpression(
-//#line  3482 "VBNET.ATG" 
+#line  3485 "VBNET.ATG" 
 out expr);
 		ReDimClauseInternal(
-//#line  3483 "VBNET.ATG" 
+#line  3486 "VBNET.ATG" 
 ref expr);
 	}
 
 	void SingleLineStatementList(
-//#line  3379 "VBNET.ATG" 
+#line  3382 "VBNET.ATG" 
 List<Statement> list) {
 
-//#line  3380 "VBNET.ATG" 
+#line  3383 "VBNET.ATG" 
 		Statement embeddedStatement = null; 
 		if (la.kind == 113) {
 			lexer.NextToken();
 
-//#line  3382 "VBNET.ATG" 
+#line  3385 "VBNET.ATG" 
 			embeddedStatement = new EndStatement() { StartLocation = t.Location, EndLocation = t.EndLocation }; 
 		} else if (StartOf(49)) {
 			EmbeddedStatement(
-//#line  3383 "VBNET.ATG" 
+#line  3386 "VBNET.ATG" 
 out embeddedStatement);
 		} else SynErr(317);
 
-//#line  3384 "VBNET.ATG" 
+#line  3387 "VBNET.ATG" 
 		if (embeddedStatement != null) list.Add(embeddedStatement); 
 		while (la.kind == 21) {
 			lexer.NextToken();
@@ -7415,49 +7423,49 @@ out embeddedStatement);
 			if (la.kind == 113) {
 				lexer.NextToken();
 
-//#line  3386 "VBNET.ATG" 
+#line  3389 "VBNET.ATG" 
 				embeddedStatement = new EndStatement() { StartLocation = t.Location, EndLocation = t.EndLocation }; 
 			} else if (StartOf(49)) {
 				EmbeddedStatement(
-//#line  3387 "VBNET.ATG" 
+#line  3390 "VBNET.ATG" 
 out embeddedStatement);
 			} else SynErr(318);
 
-//#line  3388 "VBNET.ATG" 
+#line  3391 "VBNET.ATG" 
 			if (embeddedStatement != null) list.Add(embeddedStatement); 
 		}
 	}
 
 	void CaseClauses(
-//#line  3522 "VBNET.ATG" 
+#line  3525 "VBNET.ATG" 
 out List<CaseLabel> caseClauses) {
 
-//#line  3524 "VBNET.ATG" 
+#line  3527 "VBNET.ATG" 
 		caseClauses = new List<CaseLabel>();
 		CaseLabel caseClause = null;
 		
 		CaseClause(
-//#line  3527 "VBNET.ATG" 
+#line  3530 "VBNET.ATG" 
 out caseClause);
 
-//#line  3527 "VBNET.ATG" 
+#line  3530 "VBNET.ATG" 
 		if (caseClause != null) { caseClauses.Add(caseClause); } 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			CaseClause(
-//#line  3528 "VBNET.ATG" 
+#line  3531 "VBNET.ATG" 
 out caseClause);
 
-//#line  3528 "VBNET.ATG" 
+#line  3531 "VBNET.ATG" 
 			if (caseClause != null) { caseClauses.Add(caseClause); } 
 		}
 	}
 
 	void OnErrorStatement(
-//#line  3413 "VBNET.ATG" 
+#line  3416 "VBNET.ATG" 
 out OnErrorStatement stmt) {
 
-//#line  3415 "VBNET.ATG" 
+#line  3418 "VBNET.ATG" 
 		stmt = null;
 		Location startLocation = la.Location;
 		GotoStatement goToStatement = null;
@@ -7465,13 +7473,13 @@ out OnErrorStatement stmt) {
 		Expect(171);
 		Expect(118);
 		if (
-//#line  3422 "VBNET.ATG" 
+#line  3425 "VBNET.ATG" 
 IsNegativeLabelName()) {
 			Expect(132);
 			Expect(30);
 			Expect(5);
 
-//#line  3424 "VBNET.ATG" 
+#line  3427 "VBNET.ATG" 
 			long intLabel = Int64.Parse(t.val);
 			if(intLabel != 1) {
 				Error("invalid label in on error statement.");
@@ -7480,10 +7488,10 @@ IsNegativeLabelName()) {
 			
 		} else if (la.kind == 132) {
 			GotoStatement(
-//#line  3430 "VBNET.ATG" 
+#line  3433 "VBNET.ATG" 
 out goToStatement);
 
-//#line  3432 "VBNET.ATG" 
+#line  3435 "VBNET.ATG" 
 			string val = goToStatement.Label;
 			
 			// if value is numeric, make sure that is 0
@@ -7500,12 +7508,12 @@ out goToStatement);
 			lexer.NextToken();
 			Expect(163);
 
-//#line  3446 "VBNET.ATG" 
+#line  3449 "VBNET.ATG" 
 			stmt = new OnErrorStatement(new ResumeStatement(true));
 			
 		} else SynErr(319);
 
-//#line  3450 "VBNET.ATG" 
+#line  3453 "VBNET.ATG" 
 		if (stmt != null) {
 		stmt.StartLocation = startLocation;
 		stmt.EndLocation = t.EndLocation;
@@ -7514,17 +7522,17 @@ out goToStatement);
 	}
 
 	void GotoStatement(
-//#line  3458 "VBNET.ATG" 
+#line  3461 "VBNET.ATG" 
 out GotoStatement goToStatement) {
 
-//#line  3459 "VBNET.ATG" 
+#line  3462 "VBNET.ATG" 
 		string label = String.Empty; Location startLocation = la.Location; 
 		Expect(132);
 		LabelName(
-//#line  3461 "VBNET.ATG" 
+#line  3464 "VBNET.ATG" 
 out label);
 
-//#line  3463 "VBNET.ATG" 
+#line  3466 "VBNET.ATG" 
 		goToStatement = new GotoStatement(label) {
 		StartLocation = startLocation,
 		EndLocation = t.EndLocation
@@ -7533,57 +7541,57 @@ out label);
 	}
 
 	void ResumeStatement(
-//#line  3511 "VBNET.ATG" 
+#line  3514 "VBNET.ATG" 
 out ResumeStatement resumeStatement) {
 
-//#line  3513 "VBNET.ATG" 
+#line  3516 "VBNET.ATG" 
 		resumeStatement = null;
 		string label = String.Empty;
 		
 		if (
-//#line  3516 "VBNET.ATG" 
+#line  3519 "VBNET.ATG" 
 IsResumeNext()) {
 			Expect(194);
 			Expect(163);
 
-//#line  3517 "VBNET.ATG" 
+#line  3520 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(true); 
 		} else if (la.kind == 194) {
 			lexer.NextToken();
 			if (StartOf(50)) {
 				LabelName(
-//#line  3518 "VBNET.ATG" 
+#line  3521 "VBNET.ATG" 
 out label);
 			}
 
-//#line  3518 "VBNET.ATG" 
+#line  3521 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(label); 
 		} else SynErr(320);
 	}
 
 	void ReDimClauseInternal(
-//#line  3486 "VBNET.ATG" 
+#line  3489 "VBNET.ATG" 
 ref Expression expr) {
 
-//#line  3487 "VBNET.ATG" 
+#line  3490 "VBNET.ATG" 
 		List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; Location startLocation = la.Location; 
 		while (la.kind == 26 || 
-//#line  3490 "VBNET.ATG" 
+#line  3493 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			if (la.kind == 26) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-//#line  3489 "VBNET.ATG" 
+#line  3492 "VBNET.ATG" 
 out name);
 
-//#line  3489 "VBNET.ATG" 
+#line  3492 "VBNET.ATG" 
 				expr = new MemberReferenceExpression(expr, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 			} else {
 				InvocationExpression(
-//#line  3491 "VBNET.ATG" 
+#line  3494 "VBNET.ATG" 
 ref expr);
 
-//#line  3493 "VBNET.ATG" 
+#line  3496 "VBNET.ATG" 
 				expr.StartLocation = startLocation;
 				expr.EndLocation = t.EndLocation;
 				
@@ -7591,11 +7599,11 @@ ref expr);
 		}
 		Expect(37);
 		NormalOrReDimArgumentList(
-//#line  3498 "VBNET.ATG" 
+#line  3501 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeRedim);
 		Expect(38);
 
-//#line  3500 "VBNET.ATG" 
+#line  3503 "VBNET.ATG" 
 		expr = new InvocationExpression(expr, arguments);
 		if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
 			if (this.Errors.Count == 0) {
@@ -7607,10 +7615,10 @@ out arguments, out canBeNormal, out canBeRedim);
 	}
 
 	void CaseClause(
-//#line  3532 "VBNET.ATG" 
+#line  3535 "VBNET.ATG" 
 out CaseLabel caseClause) {
 
-//#line  3534 "VBNET.ATG" 
+#line  3537 "VBNET.ATG" 
 		Expression expr = null;
 		Expression sexpr = null;
 		BinaryOperatorType op = BinaryOperatorType.None;
@@ -7619,7 +7627,7 @@ out CaseLabel caseClause) {
 		if (la.kind == 111) {
 			lexer.NextToken();
 
-//#line  3540 "VBNET.ATG" 
+#line  3543 "VBNET.ATG" 
 			caseClause = new CaseLabel(); 
 		} else if (StartOf(51)) {
 			if (la.kind == 144) {
@@ -7629,76 +7637,76 @@ out CaseLabel caseClause) {
 			case 40: {
 				lexer.NextToken();
 
-//#line  3544 "VBNET.ATG" 
+#line  3547 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 39: {
 				lexer.NextToken();
 
-//#line  3545 "VBNET.ATG" 
+#line  3548 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 43: {
 				lexer.NextToken();
 
-//#line  3546 "VBNET.ATG" 
+#line  3549 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 42: {
 				lexer.NextToken();
 
-//#line  3547 "VBNET.ATG" 
+#line  3550 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 20: {
 				lexer.NextToken();
 
-//#line  3548 "VBNET.ATG" 
+#line  3551 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 41: {
 				lexer.NextToken();
 
-//#line  3549 "VBNET.ATG" 
+#line  3552 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			default: SynErr(321); break;
 			}
 			Expr(
-//#line  3551 "VBNET.ATG" 
+#line  3554 "VBNET.ATG" 
 out expr);
 
-//#line  3553 "VBNET.ATG" 
+#line  3556 "VBNET.ATG" 
 			caseClause = new CaseLabel(op, expr);
 			
 		} else if (StartOf(24)) {
 			Expr(
-//#line  3555 "VBNET.ATG" 
+#line  3558 "VBNET.ATG" 
 out expr);
 			if (la.kind == 216) {
 				lexer.NextToken();
 				Expr(
-//#line  3555 "VBNET.ATG" 
+#line  3558 "VBNET.ATG" 
 out sexpr);
 			}
 
-//#line  3557 "VBNET.ATG" 
+#line  3560 "VBNET.ATG" 
 			caseClause = new CaseLabel(expr, sexpr);
 			
 		} else SynErr(322);
 	}
 
 	void CatchClauses(
-//#line  3604 "VBNET.ATG" 
+#line  3607 "VBNET.ATG" 
 out List<CatchClause> catchClauses) {
 
-//#line  3606 "VBNET.ATG" 
+#line  3609 "VBNET.ATG" 
 		catchClauses = new List<CatchClause>();
 		TypeReference type = null;
 		Statement blockStmt = null;
@@ -7710,27 +7718,27 @@ out List<CatchClause> catchClauses) {
 			if (StartOf(4)) {
 				Identifier();
 
-//#line  3614 "VBNET.ATG" 
+#line  3617 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 63) {
 					lexer.NextToken();
 					TypeName(
-//#line  3614 "VBNET.ATG" 
+#line  3617 "VBNET.ATG" 
 out type);
 				}
 			}
 			if (la.kind == 229) {
 				lexer.NextToken();
 				Expr(
-//#line  3615 "VBNET.ATG" 
+#line  3618 "VBNET.ATG" 
 out expr);
 			}
 			EndOfStmt();
 			Block(
-//#line  3617 "VBNET.ATG" 
+#line  3620 "VBNET.ATG" 
 out blockStmt);
 
-//#line  3618 "VBNET.ATG" 
+#line  3621 "VBNET.ATG" 
 			catchClauses.Add(new CatchClause(type, name, blockStmt, expr)); 
 		}
 	}
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
index ed814fad0b..75548a906f 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
@@ -1263,6 +1263,7 @@ StructureMemberDecl<ModifierList m, List<AttributeSection> attributes>
 			Parameters = parameters,
 			TypeReference = returnType,
 			OverloadableOperator = operatorType,
+			Name = GetReflectionNameForOperator(operatorType, opConversionType),
 			ConversionType = opConversionType,
 			Body = (BlockStatement)stmt,
 			StartLocation = m.GetDeclarationLocation(startPos),
@@ -1299,6 +1300,8 @@ OverloadableOperator<out OverloadableOperatorType operatorType>
 	|
 	"Xor"		(. operatorType = OverloadableOperatorType.ExclusiveOr; .)
 	|
+	"Not"		(. operatorType = OverloadableOperatorType.BitNot; .)
+	|
 	"^"			(. operatorType = OverloadableOperatorType.Power; .)
 	|
 	"<<"		(. operatorType = OverloadableOperatorType.ShiftLeft; .)
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNetParser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNetParser.cs
index 10f1c830e7..ca7aca494c 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNetParser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNetParser.cs
@@ -385,5 +385,74 @@ namespace ICSharpCode.NRefactory.Parser.VB
 				item.Parent = parent;
 			}
 		}
+		
+		internal static string GetReflectionNameForOperator(OverloadableOperatorType op, ConversionType conversion)
+		{
+			switch (op) {
+				case OverloadableOperatorType.Add:
+					return "op_Addition";
+				case OverloadableOperatorType.BitNot:
+					return "op_OnesComplement";
+				case OverloadableOperatorType.BitwiseAnd:
+					return "op_BitwiseAnd";
+				case OverloadableOperatorType.BitwiseOr:
+					return "op_BitwiseOr";
+				case OverloadableOperatorType.Concat:
+					return "op_Concatenate";
+				case OverloadableOperatorType.CType:
+					switch (conversion) {
+						case ConversionType.Implicit:
+							return "op_Implicit";
+						case ConversionType.Explicit:
+							return "op_Explicit";
+						default:
+							return "op_unknown";
+					}
+				case OverloadableOperatorType.Divide:
+					return "op_Division";
+				case OverloadableOperatorType.DivideInteger:
+					return "op_IntegerDivision";
+				case OverloadableOperatorType.Equality:
+					return "op_Equality";
+				case OverloadableOperatorType.ExclusiveOr:
+					return "op_ExclusiveOr";
+				case OverloadableOperatorType.GreaterThan:
+					return "op_GreaterThan";
+				case OverloadableOperatorType.GreaterThanOrEqual:
+					return "op_GreaterThanOrEqual";
+				case OverloadableOperatorType.InEquality:
+					return "op_Inequality";
+				case OverloadableOperatorType.IsFalse:
+					return "op_False";
+				case OverloadableOperatorType.IsTrue:
+					return "op_True";
+				case OverloadableOperatorType.LessThan:
+					return "op_LessThan";
+				case OverloadableOperatorType.LessThanOrEqual:
+					return "op_LessThanOrEqual";
+				case OverloadableOperatorType.Like:
+					return "op_Like";
+				case OverloadableOperatorType.Modulus:
+					return "op_Modulus";
+				case OverloadableOperatorType.Multiply:
+					return "op_Multiply";
+				case OverloadableOperatorType.Not:
+					return "op_LogicalNot";
+				case OverloadableOperatorType.Power:
+					return "op_Exponent";
+				case OverloadableOperatorType.ShiftLeft:
+					return "op_LeftShift";
+				case OverloadableOperatorType.ShiftRight:
+					return "op_RightShift";
+				case OverloadableOperatorType.Subtract:
+					return "op_Subtraction";
+				case OverloadableOperatorType.UnaryMinus:
+					return "op_UnaryNegation";
+				case OverloadableOperatorType.UnaryPlus:
+					return "op_UnaryPlus";
+				default:
+					return "op_unknown";
+			}
+		}
 	}
 }