diff --git a/src/Libraries/NRefactory/Project/Src/Ast/Enums.cs b/src/Libraries/NRefactory/Project/Src/Ast/Enums.cs
index 32dde466b9..ed5983c4f9 100644
--- a/src/Libraries/NRefactory/Project/Src/Ast/Enums.cs
+++ b/src/Libraries/NRefactory/Project/Src/Ast/Enums.cs
@@ -362,7 +362,8 @@ namespace ICSharpCode.NRefactory.Ast
 		Explicit,
 		Strict,
 		CompareBinary,
-		CompareText
+		CompareText,
+		Infer
 	}
 	
 	/// <summary>
@@ -370,6 +371,8 @@ namespace ICSharpCode.NRefactory.Ast
 	/// </summary>
 	public enum QueryExpressionOrderingDirection
 	{
-		None, Ascending, Descending
+		None,
+		Ascending,
+		Descending
 	}
 }
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
index 75a9fcf0cd..b05c7868aa 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
@@ -119,10 +119,20 @@ ref val);
 #line  254 "VBNET.ATG" 
 				node = new OptionDeclaration(OptionType.CompareText, val); 
 			} else SynErr(210);
+		} else if (la.kind == 118) {
+			lexer.NextToken();
+			if (la.kind == 146 || la.kind == 147) {
+				OptionValue(
+#line  257 "VBNET.ATG" 
+ref val);
+			}
+
+#line  258 "VBNET.ATG" 
+			node = new OptionDeclaration(OptionType.Infer, val); 
 		} else SynErr(211);
 		EndOfStmt();
 
-#line  259 "VBNET.ATG" 
+#line  262 "VBNET.ATG" 
 		if (node != null) {
 		node.StartLocation = startPos;
 		node.EndLocation   = t.Location;
@@ -133,33 +143,33 @@ ref val);
 
 	void ImportsStmt() {
 
-#line  282 "VBNET.ATG" 
+#line  285 "VBNET.ATG" 
 		List<Using> usings = new List<Using>();
 		
 		Expect(116);
 
-#line  286 "VBNET.ATG" 
+#line  289 "VBNET.ATG" 
 		Location startPos = t.Location;
 		Using u;
 		
 		ImportClause(
-#line  289 "VBNET.ATG" 
+#line  292 "VBNET.ATG" 
 out u);
 
-#line  289 "VBNET.ATG" 
+#line  292 "VBNET.ATG" 
 		if (u != null) { usings.Add(u); } 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			ImportClause(
-#line  291 "VBNET.ATG" 
+#line  294 "VBNET.ATG" 
 out u);
 
-#line  291 "VBNET.ATG" 
+#line  294 "VBNET.ATG" 
 			if (u != null) { usings.Add(u); } 
 		}
 		EndOfStmt();
 
-#line  295 "VBNET.ATG" 
+#line  298 "VBNET.ATG" 
 		UsingDeclaration usingDeclaration = new UsingDeclaration(usings);
 		usingDeclaration.StartLocation = startPos;
 		usingDeclaration.EndLocation   = t.Location;
@@ -170,7 +180,7 @@ out u);
 	void GlobalAttributeSection() {
 		Expect(28);
 
-#line  2178 "VBNET.ATG" 
+#line  2181 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (la.kind == 50) {
 			lexer.NextToken();
@@ -178,20 +188,20 @@ out u);
 			lexer.NextToken();
 		} else SynErr(212);
 
-#line  2180 "VBNET.ATG" 
+#line  2183 "VBNET.ATG" 
 		string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
 		List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		Expect(11);
 		Attribute(
-#line  2184 "VBNET.ATG" 
+#line  2187 "VBNET.ATG" 
 out attribute);
 
-#line  2184 "VBNET.ATG" 
+#line  2187 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2185 "VBNET.ATG" 
+#line  2188 "VBNET.ATG" 
 NotFinalComma()) {
 			if (la.kind == 12) {
 				lexer.NextToken();
@@ -203,10 +213,10 @@ NotFinalComma()) {
 				Expect(11);
 			}
 			Attribute(
-#line  2185 "VBNET.ATG" 
+#line  2188 "VBNET.ATG" 
 out attribute);
 
-#line  2185 "VBNET.ATG" 
+#line  2188 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 12) {
@@ -215,7 +225,7 @@ out attribute);
 		Expect(27);
 		EndOfStmt();
 
-#line  2190 "VBNET.ATG" 
+#line  2193 "VBNET.ATG" 
 		AttributeSection section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -228,7 +238,7 @@ out attribute);
 
 	void NamespaceMemberDecl() {
 
-#line  324 "VBNET.ATG" 
+#line  327 "VBNET.ATG" 
 		ModifierList m = new ModifierList();
 		AttributeSection section;
 		List<AttributeSection> attributes = new List<AttributeSection>();
@@ -237,14 +247,14 @@ out attribute);
 		if (la.kind == 136) {
 			lexer.NextToken();
 
-#line  331 "VBNET.ATG" 
+#line  334 "VBNET.ATG" 
 			Location startPos = t.Location;
 			
 			Qualident(
-#line  333 "VBNET.ATG" 
+#line  336 "VBNET.ATG" 
 out qualident);
 
-#line  335 "VBNET.ATG" 
+#line  338 "VBNET.ATG" 
 			INode node =  new NamespaceDeclaration(qualident);
 			node.StartLocation = startPos;
 			compilationUnit.AddChild(node);
@@ -253,66 +263,66 @@ out qualident);
 			EndOfStmt();
 			NamespaceBody();
 
-#line  343 "VBNET.ATG" 
+#line  346 "VBNET.ATG" 
 			node.EndLocation = t.Location;
 			compilationUnit.BlockEnd();
 			
 		} else if (StartOf(2)) {
 			while (la.kind == 28) {
 				AttributeSection(
-#line  347 "VBNET.ATG" 
+#line  350 "VBNET.ATG" 
 out section);
 
-#line  347 "VBNET.ATG" 
+#line  350 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(3)) {
 				TypeModifier(
-#line  348 "VBNET.ATG" 
+#line  351 "VBNET.ATG" 
 m);
 			}
 			NonModuleDeclaration(
-#line  348 "VBNET.ATG" 
+#line  351 "VBNET.ATG" 
 m, attributes);
 		} else SynErr(214);
 	}
 
 	void OptionValue(
-#line  267 "VBNET.ATG" 
+#line  270 "VBNET.ATG" 
 ref bool val) {
 		if (la.kind == 147) {
 			lexer.NextToken();
 
-#line  269 "VBNET.ATG" 
+#line  272 "VBNET.ATG" 
 			val = true; 
 		} else if (la.kind == 146) {
 			lexer.NextToken();
 
-#line  271 "VBNET.ATG" 
+#line  274 "VBNET.ATG" 
 			val = false; 
 		} else SynErr(215);
 	}
 
 	void ImportClause(
-#line  302 "VBNET.ATG" 
+#line  305 "VBNET.ATG" 
 out Using u) {
 
-#line  304 "VBNET.ATG" 
+#line  307 "VBNET.ATG" 
 		string qualident  = null;
 		TypeReference aliasedType = null;
 		u = null;
 		
 		Qualident(
-#line  308 "VBNET.ATG" 
+#line  311 "VBNET.ATG" 
 out qualident);
 		if (la.kind == 10) {
 			lexer.NextToken();
 			TypeName(
-#line  309 "VBNET.ATG" 
+#line  312 "VBNET.ATG" 
 out aliasedType);
 		}
 
-#line  311 "VBNET.ATG" 
+#line  314 "VBNET.ATG" 
 		if (qualident != null && qualident.Length > 0) {
 		if (aliasedType != null) {
 			u = new Using(qualident, aliasedType);
@@ -324,47 +334,47 @@ out aliasedType);
 	}
 
 	void Qualident(
-#line  2931 "VBNET.ATG" 
+#line  2934 "VBNET.ATG" 
 out string qualident) {
 
-#line  2933 "VBNET.ATG" 
+#line  2936 "VBNET.ATG" 
 		string name;
 		qualidentBuilder.Length = 0; 
 		
 		Identifier();
 
-#line  2937 "VBNET.ATG" 
+#line  2940 "VBNET.ATG" 
 		qualidentBuilder.Append(t.val); 
 		while (
-#line  2938 "VBNET.ATG" 
+#line  2941 "VBNET.ATG" 
 DotAndIdentOrKw()) {
 			Expect(16);
 			IdentifierOrKeyword(
-#line  2938 "VBNET.ATG" 
+#line  2941 "VBNET.ATG" 
 out name);
 
-#line  2938 "VBNET.ATG" 
+#line  2941 "VBNET.ATG" 
 			qualidentBuilder.Append('.'); qualidentBuilder.Append(name); 
 		}
 
-#line  2940 "VBNET.ATG" 
+#line  2943 "VBNET.ATG" 
 		qualident = qualidentBuilder.ToString(); 
 	}
 
 	void TypeName(
-#line  2051 "VBNET.ATG" 
+#line  2054 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  2052 "VBNET.ATG" 
+#line  2055 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  2054 "VBNET.ATG" 
+#line  2057 "VBNET.ATG" 
 out typeref, false);
 		ArrayTypeModifiers(
-#line  2058 "VBNET.ATG" 
+#line  2061 "VBNET.ATG" 
 out rank);
 
-#line  2059 "VBNET.ATG" 
+#line  2062 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -387,35 +397,35 @@ out rank);
 	}
 
 	void AttributeSection(
-#line  2255 "VBNET.ATG" 
+#line  2258 "VBNET.ATG" 
 out AttributeSection section) {
 
-#line  2257 "VBNET.ATG" 
+#line  2260 "VBNET.ATG" 
 		string attributeTarget = "";List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		
 		Expect(28);
 
-#line  2261 "VBNET.ATG" 
+#line  2264 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (
-#line  2262 "VBNET.ATG" 
+#line  2265 "VBNET.ATG" 
 IsLocalAttrTarget()) {
 			if (la.kind == 100) {
 				lexer.NextToken();
 
-#line  2263 "VBNET.ATG" 
+#line  2266 "VBNET.ATG" 
 				attributeTarget = "event";
 			} else if (la.kind == 169) {
 				lexer.NextToken();
 
-#line  2264 "VBNET.ATG" 
+#line  2267 "VBNET.ATG" 
 				attributeTarget = "return";
 			} else {
 				Identifier();
 
-#line  2267 "VBNET.ATG" 
+#line  2270 "VBNET.ATG" 
 				string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
 				if (val != "field"	|| val != "method" ||
 					val != "module" || val != "param"  ||
@@ -428,20 +438,20 @@ IsLocalAttrTarget()) {
 			Expect(11);
 		}
 		Attribute(
-#line  2277 "VBNET.ATG" 
+#line  2280 "VBNET.ATG" 
 out attribute);
 
-#line  2277 "VBNET.ATG" 
+#line  2280 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2278 "VBNET.ATG" 
+#line  2281 "VBNET.ATG" 
 NotFinalComma()) {
 			Expect(12);
 			Attribute(
-#line  2278 "VBNET.ATG" 
+#line  2281 "VBNET.ATG" 
 out attribute);
 
-#line  2278 "VBNET.ATG" 
+#line  2281 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 12) {
@@ -449,7 +459,7 @@ out attribute);
 		}
 		Expect(27);
 
-#line  2282 "VBNET.ATG" 
+#line  2285 "VBNET.ATG" 
 		section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -460,69 +470,69 @@ out attribute);
 	}
 
 	void TypeModifier(
-#line  3011 "VBNET.ATG" 
+#line  3014 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 162: {
 			lexer.NextToken();
 
-#line  3012 "VBNET.ATG" 
+#line  3015 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location); 
 			break;
 		}
 		case 161: {
 			lexer.NextToken();
 
-#line  3013 "VBNET.ATG" 
+#line  3016 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location); 
 			break;
 		}
 		case 106: {
 			lexer.NextToken();
 
-#line  3014 "VBNET.ATG" 
+#line  3017 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location); 
 			break;
 		}
 		case 159: {
 			lexer.NextToken();
 
-#line  3015 "VBNET.ATG" 
+#line  3018 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location); 
 			break;
 		}
 		case 174: {
 			lexer.NextToken();
 
-#line  3016 "VBNET.ATG" 
+#line  3019 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location); 
 			break;
 		}
 		case 173: {
 			lexer.NextToken();
 
-#line  3017 "VBNET.ATG" 
+#line  3020 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location); 
 			break;
 		}
 		case 132: {
 			lexer.NextToken();
 
-#line  3018 "VBNET.ATG" 
+#line  3021 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location); 
 			break;
 		}
 		case 142: {
 			lexer.NextToken();
 
-#line  3019 "VBNET.ATG" 
+#line  3022 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location); 
 			break;
 		}
 		case 157: {
 			lexer.NextToken();
 
-#line  3020 "VBNET.ATG" 
+#line  3023 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location); 
 			break;
 		}
@@ -531,21 +541,21 @@ ModifierList m) {
 	}
 
 	void NonModuleDeclaration(
-#line  407 "VBNET.ATG" 
+#line  410 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 
-#line  409 "VBNET.ATG" 
+#line  412 "VBNET.ATG" 
 		TypeReference typeRef = null;
 		List<TypeReference> baseInterfaces = null;
 		
 		switch (la.kind) {
 		case 68: {
 
-#line  412 "VBNET.ATG" 
+#line  415 "VBNET.ATG" 
 			m.Check(Modifiers.Classes); 
 			lexer.NextToken();
 
-#line  415 "VBNET.ATG" 
+#line  418 "VBNET.ATG" 
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = t.Location;
 			compilationUnit.AddChild(newType);
@@ -555,42 +565,42 @@ ModifierList m, List<AttributeSection> attributes) {
 			
 			Identifier();
 
-#line  422 "VBNET.ATG" 
+#line  425 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-#line  423 "VBNET.ATG" 
+#line  426 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-#line  425 "VBNET.ATG" 
+#line  428 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			if (la.kind == 119) {
 				ClassBaseType(
-#line  426 "VBNET.ATG" 
+#line  429 "VBNET.ATG" 
 out typeRef);
 
-#line  426 "VBNET.ATG" 
+#line  429 "VBNET.ATG" 
 				newType.BaseTypes.Add(typeRef); 
 			}
 			while (la.kind == 115) {
 				TypeImplementsClause(
-#line  427 "VBNET.ATG" 
+#line  430 "VBNET.ATG" 
 out baseInterfaces);
 
-#line  427 "VBNET.ATG" 
+#line  430 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces); 
 			}
 			ClassBody(
-#line  428 "VBNET.ATG" 
+#line  431 "VBNET.ATG" 
 newType);
 			Expect(95);
 			Expect(68);
 
-#line  429 "VBNET.ATG" 
+#line  432 "VBNET.ATG" 
 			newType.EndLocation = t.EndLocation; 
 			EndOfStmt();
 
-#line  432 "VBNET.ATG" 
+#line  435 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -598,7 +608,7 @@ newType);
 		case 131: {
 			lexer.NextToken();
 
-#line  436 "VBNET.ATG" 
+#line  439 "VBNET.ATG" 
 			m.Check(Modifiers.VBModules);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			compilationUnit.AddChild(newType);
@@ -608,17 +618,17 @@ newType);
 			
 			Identifier();
 
-#line  443 "VBNET.ATG" 
+#line  446 "VBNET.ATG" 
 			newType.Name = t.val; 
 			EndOfStmt();
 
-#line  445 "VBNET.ATG" 
+#line  448 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			ModuleBody(
-#line  446 "VBNET.ATG" 
+#line  449 "VBNET.ATG" 
 newType);
 
-#line  448 "VBNET.ATG" 
+#line  451 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -626,7 +636,7 @@ newType);
 		case 182: {
 			lexer.NextToken();
 
-#line  452 "VBNET.ATG" 
+#line  455 "VBNET.ATG" 
 			m.Check(Modifiers.VBStructures);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			compilationUnit.AddChild(newType);
@@ -636,28 +646,28 @@ newType);
 			
 			Identifier();
 
-#line  459 "VBNET.ATG" 
+#line  462 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-#line  460 "VBNET.ATG" 
+#line  463 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-#line  462 "VBNET.ATG" 
+#line  465 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			while (la.kind == 115) {
 				TypeImplementsClause(
-#line  463 "VBNET.ATG" 
+#line  466 "VBNET.ATG" 
 out baseInterfaces);
 
-#line  463 "VBNET.ATG" 
+#line  466 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces);
 			}
 			StructureBody(
-#line  464 "VBNET.ATG" 
+#line  467 "VBNET.ATG" 
 newType);
 
-#line  466 "VBNET.ATG" 
+#line  469 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -665,7 +675,7 @@ newType);
 		case 97: {
 			lexer.NextToken();
 
-#line  471 "VBNET.ATG" 
+#line  474 "VBNET.ATG" 
 			m.Check(Modifiers.VBEnums);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -676,26 +686,26 @@ newType);
 			
 			Identifier();
 
-#line  479 "VBNET.ATG" 
+#line  482 "VBNET.ATG" 
 			newType.Name = t.val; 
 			if (la.kind == 49) {
 				lexer.NextToken();
 				NonArrayTypeName(
-#line  480 "VBNET.ATG" 
+#line  483 "VBNET.ATG" 
 out typeRef, false);
 
-#line  480 "VBNET.ATG" 
+#line  483 "VBNET.ATG" 
 				newType.BaseTypes.Add(typeRef); 
 			}
 			EndOfStmt();
 
-#line  482 "VBNET.ATG" 
+#line  485 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			EnumBody(
-#line  483 "VBNET.ATG" 
+#line  486 "VBNET.ATG" 
 newType);
 
-#line  485 "VBNET.ATG" 
+#line  488 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -703,7 +713,7 @@ newType);
 		case 121: {
 			lexer.NextToken();
 
-#line  490 "VBNET.ATG" 
+#line  493 "VBNET.ATG" 
 			m.Check(Modifiers.VBInterfacs);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -713,28 +723,28 @@ newType);
 			
 			Identifier();
 
-#line  497 "VBNET.ATG" 
+#line  500 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-#line  498 "VBNET.ATG" 
+#line  501 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-#line  500 "VBNET.ATG" 
+#line  503 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			while (la.kind == 119) {
 				InterfaceBase(
-#line  501 "VBNET.ATG" 
+#line  504 "VBNET.ATG" 
 out baseInterfaces);
 
-#line  501 "VBNET.ATG" 
+#line  504 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces); 
 			}
 			InterfaceBody(
-#line  502 "VBNET.ATG" 
+#line  505 "VBNET.ATG" 
 newType);
 
-#line  504 "VBNET.ATG" 
+#line  507 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -742,7 +752,7 @@ newType);
 		case 87: {
 			lexer.NextToken();
 
-#line  509 "VBNET.ATG" 
+#line  512 "VBNET.ATG" 
 			m.Check(Modifiers.VBDelegates);
 			DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes);
 			delegateDeclr.ReturnType = new TypeReference("", "System.Void");
@@ -753,63 +763,63 @@ newType);
 				lexer.NextToken();
 				Identifier();
 
-#line  516 "VBNET.ATG" 
+#line  519 "VBNET.ATG" 
 				delegateDeclr.Name = t.val; 
 				TypeParameterList(
-#line  517 "VBNET.ATG" 
+#line  520 "VBNET.ATG" 
 delegateDeclr.Templates);
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  518 "VBNET.ATG" 
+#line  521 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
 
-#line  518 "VBNET.ATG" 
+#line  521 "VBNET.ATG" 
 					delegateDeclr.Parameters = p; 
 				}
 			} else if (la.kind == 107) {
 				lexer.NextToken();
 				Identifier();
 
-#line  520 "VBNET.ATG" 
+#line  523 "VBNET.ATG" 
 				delegateDeclr.Name = t.val; 
 				TypeParameterList(
-#line  521 "VBNET.ATG" 
+#line  524 "VBNET.ATG" 
 delegateDeclr.Templates);
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  522 "VBNET.ATG" 
+#line  525 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
 
-#line  522 "VBNET.ATG" 
+#line  525 "VBNET.ATG" 
 					delegateDeclr.Parameters = p; 
 				}
 				if (la.kind == 49) {
 					lexer.NextToken();
 
-#line  523 "VBNET.ATG" 
+#line  526 "VBNET.ATG" 
 					TypeReference type; 
 					TypeName(
-#line  523 "VBNET.ATG" 
+#line  526 "VBNET.ATG" 
 out type);
 
-#line  523 "VBNET.ATG" 
+#line  526 "VBNET.ATG" 
 					delegateDeclr.ReturnType = type; 
 				}
 			} else SynErr(217);
 
-#line  525 "VBNET.ATG" 
+#line  528 "VBNET.ATG" 
 			delegateDeclr.EndLocation = t.EndLocation; 
 			EndOfStmt();
 
-#line  528 "VBNET.ATG" 
+#line  531 "VBNET.ATG" 
 			compilationUnit.AddChild(delegateDeclr);
 			
 			break;
@@ -819,31 +829,31 @@ out type);
 	}
 
 	void TypeParameterList(
-#line  352 "VBNET.ATG" 
+#line  355 "VBNET.ATG" 
 List<TemplateDefinition> templates) {
 
-#line  354 "VBNET.ATG" 
+#line  357 "VBNET.ATG" 
 		TemplateDefinition template;
 		
 		if (
-#line  357 "VBNET.ATG" 
+#line  360 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			lexer.NextToken();
 			Expect(145);
 			TypeParameter(
-#line  358 "VBNET.ATG" 
+#line  361 "VBNET.ATG" 
 out template);
 
-#line  360 "VBNET.ATG" 
+#line  363 "VBNET.ATG" 
 			if (template != null) templates.Add(template);
 			
 			while (la.kind == 12) {
 				lexer.NextToken();
 				TypeParameter(
-#line  363 "VBNET.ATG" 
+#line  366 "VBNET.ATG" 
 out template);
 
-#line  365 "VBNET.ATG" 
+#line  368 "VBNET.ATG" 
 				if (template != null) templates.Add(template);
 				
 			}
@@ -852,15 +862,15 @@ out template);
 	}
 
 	void TypeParameter(
-#line  373 "VBNET.ATG" 
+#line  376 "VBNET.ATG" 
 out TemplateDefinition template) {
 		Identifier();
 
-#line  375 "VBNET.ATG" 
+#line  378 "VBNET.ATG" 
 		template = new TemplateDefinition(t.val, null); 
 		if (la.kind == 49) {
 			TypeParameterConstraints(
-#line  376 "VBNET.ATG" 
+#line  379 "VBNET.ATG" 
 template);
 		}
 	}
@@ -924,141 +934,141 @@ template);
 	}
 
 	void TypeParameterConstraints(
-#line  380 "VBNET.ATG" 
+#line  383 "VBNET.ATG" 
 TemplateDefinition template) {
 
-#line  382 "VBNET.ATG" 
+#line  385 "VBNET.ATG" 
 		TypeReference constraint;
 		
 		Expect(49);
 		if (la.kind == 23) {
 			lexer.NextToken();
 			TypeParameterConstraint(
-#line  388 "VBNET.ATG" 
+#line  391 "VBNET.ATG" 
 out constraint);
 
-#line  388 "VBNET.ATG" 
+#line  391 "VBNET.ATG" 
 			if (constraint != null) { template.Bases.Add(constraint); } 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				TypeParameterConstraint(
-#line  391 "VBNET.ATG" 
+#line  394 "VBNET.ATG" 
 out constraint);
 
-#line  391 "VBNET.ATG" 
+#line  394 "VBNET.ATG" 
 				if (constraint != null) { template.Bases.Add(constraint); } 
 			}
 			Expect(24);
 		} else if (StartOf(5)) {
 			TypeParameterConstraint(
-#line  394 "VBNET.ATG" 
+#line  397 "VBNET.ATG" 
 out constraint);
 
-#line  394 "VBNET.ATG" 
+#line  397 "VBNET.ATG" 
 			if (constraint != null) { template.Bases.Add(constraint); } 
 		} else SynErr(220);
 	}
 
 	void TypeParameterConstraint(
-#line  398 "VBNET.ATG" 
+#line  401 "VBNET.ATG" 
 out TypeReference constraint) {
 
-#line  399 "VBNET.ATG" 
+#line  402 "VBNET.ATG" 
 		constraint = null; 
 		if (la.kind == 68) {
 			lexer.NextToken();
 
-#line  400 "VBNET.ATG" 
+#line  403 "VBNET.ATG" 
 			constraint = TypeReference.ClassConstraint; 
 		} else if (la.kind == 182) {
 			lexer.NextToken();
 
-#line  401 "VBNET.ATG" 
+#line  404 "VBNET.ATG" 
 			constraint = TypeReference.StructConstraint; 
 		} else if (la.kind == 138) {
 			lexer.NextToken();
 
-#line  402 "VBNET.ATG" 
+#line  405 "VBNET.ATG" 
 			constraint = TypeReference.NewConstraint; 
 		} else if (StartOf(6)) {
 			TypeName(
-#line  403 "VBNET.ATG" 
+#line  406 "VBNET.ATG" 
 out constraint);
 		} else SynErr(221);
 	}
 
 	void ClassBaseType(
-#line  749 "VBNET.ATG" 
+#line  752 "VBNET.ATG" 
 out TypeReference typeRef) {
 
-#line  751 "VBNET.ATG" 
+#line  754 "VBNET.ATG" 
 		typeRef = null;
 		
 		Expect(119);
 		TypeName(
-#line  754 "VBNET.ATG" 
+#line  757 "VBNET.ATG" 
 out typeRef);
 		EndOfStmt();
 	}
 
 	void TypeImplementsClause(
-#line  1549 "VBNET.ATG" 
+#line  1552 "VBNET.ATG" 
 out List<TypeReference> baseInterfaces) {
 
-#line  1551 "VBNET.ATG" 
+#line  1554 "VBNET.ATG" 
 		baseInterfaces = new List<TypeReference>();
 		TypeReference type = null;
 		
 		Expect(115);
 		TypeName(
-#line  1554 "VBNET.ATG" 
+#line  1557 "VBNET.ATG" 
 out type);
 
-#line  1556 "VBNET.ATG" 
+#line  1559 "VBNET.ATG" 
 		baseInterfaces.Add(type);
 		
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  1559 "VBNET.ATG" 
+#line  1562 "VBNET.ATG" 
 out type);
 
-#line  1560 "VBNET.ATG" 
+#line  1563 "VBNET.ATG" 
 			baseInterfaces.Add(type); 
 		}
 		EndOfStmt();
 	}
 
 	void ClassBody(
-#line  542 "VBNET.ATG" 
+#line  545 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  543 "VBNET.ATG" 
+#line  546 "VBNET.ATG" 
 		AttributeSection section; 
 		while (la.kind == 1 || la.kind == 11) {
 			EndOfStmt();
 		}
 		while (StartOf(7)) {
 
-#line  546 "VBNET.ATG" 
+#line  549 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 28) {
 				AttributeSection(
-#line  549 "VBNET.ATG" 
+#line  552 "VBNET.ATG" 
 out section);
 
-#line  549 "VBNET.ATG" 
+#line  552 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(8)) {
 				MemberModifier(
-#line  550 "VBNET.ATG" 
+#line  553 "VBNET.ATG" 
 m);
 			}
 			ClassMemberDecl(
-#line  551 "VBNET.ATG" 
+#line  554 "VBNET.ATG" 
 m, attributes);
 			while (la.kind == 1 || la.kind == 11) {
 				EndOfStmt();
@@ -1067,35 +1077,35 @@ m, attributes);
 	}
 
 	void ModuleBody(
-#line  573 "VBNET.ATG" 
+#line  576 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  574 "VBNET.ATG" 
+#line  577 "VBNET.ATG" 
 		AttributeSection section; 
 		while (la.kind == 1 || la.kind == 11) {
 			EndOfStmt();
 		}
 		while (StartOf(7)) {
 
-#line  577 "VBNET.ATG" 
+#line  580 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 28) {
 				AttributeSection(
-#line  580 "VBNET.ATG" 
+#line  583 "VBNET.ATG" 
 out section);
 
-#line  580 "VBNET.ATG" 
+#line  583 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(8)) {
 				MemberModifier(
-#line  581 "VBNET.ATG" 
+#line  584 "VBNET.ATG" 
 m);
 			}
 			ClassMemberDecl(
-#line  582 "VBNET.ATG" 
+#line  585 "VBNET.ATG" 
 m, attributes);
 			while (la.kind == 1 || la.kind == 11) {
 				EndOfStmt();
@@ -1104,41 +1114,41 @@ m, attributes);
 		Expect(95);
 		Expect(131);
 
-#line  585 "VBNET.ATG" 
+#line  588 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void StructureBody(
-#line  556 "VBNET.ATG" 
+#line  559 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  557 "VBNET.ATG" 
+#line  560 "VBNET.ATG" 
 		AttributeSection section; 
 		while (la.kind == 1 || la.kind == 11) {
 			EndOfStmt();
 		}
 		while (StartOf(7)) {
 
-#line  560 "VBNET.ATG" 
+#line  563 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 28) {
 				AttributeSection(
-#line  563 "VBNET.ATG" 
+#line  566 "VBNET.ATG" 
 out section);
 
-#line  563 "VBNET.ATG" 
+#line  566 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(8)) {
 				MemberModifier(
-#line  564 "VBNET.ATG" 
+#line  567 "VBNET.ATG" 
 m);
 			}
 			StructureMemberDecl(
-#line  565 "VBNET.ATG" 
+#line  568 "VBNET.ATG" 
 m, attributes);
 			while (la.kind == 1 || la.kind == 11) {
 				EndOfStmt();
@@ -1147,16 +1157,16 @@ m, attributes);
 		Expect(95);
 		Expect(182);
 
-#line  568 "VBNET.ATG" 
+#line  571 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void NonArrayTypeName(
-#line  2077 "VBNET.ATG" 
+#line  2080 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  2079 "VBNET.ATG" 
+#line  2082 "VBNET.ATG" 
 		string name;
 		typeref = null;
 		bool isGlobal = false;
@@ -1166,36 +1176,36 @@ out TypeReference typeref, bool canBeUnbound) {
 				lexer.NextToken();
 				Expect(16);
 
-#line  2084 "VBNET.ATG" 
+#line  2087 "VBNET.ATG" 
 				isGlobal = true; 
 			}
 			QualIdentAndTypeArguments(
-#line  2085 "VBNET.ATG" 
+#line  2088 "VBNET.ATG" 
 out typeref, canBeUnbound);
 
-#line  2086 "VBNET.ATG" 
+#line  2089 "VBNET.ATG" 
 			typeref.IsGlobal = isGlobal; 
 			while (la.kind == 16) {
 				lexer.NextToken();
 
-#line  2087 "VBNET.ATG" 
+#line  2090 "VBNET.ATG" 
 				TypeReference nestedTypeRef; 
 				QualIdentAndTypeArguments(
-#line  2088 "VBNET.ATG" 
+#line  2091 "VBNET.ATG" 
 out nestedTypeRef, canBeUnbound);
 
-#line  2089 "VBNET.ATG" 
+#line  2092 "VBNET.ATG" 
 				typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes); 
 			}
 		} else if (la.kind == 144) {
 			lexer.NextToken();
 
-#line  2092 "VBNET.ATG" 
+#line  2095 "VBNET.ATG" 
 			typeref = new TypeReference("System.Object"); 
 			if (la.kind == 21) {
 				lexer.NextToken();
 
-#line  2096 "VBNET.ATG" 
+#line  2099 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments);
@@ -1203,15 +1213,15 @@ out nestedTypeRef, canBeUnbound);
 			}
 		} else if (StartOf(10)) {
 			PrimitiveTypeName(
-#line  2102 "VBNET.ATG" 
+#line  2105 "VBNET.ATG" 
 out name);
 
-#line  2102 "VBNET.ATG" 
+#line  2105 "VBNET.ATG" 
 			typeref = new TypeReference(name); 
 			if (la.kind == 21) {
 				lexer.NextToken();
 
-#line  2106 "VBNET.ATG" 
+#line  2109 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments);
@@ -1221,20 +1231,20 @@ out name);
 	}
 
 	void EnumBody(
-#line  589 "VBNET.ATG" 
+#line  592 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  590 "VBNET.ATG" 
+#line  593 "VBNET.ATG" 
 		FieldDeclaration f; 
 		while (la.kind == 1 || la.kind == 11) {
 			EndOfStmt();
 		}
 		while (StartOf(11)) {
 			EnumMemberDecl(
-#line  593 "VBNET.ATG" 
+#line  596 "VBNET.ATG" 
 out f);
 
-#line  595 "VBNET.ATG" 
+#line  598 "VBNET.ATG" 
 			SetParent(f.Fields, f);
 			compilationUnit.AddChild(f);
 			
@@ -1245,40 +1255,40 @@ out f);
 		Expect(95);
 		Expect(97);
 
-#line  600 "VBNET.ATG" 
+#line  603 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void InterfaceBase(
-#line  1534 "VBNET.ATG" 
+#line  1537 "VBNET.ATG" 
 out List<TypeReference> bases) {
 
-#line  1536 "VBNET.ATG" 
+#line  1539 "VBNET.ATG" 
 		TypeReference type;
 		bases = new List<TypeReference>();
 		
 		Expect(119);
 		TypeName(
-#line  1540 "VBNET.ATG" 
+#line  1543 "VBNET.ATG" 
 out type);
 
-#line  1540 "VBNET.ATG" 
+#line  1543 "VBNET.ATG" 
 		bases.Add(type); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  1543 "VBNET.ATG" 
+#line  1546 "VBNET.ATG" 
 out type);
 
-#line  1543 "VBNET.ATG" 
+#line  1546 "VBNET.ATG" 
 			bases.Add(type); 
 		}
 		EndOfStmt();
 	}
 
 	void InterfaceBody(
-#line  604 "VBNET.ATG" 
+#line  607 "VBNET.ATG" 
 TypeDeclaration newType) {
 		while (la.kind == 1 || la.kind == 11) {
 			EndOfStmt();
@@ -1292,168 +1302,168 @@ TypeDeclaration newType) {
 		Expect(95);
 		Expect(121);
 
-#line  610 "VBNET.ATG" 
+#line  613 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void FormalParameterList(
-#line  2292 "VBNET.ATG" 
+#line  2295 "VBNET.ATG" 
 List<ParameterDeclarationExpression> parameter) {
 
-#line  2293 "VBNET.ATG" 
+#line  2296 "VBNET.ATG" 
 		ParameterDeclarationExpression p; 
 		FormalParameter(
-#line  2295 "VBNET.ATG" 
+#line  2298 "VBNET.ATG" 
 out p);
 
-#line  2295 "VBNET.ATG" 
+#line  2298 "VBNET.ATG" 
 		if (p != null) parameter.Add(p); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			FormalParameter(
-#line  2297 "VBNET.ATG" 
+#line  2300 "VBNET.ATG" 
 out p);
 
-#line  2297 "VBNET.ATG" 
+#line  2300 "VBNET.ATG" 
 			if (p != null) parameter.Add(p); 
 		}
 	}
 
 	void MemberModifier(
-#line  3023 "VBNET.ATG" 
+#line  3026 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 132: {
 			lexer.NextToken();
 
-#line  3024 "VBNET.ATG" 
+#line  3027 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 86: {
 			lexer.NextToken();
 
-#line  3025 "VBNET.ATG" 
+#line  3028 "VBNET.ATG" 
 			m.Add(Modifiers.Default, t.Location);
 			break;
 		}
 		case 106: {
 			lexer.NextToken();
 
-#line  3026 "VBNET.ATG" 
+#line  3029 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location);
 			break;
 		}
 		case 173: {
 			lexer.NextToken();
 
-#line  3027 "VBNET.ATG" 
+#line  3030 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location);
 			break;
 		}
 		case 155: {
 			lexer.NextToken();
 
-#line  3028 "VBNET.ATG" 
+#line  3031 "VBNET.ATG" 
 			m.Add(Modifiers.Override, t.Location);
 			break;
 		}
 		case 133: {
 			lexer.NextToken();
 
-#line  3029 "VBNET.ATG" 
+#line  3032 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 159: {
 			lexer.NextToken();
 
-#line  3030 "VBNET.ATG" 
+#line  3033 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location);
 			break;
 		}
 		case 161: {
 			lexer.NextToken();
 
-#line  3031 "VBNET.ATG" 
+#line  3034 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location);
 			break;
 		}
 		case 162: {
 			lexer.NextToken();
 
-#line  3032 "VBNET.ATG" 
+#line  3035 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location);
 			break;
 		}
 		case 142: {
 			lexer.NextToken();
 
-#line  3033 "VBNET.ATG" 
+#line  3036 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 143: {
 			lexer.NextToken();
 
-#line  3034 "VBNET.ATG" 
+#line  3037 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 174: {
 			lexer.NextToken();
 
-#line  3035 "VBNET.ATG" 
+#line  3038 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location);
 			break;
 		}
 		case 154: {
 			lexer.NextToken();
 
-#line  3036 "VBNET.ATG" 
+#line  3039 "VBNET.ATG" 
 			m.Add(Modifiers.Virtual, t.Location);
 			break;
 		}
 		case 153: {
 			lexer.NextToken();
 
-#line  3037 "VBNET.ATG" 
+#line  3040 "VBNET.ATG" 
 			m.Add(Modifiers.Overloads, t.Location);
 			break;
 		}
 		case 164: {
 			lexer.NextToken();
 
-#line  3038 "VBNET.ATG" 
+#line  3041 "VBNET.ATG" 
 			m.Add(Modifiers.ReadOnly, t.Location);
 			break;
 		}
 		case 206: {
 			lexer.NextToken();
 
-#line  3039 "VBNET.ATG" 
+#line  3042 "VBNET.ATG" 
 			m.Add(Modifiers.WriteOnly, t.Location);
 			break;
 		}
 		case 205: {
 			lexer.NextToken();
 
-#line  3040 "VBNET.ATG" 
+#line  3043 "VBNET.ATG" 
 			m.Add(Modifiers.WithEvents, t.Location);
 			break;
 		}
 		case 88: {
 			lexer.NextToken();
 
-#line  3041 "VBNET.ATG" 
+#line  3044 "VBNET.ATG" 
 			m.Add(Modifiers.Dim, t.Location);
 			break;
 		}
 		case 157: {
 			lexer.NextToken();
 
-#line  3042 "VBNET.ATG" 
+#line  3045 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location);
 			break;
 		}
@@ -1462,18 +1472,18 @@ ModifierList m) {
 	}
 
 	void ClassMemberDecl(
-#line  745 "VBNET.ATG" 
+#line  748 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 		StructureMemberDecl(
-#line  746 "VBNET.ATG" 
+#line  749 "VBNET.ATG" 
 m, attributes);
 	}
 
 	void StructureMemberDecl(
-#line  759 "VBNET.ATG" 
+#line  762 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 
-#line  761 "VBNET.ATG" 
+#line  764 "VBNET.ATG" 
 		TypeReference type = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		Statement stmt = null;
@@ -1483,37 +1493,37 @@ ModifierList m, List<AttributeSection> attributes) {
 		switch (la.kind) {
 		case 68: case 87: case 97: case 121: case 131: case 182: {
 			NonModuleDeclaration(
-#line  768 "VBNET.ATG" 
+#line  771 "VBNET.ATG" 
 m, attributes);
 			break;
 		}
 		case 183: {
 			lexer.NextToken();
 
-#line  772 "VBNET.ATG" 
+#line  775 "VBNET.ATG" 
 			Location startPos = t.Location;
 			
 			if (StartOf(13)) {
 
-#line  776 "VBNET.ATG" 
+#line  779 "VBNET.ATG" 
 				string name = String.Empty;
 				MethodDeclaration methodDeclaration; List<string> handlesClause = null;
 				List<InterfaceImplementation> implementsClause = null;
 				
 				Identifier();
 
-#line  782 "VBNET.ATG" 
+#line  785 "VBNET.ATG" 
 				name = t.val;
 				m.Check(Modifiers.VBMethods);
 				
 				TypeParameterList(
-#line  785 "VBNET.ATG" 
+#line  788 "VBNET.ATG" 
 templates);
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  786 "VBNET.ATG" 
+#line  789 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
@@ -1521,23 +1531,23 @@ p);
 				if (la.kind == 113 || la.kind == 115) {
 					if (la.kind == 115) {
 						ImplementsClause(
-#line  789 "VBNET.ATG" 
+#line  792 "VBNET.ATG" 
 out implementsClause);
 					} else {
 						HandlesClause(
-#line  791 "VBNET.ATG" 
+#line  794 "VBNET.ATG" 
 out handlesClause);
 					}
 				}
 
-#line  794 "VBNET.ATG" 
+#line  797 "VBNET.ATG" 
 				Location endLocation = t.EndLocation; 
 				if (
-#line  797 "VBNET.ATG" 
+#line  800 "VBNET.ATG" 
 IsMustOverride(m)) {
 					EndOfStmt();
 
-#line  800 "VBNET.ATG" 
+#line  803 "VBNET.ATG" 
 					methodDeclaration = new MethodDeclaration {
 					Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
 					StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
@@ -1551,7 +1561,7 @@ IsMustOverride(m)) {
 				} else if (la.kind == 1) {
 					lexer.NextToken();
 
-#line  813 "VBNET.ATG" 
+#line  816 "VBNET.ATG" 
 					methodDeclaration = new MethodDeclaration {
 					Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
 					StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
@@ -1563,25 +1573,25 @@ IsMustOverride(m)) {
 					compilationUnit.AddChild(methodDeclaration);
 					
 
-#line  824 "VBNET.ATG" 
+#line  827 "VBNET.ATG" 
 					if (ParseMethodBodies) { 
 					Block(
-#line  825 "VBNET.ATG" 
+#line  828 "VBNET.ATG" 
 out stmt);
 					Expect(95);
 					Expect(183);
 
-#line  827 "VBNET.ATG" 
+#line  830 "VBNET.ATG" 
 					} else {
 					// don't parse method body
 					lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
 					  }
 					
 
-#line  833 "VBNET.ATG" 
+#line  836 "VBNET.ATG" 
 					methodDeclaration.Body  = (BlockStatement)stmt; 
 
-#line  834 "VBNET.ATG" 
+#line  837 "VBNET.ATG" 
 					methodDeclaration.Body.EndLocation = t.EndLocation; 
 					EndOfStmt();
 				} else SynErr(224);
@@ -1591,39 +1601,39 @@ out stmt);
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  838 "VBNET.ATG" 
+#line  841 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
 				}
 
-#line  839 "VBNET.ATG" 
+#line  842 "VBNET.ATG" 
 				m.Check(Modifiers.Constructors); 
 
-#line  840 "VBNET.ATG" 
+#line  843 "VBNET.ATG" 
 				Location constructorEndLocation = t.EndLocation; 
 				Expect(1);
 
-#line  843 "VBNET.ATG" 
+#line  846 "VBNET.ATG" 
 				if (ParseMethodBodies) { 
 				Block(
-#line  844 "VBNET.ATG" 
+#line  847 "VBNET.ATG" 
 out stmt);
 				Expect(95);
 				Expect(183);
 
-#line  846 "VBNET.ATG" 
+#line  849 "VBNET.ATG" 
 				} else {
 				// don't parse method body
 				lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
 				  }
 				
 
-#line  852 "VBNET.ATG" 
+#line  855 "VBNET.ATG" 
 				Location endLocation = t.EndLocation; 
 				EndOfStmt();
 
-#line  855 "VBNET.ATG" 
+#line  858 "VBNET.ATG" 
 				ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes); 
 				cd.StartLocation = m.GetDeclarationLocation(startPos);
 				cd.EndLocation   = constructorEndLocation;
@@ -1637,7 +1647,7 @@ out stmt);
 		case 107: {
 			lexer.NextToken();
 
-#line  867 "VBNET.ATG" 
+#line  870 "VBNET.ATG" 
 			m.Check(Modifiers.VBMethods);
 			string name = String.Empty;
 			Location startPos = t.Location;
@@ -1647,16 +1657,16 @@ out stmt);
 			
 			Identifier();
 
-#line  874 "VBNET.ATG" 
+#line  877 "VBNET.ATG" 
 			name = t.val; 
 			TypeParameterList(
-#line  875 "VBNET.ATG" 
+#line  878 "VBNET.ATG" 
 templates);
 			if (la.kind == 25) {
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  876 "VBNET.ATG" 
+#line  879 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
@@ -1665,15 +1675,15 @@ p);
 				lexer.NextToken();
 				while (la.kind == 28) {
 					AttributeSection(
-#line  877 "VBNET.ATG" 
+#line  880 "VBNET.ATG" 
 out returnTypeAttributeSection);
 				}
 				TypeName(
-#line  877 "VBNET.ATG" 
+#line  880 "VBNET.ATG" 
 out type);
 			}
 
-#line  879 "VBNET.ATG" 
+#line  882 "VBNET.ATG" 
 			if(type == null) {
 			type = new TypeReference("System.Object");
 			}
@@ -1681,20 +1691,20 @@ out type);
 			if (la.kind == 113 || la.kind == 115) {
 				if (la.kind == 115) {
 					ImplementsClause(
-#line  885 "VBNET.ATG" 
+#line  888 "VBNET.ATG" 
 out implementsClause);
 				} else {
 					HandlesClause(
-#line  887 "VBNET.ATG" 
+#line  890 "VBNET.ATG" 
 out handlesClause);
 				}
 			}
 			if (
-#line  892 "VBNET.ATG" 
+#line  895 "VBNET.ATG" 
 IsMustOverride(m)) {
 				EndOfStmt();
 
-#line  895 "VBNET.ATG" 
+#line  898 "VBNET.ATG" 
 				methodDeclaration = new MethodDeclaration {
 				Name = name, Modifier = m.Modifier, TypeReference = type,
 				Parameters = p, Attributes = attributes,
@@ -1713,7 +1723,7 @@ IsMustOverride(m)) {
 			} else if (la.kind == 1) {
 				lexer.NextToken();
 
-#line  913 "VBNET.ATG" 
+#line  916 "VBNET.ATG" 
 				methodDeclaration = new MethodDeclaration {
 				Name = name, Modifier = m.Modifier, TypeReference = type,
 				Parameters = p, Attributes = attributes,
@@ -1732,12 +1742,12 @@ IsMustOverride(m)) {
 				
 				if (ParseMethodBodies) { 
 				Block(
-#line  930 "VBNET.ATG" 
+#line  933 "VBNET.ATG" 
 out stmt);
 				Expect(95);
 				Expect(107);
 
-#line  932 "VBNET.ATG" 
+#line  935 "VBNET.ATG" 
 				} else {
 				// don't parse method body
 				lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
@@ -1753,7 +1763,7 @@ out stmt);
 		case 85: {
 			lexer.NextToken();
 
-#line  946 "VBNET.ATG" 
+#line  949 "VBNET.ATG" 
 			m.Check(Modifiers.VBExternalMethods);
 			Location startPos = t.Location;
 			CharsetModifier charsetModifer = CharsetModifier.None;
@@ -1763,39 +1773,39 @@ out stmt);
 			
 			if (StartOf(14)) {
 				Charset(
-#line  953 "VBNET.ATG" 
+#line  956 "VBNET.ATG" 
 out charsetModifer);
 			}
 			if (la.kind == 183) {
 				lexer.NextToken();
 				Identifier();
 
-#line  956 "VBNET.ATG" 
+#line  959 "VBNET.ATG" 
 				name = t.val; 
 				Expect(125);
 				Expect(3);
 
-#line  957 "VBNET.ATG" 
+#line  960 "VBNET.ATG" 
 				library = t.literalValue as string; 
 				if (la.kind == 45) {
 					lexer.NextToken();
 					Expect(3);
 
-#line  958 "VBNET.ATG" 
+#line  961 "VBNET.ATG" 
 					alias = t.literalValue as string; 
 				}
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  959 "VBNET.ATG" 
+#line  962 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
 				}
 				EndOfStmt();
 
-#line  962 "VBNET.ATG" 
+#line  965 "VBNET.ATG" 
 				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
 				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				declareDeclaration.EndLocation   = t.EndLocation;
@@ -1805,25 +1815,25 @@ p);
 				lexer.NextToken();
 				Identifier();
 
-#line  969 "VBNET.ATG" 
+#line  972 "VBNET.ATG" 
 				name = t.val; 
 				Expect(125);
 				Expect(3);
 
-#line  970 "VBNET.ATG" 
+#line  973 "VBNET.ATG" 
 				library = t.literalValue as string; 
 				if (la.kind == 45) {
 					lexer.NextToken();
 					Expect(3);
 
-#line  971 "VBNET.ATG" 
+#line  974 "VBNET.ATG" 
 					alias = t.literalValue as string; 
 				}
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  972 "VBNET.ATG" 
+#line  975 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
@@ -1831,12 +1841,12 @@ p);
 				if (la.kind == 49) {
 					lexer.NextToken();
 					TypeName(
-#line  973 "VBNET.ATG" 
+#line  976 "VBNET.ATG" 
 out type);
 				}
 				EndOfStmt();
 
-#line  976 "VBNET.ATG" 
+#line  979 "VBNET.ATG" 
 				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
 				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				declareDeclaration.EndLocation   = t.EndLocation;
@@ -1848,7 +1858,7 @@ out type);
 		case 100: {
 			lexer.NextToken();
 
-#line  986 "VBNET.ATG" 
+#line  989 "VBNET.ATG" 
 			m.Check(Modifiers.VBEvents);
 			Location startPos = t.Location;
 			EventDeclaration eventDeclaration;
@@ -1857,19 +1867,19 @@ out type);
 			
 			Identifier();
 
-#line  992 "VBNET.ATG" 
+#line  995 "VBNET.ATG" 
 			name= t.val; 
 			if (la.kind == 49) {
 				lexer.NextToken();
 				TypeName(
-#line  994 "VBNET.ATG" 
+#line  997 "VBNET.ATG" 
 out type);
 			} else if (StartOf(15)) {
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  996 "VBNET.ATG" 
+#line  999 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
@@ -1877,11 +1887,11 @@ p);
 			} else SynErr(228);
 			if (la.kind == 115) {
 				ImplementsClause(
-#line  998 "VBNET.ATG" 
+#line  1001 "VBNET.ATG" 
 out implementsClause);
 			}
 
-#line  1000 "VBNET.ATG" 
+#line  1003 "VBNET.ATG" 
 			eventDeclaration = new EventDeclaration {
 			Name = name, TypeReference = type, Modifier = m.Modifier, 
 			Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
@@ -1893,32 +1903,32 @@ out implementsClause);
 			EndOfStmt();
 			break;
 		}
-		case 2: case 48: case 50: case 51: case 52: case 71: case 102: case 146: case 158: case 185: case 195: case 196: {
+		case 2: case 48: case 50: case 51: case 52: case 71: case 102: case 118: case 146: case 158: case 185: case 195: case 196: {
 
-#line  1010 "VBNET.ATG" 
+#line  1013 "VBNET.ATG" 
 			Location startPos = t.Location; 
 
-#line  1012 "VBNET.ATG" 
+#line  1015 "VBNET.ATG" 
 			m.Check(Modifiers.Fields);
 			FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);
 			fd.StartLocation = m.GetDeclarationLocation(startPos); 
 			
 			IdentifierForFieldDeclaration();
 
-#line  1016 "VBNET.ATG" 
+#line  1019 "VBNET.ATG" 
 			string name = t.val; 
 			VariableDeclaratorPartAfterIdentifier(
-#line  1017 "VBNET.ATG" 
+#line  1020 "VBNET.ATG" 
 variableDeclarators, name);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				VariableDeclarator(
-#line  1018 "VBNET.ATG" 
+#line  1021 "VBNET.ATG" 
 variableDeclarators);
 			}
 			EndOfStmt();
 
-#line  1021 "VBNET.ATG" 
+#line  1024 "VBNET.ATG" 
 			fd.EndLocation = t.EndLocation;
 			fd.Fields = variableDeclarators;
 			SetParent(variableDeclarators, fd);
@@ -1928,35 +1938,35 @@ variableDeclarators);
 		}
 		case 72: {
 
-#line  1027 "VBNET.ATG" 
+#line  1030 "VBNET.ATG" 
 			m.Check(Modifiers.Fields); 
 			lexer.NextToken();
 
-#line  1028 "VBNET.ATG" 
+#line  1031 "VBNET.ATG" 
 			m.Add(Modifiers.Const, t.Location);  
 
-#line  1030 "VBNET.ATG" 
+#line  1033 "VBNET.ATG" 
 			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
 			fd.StartLocation = m.GetDeclarationLocation(t.Location);
 			List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();
 			
 			ConstantDeclarator(
-#line  1034 "VBNET.ATG" 
+#line  1037 "VBNET.ATG" 
 constantDeclarators);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				ConstantDeclarator(
-#line  1035 "VBNET.ATG" 
+#line  1038 "VBNET.ATG" 
 constantDeclarators);
 			}
 
-#line  1037 "VBNET.ATG" 
+#line  1040 "VBNET.ATG" 
 			fd.Fields = constantDeclarators;
 			fd.EndLocation = t.Location;
 			
 			EndOfStmt();
 
-#line  1042 "VBNET.ATG" 
+#line  1045 "VBNET.ATG" 
 			fd.EndLocation = t.EndLocation;
 			compilationUnit.AddChild(fd);
 			
@@ -1965,20 +1975,20 @@ constantDeclarators);
 		case 160: {
 			lexer.NextToken();
 
-#line  1048 "VBNET.ATG" 
+#line  1051 "VBNET.ATG" 
 			m.Check(Modifiers.VBProperties);
 			Location startPos = t.Location;
 			List<InterfaceImplementation> implementsClause = null;
 			
 			Identifier();
 
-#line  1052 "VBNET.ATG" 
+#line  1055 "VBNET.ATG" 
 			string propertyName = t.val; 
 			if (la.kind == 25) {
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1053 "VBNET.ATG" 
+#line  1056 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
@@ -1986,26 +1996,26 @@ p);
 			if (la.kind == 49) {
 				lexer.NextToken();
 				TypeName(
-#line  1054 "VBNET.ATG" 
+#line  1057 "VBNET.ATG" 
 out type);
 			}
 
-#line  1056 "VBNET.ATG" 
+#line  1059 "VBNET.ATG" 
 			if(type == null) {
 			type = new TypeReference("System.Object");
 			}
 			
 			if (la.kind == 115) {
 				ImplementsClause(
-#line  1060 "VBNET.ATG" 
+#line  1063 "VBNET.ATG" 
 out implementsClause);
 			}
 			EndOfStmt();
 			if (
-#line  1064 "VBNET.ATG" 
+#line  1067 "VBNET.ATG" 
 IsMustOverride(m)) {
 
-#line  1066 "VBNET.ATG" 
+#line  1069 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -2016,7 +2026,7 @@ IsMustOverride(m)) {
 				
 			} else if (StartOf(16)) {
 
-#line  1076 "VBNET.ATG" 
+#line  1079 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -2028,13 +2038,13 @@ IsMustOverride(m)) {
 				PropertySetRegion setRegion;
 				
 				AccessorDecls(
-#line  1086 "VBNET.ATG" 
+#line  1089 "VBNET.ATG" 
 out getRegion, out setRegion);
 				Expect(95);
 				Expect(160);
 				EndOfStmt();
 
-#line  1090 "VBNET.ATG" 
+#line  1093 "VBNET.ATG" 
 				pDecl.GetRegion = getRegion;
 				pDecl.SetRegion = setRegion;
 				pDecl.BodyEnd = t.EndLocation;
@@ -2046,11 +2056,11 @@ out getRegion, out setRegion);
 		case 82: {
 			lexer.NextToken();
 
-#line  1097 "VBNET.ATG" 
+#line  1100 "VBNET.ATG" 
 			Location startPos = t.Location; 
 			Expect(100);
 
-#line  1099 "VBNET.ATG" 
+#line  1102 "VBNET.ATG" 
 			m.Check(Modifiers.VBCustomEvents);
 			EventAddRemoveRegion eventAccessorDeclaration;
 			EventAddRegion addHandlerAccessorDeclaration = null;
@@ -2060,24 +2070,24 @@ out getRegion, out setRegion);
 			
 			Identifier();
 
-#line  1106 "VBNET.ATG" 
+#line  1109 "VBNET.ATG" 
 			string customEventName = t.val; 
 			Expect(49);
 			TypeName(
-#line  1107 "VBNET.ATG" 
+#line  1110 "VBNET.ATG" 
 out type);
 			if (la.kind == 115) {
 				ImplementsClause(
-#line  1108 "VBNET.ATG" 
+#line  1111 "VBNET.ATG" 
 out implementsClause);
 			}
 			EndOfStmt();
 			while (StartOf(17)) {
 				EventAccessorDeclaration(
-#line  1111 "VBNET.ATG" 
+#line  1114 "VBNET.ATG" 
 out eventAccessorDeclaration);
 
-#line  1113 "VBNET.ATG" 
+#line  1116 "VBNET.ATG" 
 				if(eventAccessorDeclaration is EventAddRegion)
 				{
 					addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
@@ -2096,7 +2106,7 @@ out eventAccessorDeclaration);
 			Expect(100);
 			EndOfStmt();
 
-#line  1129 "VBNET.ATG" 
+#line  1132 "VBNET.ATG" 
 			if(addHandlerAccessorDeclaration == null)
 			{
 				Error("Need to provide AddHandler accessor.");
@@ -2127,24 +2137,24 @@ out eventAccessorDeclaration);
 		}
 		case 137: case 148: case 203: {
 
-#line  1155 "VBNET.ATG" 
+#line  1158 "VBNET.ATG" 
 			ConversionType opConversionType = ConversionType.None; 
 			if (la.kind == 137 || la.kind == 203) {
 				if (la.kind == 203) {
 					lexer.NextToken();
 
-#line  1156 "VBNET.ATG" 
+#line  1159 "VBNET.ATG" 
 					opConversionType = ConversionType.Implicit; 
 				} else {
 					lexer.NextToken();
 
-#line  1157 "VBNET.ATG" 
+#line  1160 "VBNET.ATG" 
 					opConversionType = ConversionType.Explicit;
 				}
 			}
 			Expect(148);
 
-#line  1160 "VBNET.ATG" 
+#line  1163 "VBNET.ATG" 
 			m.Check(Modifiers.VBOperators);
 			Location startPos = t.Location;
 			TypeReference returnType = NullTypeReference.Instance;
@@ -2156,7 +2166,7 @@ out eventAccessorDeclaration);
 			List<AttributeSection> returnTypeAttributes = new List<AttributeSection>();
 			
 			OverloadableOperator(
-#line  1170 "VBNET.ATG" 
+#line  1173 "VBNET.ATG" 
 out operatorType);
 			Expect(25);
 			if (la.kind == 56) {
@@ -2164,16 +2174,16 @@ out operatorType);
 			}
 			Identifier();
 
-#line  1171 "VBNET.ATG" 
+#line  1174 "VBNET.ATG" 
 			operandName = t.val; 
 			if (la.kind == 49) {
 				lexer.NextToken();
 				TypeName(
-#line  1172 "VBNET.ATG" 
+#line  1175 "VBNET.ATG" 
 out operandType);
 			}
 
-#line  1173 "VBNET.ATG" 
+#line  1176 "VBNET.ATG" 
 			parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In)); 
 			while (la.kind == 12) {
 				lexer.NextToken();
@@ -2182,48 +2192,48 @@ out operandType);
 				}
 				Identifier();
 
-#line  1177 "VBNET.ATG" 
+#line  1180 "VBNET.ATG" 
 				operandName = t.val; 
 				if (la.kind == 49) {
 					lexer.NextToken();
 					TypeName(
-#line  1178 "VBNET.ATG" 
+#line  1181 "VBNET.ATG" 
 out operandType);
 				}
 
-#line  1179 "VBNET.ATG" 
+#line  1182 "VBNET.ATG" 
 				parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In)); 
 			}
 			Expect(26);
 
-#line  1182 "VBNET.ATG" 
+#line  1185 "VBNET.ATG" 
 			Location endPos = t.EndLocation; 
 			if (la.kind == 49) {
 				lexer.NextToken();
 				while (la.kind == 28) {
 					AttributeSection(
-#line  1183 "VBNET.ATG" 
+#line  1186 "VBNET.ATG" 
 out section);
 
-#line  1183 "VBNET.ATG" 
+#line  1186 "VBNET.ATG" 
 					returnTypeAttributes.Add(section); 
 				}
 				TypeName(
-#line  1183 "VBNET.ATG" 
+#line  1186 "VBNET.ATG" 
 out returnType);
 
-#line  1183 "VBNET.ATG" 
+#line  1186 "VBNET.ATG" 
 				endPos = t.EndLocation; 
 			}
 			Expect(1);
 			Block(
-#line  1185 "VBNET.ATG" 
+#line  1188 "VBNET.ATG" 
 out stmt);
 			Expect(95);
 			Expect(148);
 			EndOfStmt();
 
-#line  1187 "VBNET.ATG" 
+#line  1190 "VBNET.ATG" 
 			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
 			Modifier = m.Modifier,
 			Attributes = attributes,
@@ -2247,25 +2257,25 @@ out stmt);
 	}
 
 	void EnumMemberDecl(
-#line  727 "VBNET.ATG" 
+#line  730 "VBNET.ATG" 
 out FieldDeclaration f) {
 
-#line  729 "VBNET.ATG" 
+#line  732 "VBNET.ATG" 
 		Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
 		AttributeSection section = null;
 		VariableDeclaration varDecl = null;
 		
 		while (la.kind == 28) {
 			AttributeSection(
-#line  733 "VBNET.ATG" 
+#line  736 "VBNET.ATG" 
 out section);
 
-#line  733 "VBNET.ATG" 
+#line  736 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		Identifier();
 
-#line  736 "VBNET.ATG" 
+#line  739 "VBNET.ATG" 
 		f = new FieldDeclaration(attributes);
 		varDecl = new VariableDeclaration(t.val);
 		f.Fields.Add(varDecl);
@@ -2274,10 +2284,10 @@ out section);
 		if (la.kind == 10) {
 			lexer.NextToken();
 			Expr(
-#line  741 "VBNET.ATG" 
+#line  744 "VBNET.ATG" 
 out expr);
 
-#line  741 "VBNET.ATG" 
+#line  744 "VBNET.ATG" 
 			varDecl.Initializer = expr; 
 		}
 		EndOfStmt();
@@ -2285,7 +2295,7 @@ out expr);
 
 	void InterfaceMemberDecl() {
 
-#line  618 "VBNET.ATG" 
+#line  621 "VBNET.ATG" 
 		TypeReference type =null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		List<TemplateDefinition> templates = new List<TemplateDefinition>();
@@ -2297,33 +2307,33 @@ out expr);
 		if (StartOf(18)) {
 			while (la.kind == 28) {
 				AttributeSection(
-#line  626 "VBNET.ATG" 
+#line  629 "VBNET.ATG" 
 out section);
 
-#line  626 "VBNET.ATG" 
+#line  629 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			while (StartOf(8)) {
 				MemberModifier(
-#line  629 "VBNET.ATG" 
+#line  632 "VBNET.ATG" 
 mod);
 			}
 			if (la.kind == 100) {
 				lexer.NextToken();
 
-#line  633 "VBNET.ATG" 
+#line  636 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceEvents);
 				Location startLocation = t.Location;
 				
 				Identifier();
 
-#line  636 "VBNET.ATG" 
+#line  639 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  637 "VBNET.ATG" 
+#line  640 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
@@ -2331,12 +2341,12 @@ p);
 				if (la.kind == 49) {
 					lexer.NextToken();
 					TypeName(
-#line  638 "VBNET.ATG" 
+#line  641 "VBNET.ATG" 
 out type);
 				}
 				EndOfStmt();
 
-#line  641 "VBNET.ATG" 
+#line  644 "VBNET.ATG" 
 				EventDeclaration ed = new EventDeclaration {
 				Name = name, TypeReference = type, Modifier = mod.Modifier,
 				Parameters = p, Attributes = attributes,
@@ -2347,29 +2357,29 @@ out type);
 			} else if (la.kind == 183) {
 				lexer.NextToken();
 
-#line  651 "VBNET.ATG" 
+#line  654 "VBNET.ATG" 
 				Location startLocation =  t.Location;
 				mod.Check(Modifiers.VBInterfaceMethods);
 				
 				Identifier();
 
-#line  654 "VBNET.ATG" 
+#line  657 "VBNET.ATG" 
 				name = t.val; 
 				TypeParameterList(
-#line  655 "VBNET.ATG" 
+#line  658 "VBNET.ATG" 
 templates);
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  656 "VBNET.ATG" 
+#line  659 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
 				}
 				EndOfStmt();
 
-#line  659 "VBNET.ATG" 
+#line  662 "VBNET.ATG" 
 				MethodDeclaration md = new MethodDeclaration {
 				Name = name, 
 				Modifier = mod.Modifier, 
@@ -2385,22 +2395,22 @@ p);
 			} else if (la.kind == 107) {
 				lexer.NextToken();
 
-#line  674 "VBNET.ATG" 
+#line  677 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceMethods);
 				Location startLocation = t.Location;
 				
 				Identifier();
 
-#line  677 "VBNET.ATG" 
+#line  680 "VBNET.ATG" 
 				name = t.val; 
 				TypeParameterList(
-#line  678 "VBNET.ATG" 
+#line  681 "VBNET.ATG" 
 templates);
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  679 "VBNET.ATG" 
+#line  682 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
@@ -2409,15 +2419,15 @@ p);
 					lexer.NextToken();
 					while (la.kind == 28) {
 						AttributeSection(
-#line  680 "VBNET.ATG" 
+#line  683 "VBNET.ATG" 
 out returnTypeAttributeSection);
 					}
 					TypeName(
-#line  680 "VBNET.ATG" 
+#line  683 "VBNET.ATG" 
 out type);
 				}
 
-#line  682 "VBNET.ATG" 
+#line  685 "VBNET.ATG" 
 				if(type == null) {
 				type = new TypeReference("System.Object");
 				}
@@ -2438,19 +2448,19 @@ out type);
 			} else if (la.kind == 160) {
 				lexer.NextToken();
 
-#line  702 "VBNET.ATG" 
+#line  705 "VBNET.ATG" 
 				Location startLocation = t.Location;
 				mod.Check(Modifiers.VBInterfaceProperties);
 				
 				Identifier();
 
-#line  705 "VBNET.ATG" 
+#line  708 "VBNET.ATG" 
 				name = t.val;  
 				if (la.kind == 25) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  706 "VBNET.ATG" 
+#line  709 "VBNET.ATG" 
 p);
 					}
 					Expect(26);
@@ -2458,18 +2468,18 @@ p);
 				if (la.kind == 49) {
 					lexer.NextToken();
 					TypeName(
-#line  707 "VBNET.ATG" 
+#line  710 "VBNET.ATG" 
 out type);
 				}
 
-#line  709 "VBNET.ATG" 
+#line  712 "VBNET.ATG" 
 				if(type == null) {
 				type = new TypeReference("System.Object");
 				}
 				
 				EndOfStmt();
 
-#line  715 "VBNET.ATG" 
+#line  718 "VBNET.ATG" 
 				PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes);
 				pd.Parameters = p;
 				pd.EndLocation = t.EndLocation;
@@ -2479,98 +2489,98 @@ out type);
 			} else SynErr(231);
 		} else if (StartOf(19)) {
 			NonModuleDeclaration(
-#line  723 "VBNET.ATG" 
+#line  726 "VBNET.ATG" 
 mod, attributes);
 		} else SynErr(232);
 	}
 
 	void Expr(
-#line  1593 "VBNET.ATG" 
+#line  1596 "VBNET.ATG" 
 out Expression expr) {
 		DisjunctionExpr(
-#line  1595 "VBNET.ATG" 
+#line  1598 "VBNET.ATG" 
 out expr);
 	}
 
 	void ImplementsClause(
-#line  1566 "VBNET.ATG" 
+#line  1569 "VBNET.ATG" 
 out List<InterfaceImplementation> baseInterfaces) {
 
-#line  1568 "VBNET.ATG" 
+#line  1571 "VBNET.ATG" 
 		baseInterfaces = new List<InterfaceImplementation>();
 		TypeReference type = null;
 		string memberName = null;
 		
 		Expect(115);
 		NonArrayTypeName(
-#line  1573 "VBNET.ATG" 
+#line  1576 "VBNET.ATG" 
 out type, false);
 
-#line  1574 "VBNET.ATG" 
+#line  1577 "VBNET.ATG" 
 		if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-#line  1575 "VBNET.ATG" 
+#line  1578 "VBNET.ATG" 
 		baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			NonArrayTypeName(
-#line  1577 "VBNET.ATG" 
+#line  1580 "VBNET.ATG" 
 out type, false);
 
-#line  1578 "VBNET.ATG" 
+#line  1581 "VBNET.ATG" 
 			if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-#line  1579 "VBNET.ATG" 
+#line  1582 "VBNET.ATG" 
 			baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		}
 	}
 
 	void HandlesClause(
-#line  1524 "VBNET.ATG" 
+#line  1527 "VBNET.ATG" 
 out List<string> handlesClause) {
 
-#line  1526 "VBNET.ATG" 
+#line  1529 "VBNET.ATG" 
 		handlesClause = new List<string>();
 		string name;
 		
 		Expect(113);
 		EventMemberSpecifier(
-#line  1529 "VBNET.ATG" 
+#line  1532 "VBNET.ATG" 
 out name);
 
-#line  1529 "VBNET.ATG" 
+#line  1532 "VBNET.ATG" 
 		handlesClause.Add(name); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			EventMemberSpecifier(
-#line  1530 "VBNET.ATG" 
+#line  1533 "VBNET.ATG" 
 out name);
 
-#line  1530 "VBNET.ATG" 
+#line  1533 "VBNET.ATG" 
 			handlesClause.Add(name); 
 		}
 	}
 
 	void Block(
-#line  2339 "VBNET.ATG" 
+#line  2342 "VBNET.ATG" 
 out Statement stmt) {
 
-#line  2342 "VBNET.ATG" 
+#line  2345 "VBNET.ATG" 
 		BlockStatement blockStmt = new BlockStatement();
 		/* in snippet parsing mode, t might be null */
 		if (t != null) blockStmt.StartLocation = t.Location;
 		compilationUnit.BlockStart(blockStmt);
 		
 		while (StartOf(20) || 
-#line  2348 "VBNET.ATG" 
+#line  2351 "VBNET.ATG" 
 IsEndStmtAhead()) {
 			if (
-#line  2348 "VBNET.ATG" 
+#line  2351 "VBNET.ATG" 
 IsEndStmtAhead()) {
 				Expect(95);
 				EndOfStmt();
 
-#line  2348 "VBNET.ATG" 
+#line  2351 "VBNET.ATG" 
 				compilationUnit.AddChild(new EndStatement()); 
 			} else {
 				Statement();
@@ -2578,7 +2588,7 @@ IsEndStmtAhead()) {
 			}
 		}
 
-#line  2353 "VBNET.ATG" 
+#line  2356 "VBNET.ATG" 
 		stmt = blockStmt;
 		if (t != null) blockStmt.EndLocation = t.EndLocation;
 		compilationUnit.BlockEnd();
@@ -2586,26 +2596,26 @@ IsEndStmtAhead()) {
 	}
 
 	void Charset(
-#line  1516 "VBNET.ATG" 
+#line  1519 "VBNET.ATG" 
 out CharsetModifier charsetModifier) {
 
-#line  1517 "VBNET.ATG" 
+#line  1520 "VBNET.ATG" 
 		charsetModifier = CharsetModifier.None; 
 		if (la.kind == 107 || la.kind == 183) {
 		} else if (la.kind == 48) {
 			lexer.NextToken();
 
-#line  1518 "VBNET.ATG" 
+#line  1521 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Ansi; 
 		} else if (la.kind == 51) {
 			lexer.NextToken();
 
-#line  1519 "VBNET.ATG" 
+#line  1522 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Auto; 
 		} else if (la.kind == 195) {
 			lexer.NextToken();
 
-#line  1520 "VBNET.ATG" 
+#line  1523 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Unicode; 
 		} else SynErr(233);
 	}
@@ -2660,15 +2670,19 @@ out CharsetModifier charsetModifier) {
 			lexer.NextToken();
 			break;
 		}
+		case 118: {
+			lexer.NextToken();
+			break;
+		}
 		default: SynErr(234); break;
 		}
 	}
 
 	void VariableDeclaratorPartAfterIdentifier(
-#line  1391 "VBNET.ATG" 
+#line  1394 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration, string name) {
 
-#line  1393 "VBNET.ATG" 
+#line  1396 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		ArrayList rank = null;
@@ -2676,28 +2690,28 @@ List<VariableDeclaration> fieldDeclaration, string name) {
 		Location startLocation = t.Location;
 		
 		if (
-#line  1399 "VBNET.ATG" 
+#line  1402 "VBNET.ATG" 
 IsSize() && !IsDims()) {
 			ArrayInitializationModifier(
-#line  1399 "VBNET.ATG" 
+#line  1402 "VBNET.ATG" 
 out dimension);
 		}
 		if (
-#line  1400 "VBNET.ATG" 
+#line  1403 "VBNET.ATG" 
 IsDims()) {
 			ArrayNameModifier(
-#line  1400 "VBNET.ATG" 
+#line  1403 "VBNET.ATG" 
 out rank);
 		}
 		if (
-#line  1402 "VBNET.ATG" 
+#line  1405 "VBNET.ATG" 
 IsObjectCreation()) {
 			Expect(49);
 			ObjectCreateExpression(
-#line  1402 "VBNET.ATG" 
+#line  1405 "VBNET.ATG" 
 out expr);
 
-#line  1404 "VBNET.ATG" 
+#line  1407 "VBNET.ATG" 
 			if (expr is ObjectCreateExpression) {
 			type = ((ObjectCreateExpression)expr).CreateType;
 			} else {
@@ -2708,10 +2722,10 @@ out expr);
 			if (la.kind == 49) {
 				lexer.NextToken();
 				TypeName(
-#line  1411 "VBNET.ATG" 
+#line  1414 "VBNET.ATG" 
 out type);
 
-#line  1413 "VBNET.ATG" 
+#line  1416 "VBNET.ATG" 
 				if (type != null) {
 				for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
 					VariableDeclaration vd = fieldDeclaration[i];
@@ -2724,7 +2738,7 @@ out type);
 				 
 			}
 
-#line  1425 "VBNET.ATG" 
+#line  1428 "VBNET.ATG" 
 			if (type == null && (dimension != null || rank != null)) {
 			type = new TypeReference("");
 			}
@@ -2752,12 +2766,12 @@ out type);
 			if (la.kind == 10) {
 				lexer.NextToken();
 				VariableInitializer(
-#line  1449 "VBNET.ATG" 
+#line  1452 "VBNET.ATG" 
 out expr);
 			}
 		} else SynErr(235);
 
-#line  1452 "VBNET.ATG" 
+#line  1455 "VBNET.ATG" 
 		VariableDeclaration varDecl = new VariableDeclaration(name, expr, type);
 		varDecl.StartLocation = startLocation;
 		varDecl.EndLocation = t.Location;
@@ -2766,22 +2780,22 @@ out expr);
 	}
 
 	void VariableDeclarator(
-#line  1385 "VBNET.ATG" 
+#line  1388 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration) {
 		Identifier();
 
-#line  1387 "VBNET.ATG" 
+#line  1390 "VBNET.ATG" 
 		string name = t.val; 
 		VariableDeclaratorPartAfterIdentifier(
-#line  1388 "VBNET.ATG" 
+#line  1391 "VBNET.ATG" 
 fieldDeclaration, name);
 	}
 
 	void ConstantDeclarator(
-#line  1366 "VBNET.ATG" 
+#line  1369 "VBNET.ATG" 
 List<VariableDeclaration> constantDeclaration) {
 
-#line  1368 "VBNET.ATG" 
+#line  1371 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		string name = String.Empty;
@@ -2789,20 +2803,20 @@ List<VariableDeclaration> constantDeclaration) {
 		
 		Identifier();
 
-#line  1373 "VBNET.ATG" 
+#line  1376 "VBNET.ATG" 
 		name = t.val; location = t.Location; 
 		if (la.kind == 49) {
 			lexer.NextToken();
 			TypeName(
-#line  1374 "VBNET.ATG" 
+#line  1377 "VBNET.ATG" 
 out type);
 		}
 		Expect(10);
 		Expr(
-#line  1375 "VBNET.ATG" 
+#line  1378 "VBNET.ATG" 
 out expr);
 
-#line  1377 "VBNET.ATG" 
+#line  1380 "VBNET.ATG" 
 		VariableDeclaration f = new VariableDeclaration(name, expr);
 		f.TypeReference = type;
 		f.StartLocation = location;
@@ -2811,10 +2825,10 @@ out expr);
 	}
 
 	void AccessorDecls(
-#line  1300 "VBNET.ATG" 
+#line  1303 "VBNET.ATG" 
 out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 
-#line  1302 "VBNET.ATG" 
+#line  1305 "VBNET.ATG" 
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		AttributeSection section;
 		getBlock = null;
@@ -2822,60 +2836,60 @@ out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 		
 		while (la.kind == 28) {
 			AttributeSection(
-#line  1307 "VBNET.ATG" 
+#line  1310 "VBNET.ATG" 
 out section);
 
-#line  1307 "VBNET.ATG" 
+#line  1310 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		if (StartOf(22)) {
 			GetAccessorDecl(
-#line  1309 "VBNET.ATG" 
+#line  1312 "VBNET.ATG" 
 out getBlock, attributes);
 			if (StartOf(23)) {
 
-#line  1311 "VBNET.ATG" 
+#line  1314 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 28) {
 					AttributeSection(
-#line  1312 "VBNET.ATG" 
+#line  1315 "VBNET.ATG" 
 out section);
 
-#line  1312 "VBNET.ATG" 
+#line  1315 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				SetAccessorDecl(
-#line  1313 "VBNET.ATG" 
+#line  1316 "VBNET.ATG" 
 out setBlock, attributes);
 			}
 		} else if (StartOf(24)) {
 			SetAccessorDecl(
-#line  1316 "VBNET.ATG" 
+#line  1319 "VBNET.ATG" 
 out setBlock, attributes);
 			if (StartOf(25)) {
 
-#line  1318 "VBNET.ATG" 
+#line  1321 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 28) {
 					AttributeSection(
-#line  1319 "VBNET.ATG" 
+#line  1322 "VBNET.ATG" 
 out section);
 
-#line  1319 "VBNET.ATG" 
+#line  1322 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				GetAccessorDecl(
-#line  1320 "VBNET.ATG" 
+#line  1323 "VBNET.ATG" 
 out getBlock, attributes);
 			}
 		} else SynErr(236);
 	}
 
 	void EventAccessorDeclaration(
-#line  1263 "VBNET.ATG" 
+#line  1266 "VBNET.ATG" 
 out EventAddRemoveRegion eventAccessorDeclaration) {
 
-#line  1265 "VBNET.ATG" 
+#line  1268 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		AttributeSection section;
@@ -2884,10 +2898,10 @@ out EventAddRemoveRegion eventAccessorDeclaration) {
 		
 		while (la.kind == 28) {
 			AttributeSection(
-#line  1271 "VBNET.ATG" 
+#line  1274 "VBNET.ATG" 
 out section);
 
-#line  1271 "VBNET.ATG" 
+#line  1274 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		if (la.kind == 43) {
@@ -2896,20 +2910,20 @@ out section);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1273 "VBNET.ATG" 
+#line  1276 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
 			}
 			Expect(1);
 			Block(
-#line  1274 "VBNET.ATG" 
+#line  1277 "VBNET.ATG" 
 out stmt);
 			Expect(95);
 			Expect(43);
 			EndOfStmt();
 
-#line  1276 "VBNET.ATG" 
+#line  1279 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventAddRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -2920,20 +2934,20 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1281 "VBNET.ATG" 
+#line  1284 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
 			}
 			Expect(1);
 			Block(
-#line  1282 "VBNET.ATG" 
+#line  1285 "VBNET.ATG" 
 out stmt);
 			Expect(95);
 			Expect(167);
 			EndOfStmt();
 
-#line  1284 "VBNET.ATG" 
+#line  1287 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRemoveRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -2944,20 +2958,20 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1289 "VBNET.ATG" 
+#line  1292 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
 			}
 			Expect(1);
 			Block(
-#line  1290 "VBNET.ATG" 
+#line  1293 "VBNET.ATG" 
 out stmt);
 			Expect(95);
 			Expect(163);
 			EndOfStmt();
 
-#line  1292 "VBNET.ATG" 
+#line  1295 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRaiseRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -2966,163 +2980,163 @@ out stmt);
 	}
 
 	void OverloadableOperator(
-#line  1205 "VBNET.ATG" 
+#line  1208 "VBNET.ATG" 
 out OverloadableOperatorType operatorType) {
 
-#line  1206 "VBNET.ATG" 
+#line  1209 "VBNET.ATG" 
 		operatorType = OverloadableOperatorType.None; 
 		switch (la.kind) {
 		case 19: {
 			lexer.NextToken();
 
-#line  1208 "VBNET.ATG" 
+#line  1211 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Add; 
 			break;
 		}
 		case 18: {
 			lexer.NextToken();
 
-#line  1210 "VBNET.ATG" 
+#line  1213 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Subtract; 
 			break;
 		}
 		case 22: {
 			lexer.NextToken();
 
-#line  1212 "VBNET.ATG" 
+#line  1215 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Multiply; 
 			break;
 		}
 		case 14: {
 			lexer.NextToken();
 
-#line  1214 "VBNET.ATG" 
+#line  1217 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Divide; 
 			break;
 		}
 		case 15: {
 			lexer.NextToken();
 
-#line  1216 "VBNET.ATG" 
+#line  1219 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.DivideInteger; 
 			break;
 		}
 		case 13: {
 			lexer.NextToken();
 
-#line  1218 "VBNET.ATG" 
+#line  1221 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Concat; 
 			break;
 		}
 		case 126: {
 			lexer.NextToken();
 
-#line  1220 "VBNET.ATG" 
+#line  1223 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Like; 
 			break;
 		}
 		case 130: {
 			lexer.NextToken();
 
-#line  1222 "VBNET.ATG" 
+#line  1225 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Modulus; 
 			break;
 		}
 		case 46: {
 			lexer.NextToken();
 
-#line  1224 "VBNET.ATG" 
+#line  1227 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseAnd; 
 			break;
 		}
 		case 151: {
 			lexer.NextToken();
 
-#line  1226 "VBNET.ATG" 
+#line  1229 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseOr; 
 			break;
 		}
 		case 207: {
 			lexer.NextToken();
 
-#line  1228 "VBNET.ATG" 
+#line  1231 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ExclusiveOr; 
 			break;
 		}
 		case 20: {
 			lexer.NextToken();
 
-#line  1230 "VBNET.ATG" 
+#line  1233 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Power; 
 			break;
 		}
 		case 32: {
 			lexer.NextToken();
 
-#line  1232 "VBNET.ATG" 
+#line  1235 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftLeft; 
 			break;
 		}
 		case 33: {
 			lexer.NextToken();
 
-#line  1234 "VBNET.ATG" 
+#line  1237 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftRight; 
 			break;
 		}
 		case 10: {
 			lexer.NextToken();
 
-#line  1236 "VBNET.ATG" 
+#line  1239 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Equality; 
 			break;
 		}
 		case 29: {
 			lexer.NextToken();
 
-#line  1238 "VBNET.ATG" 
+#line  1241 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.InEquality; 
 			break;
 		}
 		case 28: {
 			lexer.NextToken();
 
-#line  1240 "VBNET.ATG" 
+#line  1243 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThan; 
 			break;
 		}
 		case 31: {
 			lexer.NextToken();
 
-#line  1242 "VBNET.ATG" 
+#line  1245 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThanOrEqual; 
 			break;
 		}
 		case 27: {
 			lexer.NextToken();
 
-#line  1244 "VBNET.ATG" 
+#line  1247 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThan; 
 			break;
 		}
 		case 30: {
 			lexer.NextToken();
 
-#line  1246 "VBNET.ATG" 
+#line  1249 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThanOrEqual; 
 			break;
 		}
 		case 78: {
 			lexer.NextToken();
 
-#line  1248 "VBNET.ATG" 
+#line  1251 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.CType; 
 			break;
 		}
 		case 2: case 48: case 50: case 51: case 52: case 71: case 82: case 102: case 146: case 158: case 185: case 195: case 196: {
 			Identifier();
 
-#line  1252 "VBNET.ATG" 
+#line  1255 "VBNET.ATG" 
 			string opName = t.val; 
 			if (string.Equals(opName, "istrue", StringComparison.InvariantCultureIgnoreCase)) {
 				operatorType = OverloadableOperatorType.IsTrue;
@@ -3139,67 +3153,67 @@ out OverloadableOperatorType operatorType) {
 	}
 
 	void GetAccessorDecl(
-#line  1326 "VBNET.ATG" 
+#line  1329 "VBNET.ATG" 
 out PropertyGetRegion getBlock, List<AttributeSection> attributes) {
 
-#line  1327 "VBNET.ATG" 
+#line  1330 "VBNET.ATG" 
 		Statement stmt = null; Modifiers m; 
 		PropertyAccessorAccessModifier(
-#line  1329 "VBNET.ATG" 
+#line  1332 "VBNET.ATG" 
 out m);
 		Expect(108);
 
-#line  1331 "VBNET.ATG" 
+#line  1334 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		Expect(1);
 		Block(
-#line  1333 "VBNET.ATG" 
+#line  1336 "VBNET.ATG" 
 out stmt);
 
-#line  1334 "VBNET.ATG" 
+#line  1337 "VBNET.ATG" 
 		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); 
 		Expect(95);
 		Expect(108);
 
-#line  1336 "VBNET.ATG" 
+#line  1339 "VBNET.ATG" 
 		getBlock.Modifier = m; 
 
-#line  1337 "VBNET.ATG" 
+#line  1340 "VBNET.ATG" 
 		getBlock.StartLocation = startLocation; getBlock.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void SetAccessorDecl(
-#line  1342 "VBNET.ATG" 
+#line  1345 "VBNET.ATG" 
 out PropertySetRegion setBlock, List<AttributeSection> attributes) {
 
-#line  1344 "VBNET.ATG" 
+#line  1347 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		Modifiers m;
 		
 		PropertyAccessorAccessModifier(
-#line  1349 "VBNET.ATG" 
+#line  1352 "VBNET.ATG" 
 out m);
 		Expect(172);
 
-#line  1351 "VBNET.ATG" 
+#line  1354 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		if (la.kind == 25) {
 			lexer.NextToken();
 			if (StartOf(4)) {
 				FormalParameterList(
-#line  1352 "VBNET.ATG" 
+#line  1355 "VBNET.ATG" 
 p);
 			}
 			Expect(26);
 		}
 		Expect(1);
 		Block(
-#line  1354 "VBNET.ATG" 
+#line  1357 "VBNET.ATG" 
 out stmt);
 
-#line  1356 "VBNET.ATG" 
+#line  1359 "VBNET.ATG" 
 		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
 		setBlock.Modifier = m;
 		setBlock.Parameters = p;
@@ -3207,73 +3221,73 @@ out stmt);
 		Expect(95);
 		Expect(172);
 
-#line  1361 "VBNET.ATG" 
+#line  1364 "VBNET.ATG" 
 		setBlock.StartLocation = startLocation; setBlock.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void PropertyAccessorAccessModifier(
-#line  3045 "VBNET.ATG" 
+#line  3048 "VBNET.ATG" 
 out Modifiers m) {
 
-#line  3046 "VBNET.ATG" 
+#line  3049 "VBNET.ATG" 
 		m = Modifiers.None; 
 		while (StartOf(26)) {
 			if (la.kind == 162) {
 				lexer.NextToken();
 
-#line  3048 "VBNET.ATG" 
+#line  3051 "VBNET.ATG" 
 				m |= Modifiers.Public; 
 			} else if (la.kind == 161) {
 				lexer.NextToken();
 
-#line  3049 "VBNET.ATG" 
+#line  3052 "VBNET.ATG" 
 				m |= Modifiers.Protected; 
 			} else if (la.kind == 106) {
 				lexer.NextToken();
 
-#line  3050 "VBNET.ATG" 
+#line  3053 "VBNET.ATG" 
 				m |= Modifiers.Internal; 
 			} else {
 				lexer.NextToken();
 
-#line  3051 "VBNET.ATG" 
+#line  3054 "VBNET.ATG" 
 				m |= Modifiers.Private; 
 			}
 		}
 	}
 
 	void ArrayInitializationModifier(
-#line  1460 "VBNET.ATG" 
+#line  1463 "VBNET.ATG" 
 out List<Expression> arrayModifiers) {
 
-#line  1462 "VBNET.ATG" 
+#line  1465 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		Expect(25);
 		InitializationRankList(
-#line  1464 "VBNET.ATG" 
+#line  1467 "VBNET.ATG" 
 out arrayModifiers);
 		Expect(26);
 	}
 
 	void ArrayNameModifier(
-#line  2130 "VBNET.ATG" 
+#line  2133 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  2132 "VBNET.ATG" 
+#line  2135 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		ArrayTypeModifiers(
-#line  2134 "VBNET.ATG" 
+#line  2137 "VBNET.ATG" 
 out arrayModifiers);
 	}
 
 	void ObjectCreateExpression(
-#line  1919 "VBNET.ATG" 
+#line  1922 "VBNET.ATG" 
 out Expression oce) {
 
-#line  1921 "VBNET.ATG" 
+#line  1924 "VBNET.ATG" 
 		TypeReference type = null;
 		Expression initializer = null;
 		List<Expression> arguments = null;
@@ -3284,39 +3298,39 @@ out Expression oce) {
 		Expect(138);
 		if (StartOf(6)) {
 			NonArrayTypeName(
-#line  1929 "VBNET.ATG" 
+#line  1932 "VBNET.ATG" 
 out type, false);
 			if (la.kind == 25) {
 				lexer.NextToken();
 				NormalOrReDimArgumentList(
-#line  1930 "VBNET.ATG" 
+#line  1933 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeReDim);
 				Expect(26);
 				if (la.kind == 23 || 
-#line  1931 "VBNET.ATG" 
+#line  1934 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 					if (
-#line  1931 "VBNET.ATG" 
+#line  1934 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 						ArrayTypeModifiers(
-#line  1932 "VBNET.ATG" 
+#line  1935 "VBNET.ATG" 
 out dimensions);
 						CollectionInitializer(
-#line  1933 "VBNET.ATG" 
+#line  1936 "VBNET.ATG" 
 out initializer);
 					} else {
 						CollectionInitializer(
-#line  1934 "VBNET.ATG" 
+#line  1937 "VBNET.ATG" 
 out initializer);
 					}
 				}
 
-#line  1936 "VBNET.ATG" 
+#line  1939 "VBNET.ATG" 
 				if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); 
 			}
 		}
 
-#line  1940 "VBNET.ATG" 
+#line  1943 "VBNET.ATG" 
 		if (initializer == null) {
 		oce = new ObjectCreateExpression(type, arguments);
 		SetParent(arguments, oce);
@@ -3332,34 +3346,34 @@ out initializer);
 		
 		if (la.kind == 204) {
 
-#line  1956 "VBNET.ATG" 
+#line  1959 "VBNET.ATG" 
 			NamedArgumentExpression memberInitializer = null;
 			
 			lexer.NextToken();
 
-#line  1960 "VBNET.ATG" 
+#line  1963 "VBNET.ATG" 
 			CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
 			memberInitializers.StartLocation = la.Location;
 			
 			Expect(23);
 			MemberInitializer(
-#line  1964 "VBNET.ATG" 
+#line  1967 "VBNET.ATG" 
 out memberInitializer);
 
-#line  1965 "VBNET.ATG" 
+#line  1968 "VBNET.ATG" 
 			memberInitializers.CreateExpressions.Add(memberInitializer); 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				MemberInitializer(
-#line  1967 "VBNET.ATG" 
+#line  1970 "VBNET.ATG" 
 out memberInitializer);
 
-#line  1968 "VBNET.ATG" 
+#line  1971 "VBNET.ATG" 
 				memberInitializers.CreateExpressions.Add(memberInitializer); 
 			}
 			Expect(24);
 
-#line  1972 "VBNET.ATG" 
+#line  1975 "VBNET.ATG" 
 			memberInitializers.EndLocation = t.Location;
 			if(oce is ObjectCreateExpression)
 			{
@@ -3370,106 +3384,106 @@ out memberInitializer);
 	}
 
 	void VariableInitializer(
-#line  1488 "VBNET.ATG" 
+#line  1491 "VBNET.ATG" 
 out Expression initializerExpression) {
 
-#line  1490 "VBNET.ATG" 
+#line  1493 "VBNET.ATG" 
 		initializerExpression = null;
 		
 		if (StartOf(27)) {
 			Expr(
-#line  1492 "VBNET.ATG" 
+#line  1495 "VBNET.ATG" 
 out initializerExpression);
 		} else if (la.kind == 23) {
 			CollectionInitializer(
-#line  1493 "VBNET.ATG" 
+#line  1496 "VBNET.ATG" 
 out initializerExpression);
 		} else SynErr(239);
 	}
 
 	void InitializationRankList(
-#line  1468 "VBNET.ATG" 
+#line  1471 "VBNET.ATG" 
 out List<Expression> rank) {
 
-#line  1470 "VBNET.ATG" 
+#line  1473 "VBNET.ATG" 
 		rank = new List<Expression>();
 		Expression expr = null;
 		
 		Expr(
-#line  1473 "VBNET.ATG" 
+#line  1476 "VBNET.ATG" 
 out expr);
 		if (la.kind == 188) {
 			lexer.NextToken();
 
-#line  1474 "VBNET.ATG" 
+#line  1477 "VBNET.ATG" 
 			EnsureIsZero(expr); 
 			Expr(
-#line  1475 "VBNET.ATG" 
+#line  1478 "VBNET.ATG" 
 out expr);
 		}
 
-#line  1477 "VBNET.ATG" 
+#line  1480 "VBNET.ATG" 
 		if (expr != null) { rank.Add(expr); } 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			Expr(
-#line  1479 "VBNET.ATG" 
+#line  1482 "VBNET.ATG" 
 out expr);
 			if (la.kind == 188) {
 				lexer.NextToken();
 
-#line  1480 "VBNET.ATG" 
+#line  1483 "VBNET.ATG" 
 				EnsureIsZero(expr); 
 				Expr(
-#line  1481 "VBNET.ATG" 
+#line  1484 "VBNET.ATG" 
 out expr);
 			}
 
-#line  1483 "VBNET.ATG" 
+#line  1486 "VBNET.ATG" 
 			if (expr != null) { rank.Add(expr); } 
 		}
 	}
 
 	void CollectionInitializer(
-#line  1497 "VBNET.ATG" 
+#line  1500 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1499 "VBNET.ATG" 
+#line  1502 "VBNET.ATG" 
 		Expression expr = null;
 		CollectionInitializerExpression initializer = new CollectionInitializerExpression();
 		
 		Expect(23);
 		if (StartOf(28)) {
 			VariableInitializer(
-#line  1504 "VBNET.ATG" 
+#line  1507 "VBNET.ATG" 
 out expr);
 
-#line  1506 "VBNET.ATG" 
+#line  1509 "VBNET.ATG" 
 			if (expr != null) { initializer.CreateExpressions.Add(expr); }
 			
 			while (
-#line  1509 "VBNET.ATG" 
+#line  1512 "VBNET.ATG" 
 NotFinalComma()) {
 				Expect(12);
 				VariableInitializer(
-#line  1509 "VBNET.ATG" 
+#line  1512 "VBNET.ATG" 
 out expr);
 
-#line  1510 "VBNET.ATG" 
+#line  1513 "VBNET.ATG" 
 				if (expr != null) { initializer.CreateExpressions.Add(expr); } 
 			}
 		}
 		Expect(24);
 
-#line  1513 "VBNET.ATG" 
+#line  1516 "VBNET.ATG" 
 		outExpr = initializer; 
 	}
 
 	void EventMemberSpecifier(
-#line  1583 "VBNET.ATG" 
+#line  1586 "VBNET.ATG" 
 out string name) {
 
-#line  1584 "VBNET.ATG" 
+#line  1587 "VBNET.ATG" 
 		string eventName; 
 		if (StartOf(13)) {
 			Identifier();
@@ -3479,136 +3493,136 @@ out string name) {
 			lexer.NextToken();
 		} else SynErr(240);
 
-#line  1587 "VBNET.ATG" 
+#line  1590 "VBNET.ATG" 
 		name = t.val; 
 		Expect(16);
 		IdentifierOrKeyword(
-#line  1589 "VBNET.ATG" 
+#line  1592 "VBNET.ATG" 
 out eventName);
 
-#line  1590 "VBNET.ATG" 
+#line  1593 "VBNET.ATG" 
 		name = name + "." + eventName; 
 	}
 
 	void IdentifierOrKeyword(
-#line  2978 "VBNET.ATG" 
+#line  2981 "VBNET.ATG" 
 out string name) {
 
-#line  2980 "VBNET.ATG" 
+#line  2983 "VBNET.ATG" 
 		lexer.NextToken(); name = t.val;  
 	}
 
 	void DisjunctionExpr(
-#line  1763 "VBNET.ATG" 
+#line  1766 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1765 "VBNET.ATG" 
+#line  1768 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ConjunctionExpr(
-#line  1768 "VBNET.ATG" 
+#line  1771 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 151 || la.kind == 152 || la.kind == 207) {
 			if (la.kind == 151) {
 				lexer.NextToken();
 
-#line  1771 "VBNET.ATG" 
+#line  1774 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseOr; 
 			} else if (la.kind == 152) {
 				lexer.NextToken();
 
-#line  1772 "VBNET.ATG" 
+#line  1775 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalOr; 
 			} else {
 				lexer.NextToken();
 
-#line  1773 "VBNET.ATG" 
+#line  1776 "VBNET.ATG" 
 				op = BinaryOperatorType.ExclusiveOr; 
 			}
 			ConjunctionExpr(
-#line  1775 "VBNET.ATG" 
+#line  1778 "VBNET.ATG" 
 out expr);
 
-#line  1775 "VBNET.ATG" 
+#line  1778 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void AssignmentOperator(
-#line  1598 "VBNET.ATG" 
+#line  1601 "VBNET.ATG" 
 out AssignmentOperatorType op) {
 
-#line  1599 "VBNET.ATG" 
+#line  1602 "VBNET.ATG" 
 		op = AssignmentOperatorType.None; 
 		switch (la.kind) {
 		case 10: {
 			lexer.NextToken();
 
-#line  1600 "VBNET.ATG" 
+#line  1603 "VBNET.ATG" 
 			op = AssignmentOperatorType.Assign; 
 			break;
 		}
 		case 42: {
 			lexer.NextToken();
 
-#line  1601 "VBNET.ATG" 
+#line  1604 "VBNET.ATG" 
 			op = AssignmentOperatorType.ConcatString; 
 			break;
 		}
 		case 34: {
 			lexer.NextToken();
 
-#line  1602 "VBNET.ATG" 
+#line  1605 "VBNET.ATG" 
 			op = AssignmentOperatorType.Add; 
 			break;
 		}
 		case 36: {
 			lexer.NextToken();
 
-#line  1603 "VBNET.ATG" 
+#line  1606 "VBNET.ATG" 
 			op = AssignmentOperatorType.Subtract; 
 			break;
 		}
 		case 37: {
 			lexer.NextToken();
 
-#line  1604 "VBNET.ATG" 
+#line  1607 "VBNET.ATG" 
 			op = AssignmentOperatorType.Multiply; 
 			break;
 		}
 		case 38: {
 			lexer.NextToken();
 
-#line  1605 "VBNET.ATG" 
+#line  1608 "VBNET.ATG" 
 			op = AssignmentOperatorType.Divide; 
 			break;
 		}
 		case 39: {
 			lexer.NextToken();
 
-#line  1606 "VBNET.ATG" 
+#line  1609 "VBNET.ATG" 
 			op = AssignmentOperatorType.DivideInteger; 
 			break;
 		}
 		case 35: {
 			lexer.NextToken();
 
-#line  1607 "VBNET.ATG" 
+#line  1610 "VBNET.ATG" 
 			op = AssignmentOperatorType.Power; 
 			break;
 		}
 		case 40: {
 			lexer.NextToken();
 
-#line  1608 "VBNET.ATG" 
+#line  1611 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftLeft; 
 			break;
 		}
 		case 41: {
 			lexer.NextToken();
 
-#line  1609 "VBNET.ATG" 
+#line  1612 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftRight; 
 			break;
 		}
@@ -3617,451 +3631,451 @@ out AssignmentOperatorType op) {
 	}
 
 	void SimpleExpr(
-#line  1613 "VBNET.ATG" 
+#line  1616 "VBNET.ATG" 
 out Expression pexpr) {
 
-#line  1614 "VBNET.ATG" 
+#line  1617 "VBNET.ATG" 
 		string name; 
 		SimpleNonInvocationExpression(
-#line  1616 "VBNET.ATG" 
+#line  1619 "VBNET.ATG" 
 out pexpr);
 		while (la.kind == 16 || la.kind == 17 || la.kind == 25) {
 			if (la.kind == 16) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  1618 "VBNET.ATG" 
+#line  1621 "VBNET.ATG" 
 out name);
 
-#line  1619 "VBNET.ATG" 
+#line  1622 "VBNET.ATG" 
 				pexpr = new MemberReferenceExpression(pexpr, name); 
 				if (
-#line  1620 "VBNET.ATG" 
+#line  1623 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 					lexer.NextToken();
 					Expect(145);
 					TypeArgumentList(
-#line  1621 "VBNET.ATG" 
+#line  1624 "VBNET.ATG" 
 ((MemberReferenceExpression)pexpr).TypeArguments);
 					Expect(26);
 				}
 			} else if (la.kind == 17) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  1623 "VBNET.ATG" 
+#line  1626 "VBNET.ATG" 
 out name);
 
-#line  1623 "VBNET.ATG" 
+#line  1626 "VBNET.ATG" 
 				pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name)); 
 			} else {
 				InvocationExpression(
-#line  1624 "VBNET.ATG" 
+#line  1627 "VBNET.ATG" 
 ref pexpr);
 			}
 		}
 	}
 
 	void SimpleNonInvocationExpression(
-#line  1628 "VBNET.ATG" 
+#line  1631 "VBNET.ATG" 
 out Expression pexpr) {
 
-#line  1630 "VBNET.ATG" 
+#line  1633 "VBNET.ATG" 
 		Expression expr;
 		TypeReference type = null;
 		string name = String.Empty;
 		pexpr = null;
 		
 		if (StartOf(29) || 
-#line  1684 "VBNET.ATG" 
+#line  1687 "VBNET.ATG" 
 la.kind == Tokens.If) {
 			if (la.kind == 3) {
 				lexer.NextToken();
 
-#line  1638 "VBNET.ATG" 
+#line  1641 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 			} else if (la.kind == 4) {
 				lexer.NextToken();
 
-#line  1639 "VBNET.ATG" 
+#line  1642 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 			} else if (la.kind == 7) {
 				lexer.NextToken();
 
-#line  1640 "VBNET.ATG" 
+#line  1643 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 			} else if (la.kind == 6) {
 				lexer.NextToken();
 
-#line  1641 "VBNET.ATG" 
+#line  1644 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 			} else if (la.kind == 5) {
 				lexer.NextToken();
 
-#line  1642 "VBNET.ATG" 
+#line  1645 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 			} else if (la.kind == 9) {
 				lexer.NextToken();
 
-#line  1643 "VBNET.ATG" 
+#line  1646 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 			} else if (la.kind == 8) {
 				lexer.NextToken();
 
-#line  1644 "VBNET.ATG" 
+#line  1647 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 			} else if (la.kind == 189) {
 				lexer.NextToken();
 
-#line  1646 "VBNET.ATG" 
+#line  1649 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(true, "true");  
 			} else if (la.kind == 103) {
 				lexer.NextToken();
 
-#line  1647 "VBNET.ATG" 
+#line  1650 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(false, "false"); 
 			} else if (la.kind == 141) {
 				lexer.NextToken();
 
-#line  1648 "VBNET.ATG" 
+#line  1651 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(null, "null");  
 			} else if (la.kind == 25) {
 				lexer.NextToken();
 				Expr(
-#line  1649 "VBNET.ATG" 
+#line  1652 "VBNET.ATG" 
 out expr);
 				Expect(26);
 
-#line  1649 "VBNET.ATG" 
+#line  1652 "VBNET.ATG" 
 				pexpr = new ParenthesizedExpression(expr); 
 			} else if (StartOf(13)) {
 				Identifier();
 
-#line  1651 "VBNET.ATG" 
+#line  1654 "VBNET.ATG" 
 				pexpr = new IdentifierExpression(t.val);
 				pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
 				
 				if (
-#line  1654 "VBNET.ATG" 
+#line  1657 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 					lexer.NextToken();
 					Expect(145);
 					TypeArgumentList(
-#line  1655 "VBNET.ATG" 
+#line  1658 "VBNET.ATG" 
 ((IdentifierExpression)pexpr).TypeArguments);
 					Expect(26);
 				}
 			} else if (StartOf(30)) {
 
-#line  1657 "VBNET.ATG" 
+#line  1660 "VBNET.ATG" 
 				string val = String.Empty; 
 				if (StartOf(10)) {
 					PrimitiveTypeName(
-#line  1658 "VBNET.ATG" 
+#line  1661 "VBNET.ATG" 
 out val);
 				} else if (la.kind == 144) {
 					lexer.NextToken();
 
-#line  1658 "VBNET.ATG" 
+#line  1661 "VBNET.ATG" 
 					val = "Object"; 
 				} else SynErr(242);
 				Expect(16);
 
-#line  1659 "VBNET.ATG" 
+#line  1662 "VBNET.ATG" 
 				t.val = ""; 
 				Identifier();
 
-#line  1659 "VBNET.ATG" 
+#line  1662 "VBNET.ATG" 
 				pexpr = new MemberReferenceExpression(new TypeReferenceExpression(val), t.val); 
 			} else if (la.kind == 129) {
 				lexer.NextToken();
 
-#line  1660 "VBNET.ATG" 
+#line  1663 "VBNET.ATG" 
 				pexpr = new ThisReferenceExpression(); 
 			} else if (la.kind == 134 || la.kind == 135) {
 
-#line  1661 "VBNET.ATG" 
+#line  1664 "VBNET.ATG" 
 				Expression retExpr = null; 
 				if (la.kind == 134) {
 					lexer.NextToken();
 
-#line  1662 "VBNET.ATG" 
+#line  1665 "VBNET.ATG" 
 					retExpr = new BaseReferenceExpression(); 
 				} else if (la.kind == 135) {
 					lexer.NextToken();
 
-#line  1663 "VBNET.ATG" 
+#line  1666 "VBNET.ATG" 
 					retExpr = new ClassReferenceExpression(); 
 				} else SynErr(243);
 				Expect(16);
 				IdentifierOrKeyword(
-#line  1665 "VBNET.ATG" 
+#line  1668 "VBNET.ATG" 
 out name);
 
-#line  1665 "VBNET.ATG" 
+#line  1668 "VBNET.ATG" 
 				pexpr = new MemberReferenceExpression(retExpr, name); 
 			} else if (la.kind == 110) {
 				lexer.NextToken();
 				Expect(16);
 				Identifier();
 
-#line  1667 "VBNET.ATG" 
+#line  1670 "VBNET.ATG" 
 				type = new TypeReference(t.val ?? ""); 
 
-#line  1669 "VBNET.ATG" 
+#line  1672 "VBNET.ATG" 
 				type.IsGlobal = true; 
 
-#line  1670 "VBNET.ATG" 
+#line  1673 "VBNET.ATG" 
 				pexpr = new TypeReferenceExpression(type); 
 			} else if (la.kind == 138) {
 				ObjectCreateExpression(
-#line  1671 "VBNET.ATG" 
+#line  1674 "VBNET.ATG" 
 out expr);
 
-#line  1671 "VBNET.ATG" 
+#line  1674 "VBNET.ATG" 
 				pexpr = expr; 
 			} else if (la.kind == 78 || la.kind == 89 || la.kind == 191) {
 
-#line  1673 "VBNET.ATG" 
+#line  1676 "VBNET.ATG" 
 				CastType castType = CastType.Cast; 
 				if (la.kind == 89) {
 					lexer.NextToken();
 				} else if (la.kind == 78) {
 					lexer.NextToken();
 
-#line  1675 "VBNET.ATG" 
+#line  1678 "VBNET.ATG" 
 					castType = CastType.Conversion; 
 				} else if (la.kind == 191) {
 					lexer.NextToken();
 
-#line  1676 "VBNET.ATG" 
+#line  1679 "VBNET.ATG" 
 					castType = CastType.TryCast; 
 				} else SynErr(244);
 				Expect(25);
 				Expr(
-#line  1678 "VBNET.ATG" 
+#line  1681 "VBNET.ATG" 
 out expr);
 				Expect(12);
 				TypeName(
-#line  1678 "VBNET.ATG" 
+#line  1681 "VBNET.ATG" 
 out type);
 				Expect(26);
 
-#line  1679 "VBNET.ATG" 
+#line  1682 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, castType); 
 			} else if (StartOf(31)) {
 				CastTarget(
-#line  1680 "VBNET.ATG" 
+#line  1683 "VBNET.ATG" 
 out type);
 				Expect(25);
 				Expr(
-#line  1680 "VBNET.ATG" 
+#line  1683 "VBNET.ATG" 
 out expr);
 				Expect(26);
 
-#line  1680 "VBNET.ATG" 
+#line  1683 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); 
 			} else if (la.kind == 44) {
 				lexer.NextToken();
 				Expr(
-#line  1681 "VBNET.ATG" 
+#line  1684 "VBNET.ATG" 
 out expr);
 
-#line  1681 "VBNET.ATG" 
+#line  1684 "VBNET.ATG" 
 				pexpr = new AddressOfExpression(expr); 
 			} else if (la.kind == 109) {
 				lexer.NextToken();
 				Expect(25);
 				GetTypeTypeName(
-#line  1682 "VBNET.ATG" 
+#line  1685 "VBNET.ATG" 
 out type);
 				Expect(26);
 
-#line  1682 "VBNET.ATG" 
+#line  1685 "VBNET.ATG" 
 				pexpr = new TypeOfExpression(type); 
 			} else if (la.kind == 192) {
 				lexer.NextToken();
 				SimpleExpr(
-#line  1683 "VBNET.ATG" 
+#line  1686 "VBNET.ATG" 
 out expr);
 				Expect(122);
 				TypeName(
-#line  1683 "VBNET.ATG" 
+#line  1686 "VBNET.ATG" 
 out type);
 
-#line  1683 "VBNET.ATG" 
+#line  1686 "VBNET.ATG" 
 				pexpr = new TypeOfIsExpression(expr, type); 
 			} else {
 				ConditionalExpression(
-#line  1684 "VBNET.ATG" 
+#line  1687 "VBNET.ATG" 
 out pexpr);
 			}
 		} else if (la.kind == 16) {
 			lexer.NextToken();
 			IdentifierOrKeyword(
-#line  1688 "VBNET.ATG" 
+#line  1691 "VBNET.ATG" 
 out name);
 
-#line  1688 "VBNET.ATG" 
+#line  1691 "VBNET.ATG" 
 			pexpr = new MemberReferenceExpression(null, name);
 		} else SynErr(245);
 	}
 
 	void TypeArgumentList(
-#line  2166 "VBNET.ATG" 
+#line  2169 "VBNET.ATG" 
 List<TypeReference> typeArguments) {
 
-#line  2168 "VBNET.ATG" 
+#line  2171 "VBNET.ATG" 
 		TypeReference typeref;
 		
 		TypeName(
-#line  2170 "VBNET.ATG" 
+#line  2173 "VBNET.ATG" 
 out typeref);
 
-#line  2170 "VBNET.ATG" 
+#line  2173 "VBNET.ATG" 
 		if (typeref != null) typeArguments.Add(typeref); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  2173 "VBNET.ATG" 
+#line  2176 "VBNET.ATG" 
 out typeref);
 
-#line  2173 "VBNET.ATG" 
+#line  2176 "VBNET.ATG" 
 			if (typeref != null) typeArguments.Add(typeref); 
 		}
 	}
 
 	void InvocationExpression(
-#line  1726 "VBNET.ATG" 
+#line  1729 "VBNET.ATG" 
 ref Expression pexpr) {
 
-#line  1727 "VBNET.ATG" 
+#line  1730 "VBNET.ATG" 
 		List<Expression> parameters = null; 
 		Expect(25);
 
-#line  1729 "VBNET.ATG" 
+#line  1732 "VBNET.ATG" 
 		Location start = t.Location; 
 		ArgumentList(
-#line  1730 "VBNET.ATG" 
+#line  1733 "VBNET.ATG" 
 out parameters);
 		Expect(26);
 
-#line  1733 "VBNET.ATG" 
+#line  1736 "VBNET.ATG" 
 		pexpr = new InvocationExpression(pexpr, parameters);
 		SetParent(parameters, pexpr);
 		
 
-#line  1736 "VBNET.ATG" 
+#line  1739 "VBNET.ATG" 
 		pexpr.StartLocation = start; pexpr.EndLocation = t.Location; 
 	}
 
 	void PrimitiveTypeName(
-#line  2985 "VBNET.ATG" 
+#line  2988 "VBNET.ATG" 
 out string type) {
 
-#line  2986 "VBNET.ATG" 
+#line  2989 "VBNET.ATG" 
 		type = String.Empty; 
 		switch (la.kind) {
 		case 53: {
 			lexer.NextToken();
 
-#line  2987 "VBNET.ATG" 
+#line  2990 "VBNET.ATG" 
 			type = "Boolean"; 
 			break;
 		}
 		case 83: {
 			lexer.NextToken();
 
-#line  2988 "VBNET.ATG" 
+#line  2991 "VBNET.ATG" 
 			type = "Date"; 
 			break;
 		}
 		case 66: {
 			lexer.NextToken();
 
-#line  2989 "VBNET.ATG" 
+#line  2992 "VBNET.ATG" 
 			type = "Char"; 
 			break;
 		}
 		case 181: {
 			lexer.NextToken();
 
-#line  2990 "VBNET.ATG" 
+#line  2993 "VBNET.ATG" 
 			type = "String"; 
 			break;
 		}
 		case 84: {
 			lexer.NextToken();
 
-#line  2991 "VBNET.ATG" 
+#line  2994 "VBNET.ATG" 
 			type = "Decimal"; 
 			break;
 		}
 		case 55: {
 			lexer.NextToken();
 
-#line  2992 "VBNET.ATG" 
+#line  2995 "VBNET.ATG" 
 			type = "Byte"; 
 			break;
 		}
 		case 175: {
 			lexer.NextToken();
 
-#line  2993 "VBNET.ATG" 
+#line  2996 "VBNET.ATG" 
 			type = "Short"; 
 			break;
 		}
 		case 120: {
 			lexer.NextToken();
 
-#line  2994 "VBNET.ATG" 
+#line  2997 "VBNET.ATG" 
 			type = "Integer"; 
 			break;
 		}
 		case 127: {
 			lexer.NextToken();
 
-#line  2995 "VBNET.ATG" 
+#line  2998 "VBNET.ATG" 
 			type = "Long"; 
 			break;
 		}
 		case 176: {
 			lexer.NextToken();
 
-#line  2996 "VBNET.ATG" 
+#line  2999 "VBNET.ATG" 
 			type = "Single"; 
 			break;
 		}
 		case 91: {
 			lexer.NextToken();
 
-#line  2997 "VBNET.ATG" 
+#line  3000 "VBNET.ATG" 
 			type = "Double"; 
 			break;
 		}
 		case 193: {
 			lexer.NextToken();
 
-#line  2998 "VBNET.ATG" 
+#line  3001 "VBNET.ATG" 
 			type = "UInteger"; 
 			break;
 		}
 		case 194: {
 			lexer.NextToken();
 
-#line  2999 "VBNET.ATG" 
+#line  3002 "VBNET.ATG" 
 			type = "ULong"; 
 			break;
 		}
 		case 197: {
 			lexer.NextToken();
 
-#line  3000 "VBNET.ATG" 
+#line  3003 "VBNET.ATG" 
 			type = "UShort"; 
 			break;
 		}
 		case 170: {
 			lexer.NextToken();
 
-#line  3001 "VBNET.ATG" 
+#line  3004 "VBNET.ATG" 
 			type = "SByte"; 
 			break;
 		}
@@ -4070,122 +4084,122 @@ out string type) {
 	}
 
 	void CastTarget(
-#line  1741 "VBNET.ATG" 
+#line  1744 "VBNET.ATG" 
 out TypeReference type) {
 
-#line  1743 "VBNET.ATG" 
+#line  1746 "VBNET.ATG" 
 		type = null;
 		
 		switch (la.kind) {
 		case 60: {
 			lexer.NextToken();
 
-#line  1745 "VBNET.ATG" 
+#line  1748 "VBNET.ATG" 
 			type = new TypeReference("System.Boolean"); 
 			break;
 		}
 		case 61: {
 			lexer.NextToken();
 
-#line  1746 "VBNET.ATG" 
+#line  1749 "VBNET.ATG" 
 			type = new TypeReference("System.Byte"); 
 			break;
 		}
 		case 74: {
 			lexer.NextToken();
 
-#line  1747 "VBNET.ATG" 
+#line  1750 "VBNET.ATG" 
 			type = new TypeReference("System.SByte"); 
 			break;
 		}
 		case 62: {
 			lexer.NextToken();
 
-#line  1748 "VBNET.ATG" 
+#line  1751 "VBNET.ATG" 
 			type = new TypeReference("System.Char"); 
 			break;
 		}
 		case 63: {
 			lexer.NextToken();
 
-#line  1749 "VBNET.ATG" 
+#line  1752 "VBNET.ATG" 
 			type = new TypeReference("System.DateTime"); 
 			break;
 		}
 		case 65: {
 			lexer.NextToken();
 
-#line  1750 "VBNET.ATG" 
+#line  1753 "VBNET.ATG" 
 			type = new TypeReference("System.Decimal"); 
 			break;
 		}
 		case 64: {
 			lexer.NextToken();
 
-#line  1751 "VBNET.ATG" 
+#line  1754 "VBNET.ATG" 
 			type = new TypeReference("System.Double"); 
 			break;
 		}
 		case 75: {
 			lexer.NextToken();
 
-#line  1752 "VBNET.ATG" 
+#line  1755 "VBNET.ATG" 
 			type = new TypeReference("System.Int16"); 
 			break;
 		}
 		case 67: {
 			lexer.NextToken();
 
-#line  1753 "VBNET.ATG" 
+#line  1756 "VBNET.ATG" 
 			type = new TypeReference("System.Int32"); 
 			break;
 		}
 		case 69: {
 			lexer.NextToken();
 
-#line  1754 "VBNET.ATG" 
+#line  1757 "VBNET.ATG" 
 			type = new TypeReference("System.Int64"); 
 			break;
 		}
 		case 81: {
 			lexer.NextToken();
 
-#line  1755 "VBNET.ATG" 
+#line  1758 "VBNET.ATG" 
 			type = new TypeReference("System.UInt16"); 
 			break;
 		}
 		case 79: {
 			lexer.NextToken();
 
-#line  1756 "VBNET.ATG" 
+#line  1759 "VBNET.ATG" 
 			type = new TypeReference("System.UInt32"); 
 			break;
 		}
 		case 80: {
 			lexer.NextToken();
 
-#line  1757 "VBNET.ATG" 
+#line  1760 "VBNET.ATG" 
 			type = new TypeReference("System.UInt64"); 
 			break;
 		}
 		case 70: {
 			lexer.NextToken();
 
-#line  1758 "VBNET.ATG" 
+#line  1761 "VBNET.ATG" 
 			type = new TypeReference("System.Object"); 
 			break;
 		}
 		case 76: {
 			lexer.NextToken();
 
-#line  1759 "VBNET.ATG" 
+#line  1762 "VBNET.ATG" 
 			type = new TypeReference("System.Single"); 
 			break;
 		}
 		case 77: {
 			lexer.NextToken();
 
-#line  1760 "VBNET.ATG" 
+#line  1763 "VBNET.ATG" 
 			type = new TypeReference("System.String"); 
 			break;
 		}
@@ -4194,19 +4208,19 @@ out TypeReference type) {
 	}
 
 	void GetTypeTypeName(
-#line  2065 "VBNET.ATG" 
+#line  2068 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  2066 "VBNET.ATG" 
+#line  2069 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  2068 "VBNET.ATG" 
+#line  2071 "VBNET.ATG" 
 out typeref, true);
 		ArrayTypeModifiers(
-#line  2069 "VBNET.ATG" 
+#line  2072 "VBNET.ATG" 
 out rank);
 
-#line  2070 "VBNET.ATG" 
+#line  2073 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -4214,10 +4228,10 @@ out rank);
 	}
 
 	void ConditionalExpression(
-#line  1692 "VBNET.ATG" 
+#line  1695 "VBNET.ATG" 
 out Expression expr) {
 
-#line  1694 "VBNET.ATG" 
+#line  1697 "VBNET.ATG" 
 		ConditionalExpression conditionalExpression = new ConditionalExpression();
 		BinaryOperatorExpression binaryOperatorExpression = new BinaryOperatorExpression();
 		conditionalExpression.StartLocation = binaryOperatorExpression.StartLocation = la.Location;
@@ -4229,21 +4243,21 @@ out Expression expr) {
 		Expect(114);
 		Expect(25);
 		Expr(
-#line  1703 "VBNET.ATG" 
+#line  1706 "VBNET.ATG" 
 out condition);
 		Expect(12);
 		Expr(
-#line  1703 "VBNET.ATG" 
+#line  1706 "VBNET.ATG" 
 out trueExpr);
 		if (la.kind == 12) {
 			lexer.NextToken();
 			Expr(
-#line  1703 "VBNET.ATG" 
+#line  1706 "VBNET.ATG" 
 out falseExpr);
 		}
 		Expect(26);
 
-#line  1705 "VBNET.ATG" 
+#line  1708 "VBNET.ATG" 
 		if(falseExpr != null)
 		{
 			conditionalExpression.Condition = condition;
@@ -4266,348 +4280,348 @@ out falseExpr);
 	}
 
 	void ArgumentList(
-#line  1997 "VBNET.ATG" 
+#line  2000 "VBNET.ATG" 
 out List<Expression> arguments) {
 
-#line  1999 "VBNET.ATG" 
+#line  2002 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		Expression expr = null;
 		
 		if (StartOf(27)) {
 			Argument(
-#line  2002 "VBNET.ATG" 
+#line  2005 "VBNET.ATG" 
 out expr);
 		}
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  2003 "VBNET.ATG" 
+#line  2006 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 			if (StartOf(27)) {
 				Argument(
-#line  2004 "VBNET.ATG" 
+#line  2007 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2005 "VBNET.ATG" 
+#line  2008 "VBNET.ATG" 
 			if (expr == null) expr = Expression.Null; 
 		}
 
-#line  2007 "VBNET.ATG" 
+#line  2010 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); 
 	}
 
 	void ConjunctionExpr(
-#line  1779 "VBNET.ATG" 
+#line  1782 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1781 "VBNET.ATG" 
+#line  1784 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		NotExpr(
-#line  1784 "VBNET.ATG" 
+#line  1787 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 46 || la.kind == 47) {
 			if (la.kind == 46) {
 				lexer.NextToken();
 
-#line  1787 "VBNET.ATG" 
+#line  1790 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseAnd; 
 			} else {
 				lexer.NextToken();
 
-#line  1788 "VBNET.ATG" 
+#line  1791 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalAnd; 
 			}
 			NotExpr(
-#line  1790 "VBNET.ATG" 
+#line  1793 "VBNET.ATG" 
 out expr);
 
-#line  1790 "VBNET.ATG" 
+#line  1793 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void NotExpr(
-#line  1794 "VBNET.ATG" 
+#line  1797 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1795 "VBNET.ATG" 
+#line  1798 "VBNET.ATG" 
 		UnaryOperatorType uop = UnaryOperatorType.None; 
 		while (la.kind == 140) {
 			lexer.NextToken();
 
-#line  1796 "VBNET.ATG" 
+#line  1799 "VBNET.ATG" 
 			uop = UnaryOperatorType.Not; 
 		}
 		ComparisonExpr(
-#line  1797 "VBNET.ATG" 
+#line  1800 "VBNET.ATG" 
 out outExpr);
 
-#line  1798 "VBNET.ATG" 
+#line  1801 "VBNET.ATG" 
 		if (uop != UnaryOperatorType.None)
 		outExpr = new UnaryOperatorExpression(outExpr, uop);
 		
 	}
 
 	void ComparisonExpr(
-#line  1803 "VBNET.ATG" 
+#line  1806 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1805 "VBNET.ATG" 
+#line  1808 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ShiftExpr(
-#line  1808 "VBNET.ATG" 
+#line  1811 "VBNET.ATG" 
 out outExpr);
 		while (StartOf(32)) {
 			switch (la.kind) {
 			case 28: {
 				lexer.NextToken();
 
-#line  1811 "VBNET.ATG" 
+#line  1814 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 27: {
 				lexer.NextToken();
 
-#line  1812 "VBNET.ATG" 
+#line  1815 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 31: {
 				lexer.NextToken();
 
-#line  1813 "VBNET.ATG" 
+#line  1816 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 30: {
 				lexer.NextToken();
 
-#line  1814 "VBNET.ATG" 
+#line  1817 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 29: {
 				lexer.NextToken();
 
-#line  1815 "VBNET.ATG" 
+#line  1818 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			case 10: {
 				lexer.NextToken();
 
-#line  1816 "VBNET.ATG" 
+#line  1819 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 126: {
 				lexer.NextToken();
 
-#line  1817 "VBNET.ATG" 
+#line  1820 "VBNET.ATG" 
 				op = BinaryOperatorType.Like; 
 				break;
 			}
 			case 122: {
 				lexer.NextToken();
 
-#line  1818 "VBNET.ATG" 
+#line  1821 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceEquality; 
 				break;
 			}
 			case 123: {
 				lexer.NextToken();
 
-#line  1819 "VBNET.ATG" 
+#line  1822 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceInequality; 
 				break;
 			}
 			}
 			if (StartOf(33)) {
 				ShiftExpr(
-#line  1822 "VBNET.ATG" 
+#line  1825 "VBNET.ATG" 
 out expr);
 
-#line  1822 "VBNET.ATG" 
+#line  1825 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 			} else if (la.kind == 140) {
 				lexer.NextToken();
 				ShiftExpr(
-#line  1825 "VBNET.ATG" 
+#line  1828 "VBNET.ATG" 
 out expr);
 
-#line  1825 "VBNET.ATG" 
+#line  1828 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not));  
 			} else SynErr(248);
 		}
 	}
 
 	void ShiftExpr(
-#line  1830 "VBNET.ATG" 
+#line  1833 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1832 "VBNET.ATG" 
+#line  1835 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ConcatenationExpr(
-#line  1835 "VBNET.ATG" 
+#line  1838 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 32 || la.kind == 33) {
 			if (la.kind == 32) {
 				lexer.NextToken();
 
-#line  1838 "VBNET.ATG" 
+#line  1841 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftLeft; 
 			} else {
 				lexer.NextToken();
 
-#line  1839 "VBNET.ATG" 
+#line  1842 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftRight; 
 			}
 			ConcatenationExpr(
-#line  1841 "VBNET.ATG" 
+#line  1844 "VBNET.ATG" 
 out expr);
 
-#line  1841 "VBNET.ATG" 
+#line  1844 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void ConcatenationExpr(
-#line  1845 "VBNET.ATG" 
+#line  1848 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1846 "VBNET.ATG" 
+#line  1849 "VBNET.ATG" 
 		Expression expr; 
 		AdditiveExpr(
-#line  1848 "VBNET.ATG" 
+#line  1851 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 13) {
 			lexer.NextToken();
 			AdditiveExpr(
-#line  1848 "VBNET.ATG" 
+#line  1851 "VBNET.ATG" 
 out expr);
 
-#line  1848 "VBNET.ATG" 
+#line  1851 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr);  
 		}
 	}
 
 	void AdditiveExpr(
-#line  1851 "VBNET.ATG" 
+#line  1854 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1853 "VBNET.ATG" 
+#line  1856 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ModuloExpr(
-#line  1856 "VBNET.ATG" 
+#line  1859 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 18 || la.kind == 19) {
 			if (la.kind == 19) {
 				lexer.NextToken();
 
-#line  1859 "VBNET.ATG" 
+#line  1862 "VBNET.ATG" 
 				op = BinaryOperatorType.Add; 
 			} else {
 				lexer.NextToken();
 
-#line  1860 "VBNET.ATG" 
+#line  1863 "VBNET.ATG" 
 				op = BinaryOperatorType.Subtract; 
 			}
 			ModuloExpr(
-#line  1862 "VBNET.ATG" 
+#line  1865 "VBNET.ATG" 
 out expr);
 
-#line  1862 "VBNET.ATG" 
+#line  1865 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void ModuloExpr(
-#line  1866 "VBNET.ATG" 
+#line  1869 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1867 "VBNET.ATG" 
+#line  1870 "VBNET.ATG" 
 		Expression expr; 
 		IntegerDivisionExpr(
-#line  1869 "VBNET.ATG" 
+#line  1872 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 130) {
 			lexer.NextToken();
 			IntegerDivisionExpr(
-#line  1869 "VBNET.ATG" 
+#line  1872 "VBNET.ATG" 
 out expr);
 
-#line  1869 "VBNET.ATG" 
+#line  1872 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr);  
 		}
 	}
 
 	void IntegerDivisionExpr(
-#line  1872 "VBNET.ATG" 
+#line  1875 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1873 "VBNET.ATG" 
+#line  1876 "VBNET.ATG" 
 		Expression expr; 
 		MultiplicativeExpr(
-#line  1875 "VBNET.ATG" 
+#line  1878 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 15) {
 			lexer.NextToken();
 			MultiplicativeExpr(
-#line  1875 "VBNET.ATG" 
+#line  1878 "VBNET.ATG" 
 out expr);
 
-#line  1875 "VBNET.ATG" 
+#line  1878 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr);  
 		}
 	}
 
 	void MultiplicativeExpr(
-#line  1878 "VBNET.ATG" 
+#line  1881 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1880 "VBNET.ATG" 
+#line  1883 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		UnaryExpr(
-#line  1883 "VBNET.ATG" 
+#line  1886 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 14 || la.kind == 22) {
 			if (la.kind == 22) {
 				lexer.NextToken();
 
-#line  1886 "VBNET.ATG" 
+#line  1889 "VBNET.ATG" 
 				op = BinaryOperatorType.Multiply; 
 			} else {
 				lexer.NextToken();
 
-#line  1887 "VBNET.ATG" 
+#line  1890 "VBNET.ATG" 
 				op = BinaryOperatorType.Divide; 
 			}
 			UnaryExpr(
-#line  1889 "VBNET.ATG" 
+#line  1892 "VBNET.ATG" 
 out expr);
 
-#line  1889 "VBNET.ATG" 
+#line  1892 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr); 
 		}
 	}
 
 	void UnaryExpr(
-#line  1893 "VBNET.ATG" 
+#line  1896 "VBNET.ATG" 
 out Expression uExpr) {
 
-#line  1895 "VBNET.ATG" 
+#line  1898 "VBNET.ATG" 
 		Expression expr;
 		UnaryOperatorType uop = UnaryOperatorType.None;
 		bool isUOp = false;
@@ -4616,25 +4630,25 @@ out Expression uExpr) {
 			if (la.kind == 19) {
 				lexer.NextToken();
 
-#line  1899 "VBNET.ATG" 
+#line  1902 "VBNET.ATG" 
 				uop = UnaryOperatorType.Plus; isUOp = true; 
 			} else if (la.kind == 18) {
 				lexer.NextToken();
 
-#line  1900 "VBNET.ATG" 
+#line  1903 "VBNET.ATG" 
 				uop = UnaryOperatorType.Minus; isUOp = true; 
 			} else {
 				lexer.NextToken();
 
-#line  1901 "VBNET.ATG" 
+#line  1904 "VBNET.ATG" 
 				uop = UnaryOperatorType.Dereference;  isUOp = true;
 			}
 		}
 		ExponentiationExpr(
-#line  1903 "VBNET.ATG" 
+#line  1906 "VBNET.ATG" 
 out expr);
 
-#line  1905 "VBNET.ATG" 
+#line  1908 "VBNET.ATG" 
 		if (isUOp) {
 		uExpr = new UnaryOperatorExpression(expr, uop);
 		} else {
@@ -4644,107 +4658,107 @@ out expr);
 	}
 
 	void ExponentiationExpr(
-#line  1913 "VBNET.ATG" 
+#line  1916 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1914 "VBNET.ATG" 
+#line  1917 "VBNET.ATG" 
 		Expression expr; 
 		SimpleExpr(
-#line  1916 "VBNET.ATG" 
+#line  1919 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 20) {
 			lexer.NextToken();
 			SimpleExpr(
-#line  1916 "VBNET.ATG" 
+#line  1919 "VBNET.ATG" 
 out expr);
 
-#line  1916 "VBNET.ATG" 
+#line  1919 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr);  
 		}
 	}
 
 	void NormalOrReDimArgumentList(
-#line  2011 "VBNET.ATG" 
+#line  2014 "VBNET.ATG" 
 out List<Expression> arguments, out bool canBeNormal, out bool canBeRedim) {
 
-#line  2013 "VBNET.ATG" 
+#line  2016 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		canBeNormal = true; canBeRedim = !IsNamedAssign();
 		Expression expr = null;
 		
 		if (StartOf(27)) {
 			Argument(
-#line  2018 "VBNET.ATG" 
+#line  2021 "VBNET.ATG" 
 out expr);
 			if (la.kind == 188) {
 				lexer.NextToken();
 
-#line  2019 "VBNET.ATG" 
+#line  2022 "VBNET.ATG" 
 				EnsureIsZero(expr); canBeNormal = false; 
 				Expr(
-#line  2020 "VBNET.ATG" 
+#line  2023 "VBNET.ATG" 
 out expr);
 			}
 		}
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  2023 "VBNET.ATG" 
+#line  2026 "VBNET.ATG" 
 			if (expr == null) canBeRedim = false; 
 
-#line  2024 "VBNET.ATG" 
+#line  2027 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 
-#line  2025 "VBNET.ATG" 
+#line  2028 "VBNET.ATG" 
 			canBeRedim &= !IsNamedAssign(); 
 			if (StartOf(27)) {
 				Argument(
-#line  2026 "VBNET.ATG" 
+#line  2029 "VBNET.ATG" 
 out expr);
 				if (la.kind == 188) {
 					lexer.NextToken();
 
-#line  2027 "VBNET.ATG" 
+#line  2030 "VBNET.ATG" 
 					EnsureIsZero(expr); canBeNormal = false; 
 					Expr(
-#line  2028 "VBNET.ATG" 
+#line  2031 "VBNET.ATG" 
 out expr);
 				}
 			}
 
-#line  2030 "VBNET.ATG" 
+#line  2033 "VBNET.ATG" 
 			if (expr == null) { canBeRedim = false; expr = Expression.Null; } 
 		}
 
-#line  2032 "VBNET.ATG" 
+#line  2035 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); else canBeRedim = false; 
 	}
 
 	void ArrayTypeModifiers(
-#line  2139 "VBNET.ATG" 
+#line  2142 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  2141 "VBNET.ATG" 
+#line  2144 "VBNET.ATG" 
 		arrayModifiers = new ArrayList();
 		int i = 0;
 		
 		while (
-#line  2144 "VBNET.ATG" 
+#line  2147 "VBNET.ATG" 
 IsDims()) {
 			Expect(25);
 			if (la.kind == 12 || la.kind == 26) {
 				RankList(
-#line  2146 "VBNET.ATG" 
+#line  2149 "VBNET.ATG" 
 out i);
 			}
 
-#line  2148 "VBNET.ATG" 
+#line  2151 "VBNET.ATG" 
 			arrayModifiers.Add(i);
 			
 			Expect(26);
 		}
 
-#line  2153 "VBNET.ATG" 
+#line  2156 "VBNET.ATG" 
 		if(arrayModifiers.Count == 0) {
 		 arrayModifiers = null;
 		}
@@ -4752,10 +4766,10 @@ out i);
 	}
 
 	void MemberInitializer(
-#line  1981 "VBNET.ATG" 
+#line  1984 "VBNET.ATG" 
 out NamedArgumentExpression memberInitializer) {
 
-#line  1983 "VBNET.ATG" 
+#line  1986 "VBNET.ATG" 
 		memberInitializer = new NamedArgumentExpression();
 		memberInitializer.StartLocation = la.Location;
 		Expression initExpr = null;
@@ -4763,14 +4777,14 @@ out NamedArgumentExpression memberInitializer) {
 		
 		Expect(16);
 		IdentifierOrKeyword(
-#line  1988 "VBNET.ATG" 
+#line  1991 "VBNET.ATG" 
 out name);
 		Expect(10);
 		Expr(
-#line  1988 "VBNET.ATG" 
+#line  1991 "VBNET.ATG" 
 out initExpr);
 
-#line  1990 "VBNET.ATG" 
+#line  1993 "VBNET.ATG" 
 		memberInitializer.Name = name;
 		memberInitializer.Expression = initExpr;
 		memberInitializer.EndLocation = t.EndLocation;
@@ -4778,69 +4792,69 @@ out initExpr);
 	}
 
 	void Argument(
-#line  2036 "VBNET.ATG" 
+#line  2039 "VBNET.ATG" 
 out Expression argumentexpr) {
 
-#line  2038 "VBNET.ATG" 
+#line  2041 "VBNET.ATG" 
 		Expression expr;
 		argumentexpr = null;
 		string name;
 		
 		if (
-#line  2042 "VBNET.ATG" 
+#line  2045 "VBNET.ATG" 
 IsNamedAssign()) {
 			Identifier();
 
-#line  2042 "VBNET.ATG" 
+#line  2045 "VBNET.ATG" 
 			name = t.val;  
 			Expect(11);
 			Expect(10);
 			Expr(
-#line  2042 "VBNET.ATG" 
+#line  2045 "VBNET.ATG" 
 out expr);
 
-#line  2044 "VBNET.ATG" 
+#line  2047 "VBNET.ATG" 
 			argumentexpr = new NamedArgumentExpression(name, expr);
 			
 		} else if (StartOf(27)) {
 			Expr(
-#line  2047 "VBNET.ATG" 
+#line  2050 "VBNET.ATG" 
 out argumentexpr);
 		} else SynErr(249);
 	}
 
 	void QualIdentAndTypeArguments(
-#line  2113 "VBNET.ATG" 
+#line  2116 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  2114 "VBNET.ATG" 
+#line  2117 "VBNET.ATG" 
 		string name; typeref = null; 
 		Qualident(
-#line  2116 "VBNET.ATG" 
+#line  2119 "VBNET.ATG" 
 out name);
 
-#line  2117 "VBNET.ATG" 
+#line  2120 "VBNET.ATG" 
 		typeref = new TypeReference(name); 
 		if (
-#line  2118 "VBNET.ATG" 
+#line  2121 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			lexer.NextToken();
 			Expect(145);
 			if (
-#line  2120 "VBNET.ATG" 
+#line  2123 "VBNET.ATG" 
 canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma)) {
 
-#line  2121 "VBNET.ATG" 
+#line  2124 "VBNET.ATG" 
 				typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				while (la.kind == 12) {
 					lexer.NextToken();
 
-#line  2122 "VBNET.ATG" 
+#line  2125 "VBNET.ATG" 
 					typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				}
 			} else if (StartOf(6)) {
 				TypeArgumentList(
-#line  2123 "VBNET.ATG" 
+#line  2126 "VBNET.ATG" 
 typeref.GenericTypes);
 			} else SynErr(250);
 			Expect(26);
@@ -4848,24 +4862,24 @@ typeref.GenericTypes);
 	}
 
 	void RankList(
-#line  2160 "VBNET.ATG" 
+#line  2163 "VBNET.ATG" 
 out int i) {
 
-#line  2161 "VBNET.ATG" 
+#line  2164 "VBNET.ATG" 
 		i = 0; 
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  2162 "VBNET.ATG" 
+#line  2165 "VBNET.ATG" 
 			++i; 
 		}
 	}
 
 	void Attribute(
-#line  2201 "VBNET.ATG" 
+#line  2204 "VBNET.ATG" 
 out ASTAttribute attribute) {
 
-#line  2202 "VBNET.ATG" 
+#line  2205 "VBNET.ATG" 
 		string name;
 		List<Expression> positional = new List<Expression>();
 		List<NamedArgumentExpression> named = new List<NamedArgumentExpression>();
@@ -4875,15 +4889,15 @@ out ASTAttribute attribute) {
 			Expect(16);
 		}
 		Qualident(
-#line  2207 "VBNET.ATG" 
+#line  2210 "VBNET.ATG" 
 out name);
 		if (la.kind == 25) {
 			AttributeArguments(
-#line  2208 "VBNET.ATG" 
+#line  2211 "VBNET.ATG" 
 positional, named);
 		}
 
-#line  2210 "VBNET.ATG" 
+#line  2213 "VBNET.ATG" 
 		attribute  = new ASTAttribute(name, positional, named);
 		SetParent(positional, attribute);			
 		SetParent(named, attribute);			
@@ -4891,26 +4905,26 @@ positional, named);
 	}
 
 	void AttributeArguments(
-#line  2217 "VBNET.ATG" 
+#line  2220 "VBNET.ATG" 
 List<Expression> positional, List<NamedArgumentExpression> named) {
 
-#line  2219 "VBNET.ATG" 
+#line  2222 "VBNET.ATG" 
 		bool nameFound = false;
 		string name = "";
 		Expression expr;
 		
 		Expect(25);
 		if (
-#line  2225 "VBNET.ATG" 
+#line  2228 "VBNET.ATG" 
 IsNotClosingParenthesis()) {
 			if (
-#line  2227 "VBNET.ATG" 
+#line  2230 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2227 "VBNET.ATG" 
+#line  2230 "VBNET.ATG" 
 				nameFound = true; 
 				IdentifierOrKeyword(
-#line  2228 "VBNET.ATG" 
+#line  2231 "VBNET.ATG" 
 out name);
 				if (la.kind == 11) {
 					lexer.NextToken();
@@ -4918,10 +4932,10 @@ out name);
 				Expect(10);
 			}
 			Expr(
-#line  2230 "VBNET.ATG" 
+#line  2233 "VBNET.ATG" 
 out expr);
 
-#line  2232 "VBNET.ATG" 
+#line  2235 "VBNET.ATG" 
 			if (expr != null) {
 			if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
 			else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
@@ -4930,13 +4944,13 @@ out expr);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				if (
-#line  2240 "VBNET.ATG" 
+#line  2243 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2240 "VBNET.ATG" 
+#line  2243 "VBNET.ATG" 
 					nameFound = true; 
 					IdentifierOrKeyword(
-#line  2241 "VBNET.ATG" 
+#line  2244 "VBNET.ATG" 
 out name);
 					if (la.kind == 11) {
 						lexer.NextToken();
@@ -4944,14 +4958,14 @@ out name);
 					Expect(10);
 				} else if (StartOf(27)) {
 
-#line  2243 "VBNET.ATG" 
+#line  2246 "VBNET.ATG" 
 					if (nameFound) Error("no positional argument after named argument"); 
 				} else SynErr(251);
 				Expr(
-#line  2244 "VBNET.ATG" 
+#line  2247 "VBNET.ATG" 
 out expr);
 
-#line  2244 "VBNET.ATG" 
+#line  2247 "VBNET.ATG" 
 				if (expr != null) { if(name == "") positional.Add(expr);
 				else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
 				}
@@ -4962,10 +4976,10 @@ out expr);
 	}
 
 	void FormalParameter(
-#line  2301 "VBNET.ATG" 
+#line  2304 "VBNET.ATG" 
 out ParameterDeclarationExpression p) {
 
-#line  2303 "VBNET.ATG" 
+#line  2306 "VBNET.ATG" 
 		AttributeSection section;
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		TypeReference type = null;
@@ -4976,36 +4990,36 @@ out ParameterDeclarationExpression p) {
 		
 		while (la.kind == 28) {
 			AttributeSection(
-#line  2312 "VBNET.ATG" 
+#line  2315 "VBNET.ATG" 
 out section);
 
-#line  2312 "VBNET.ATG" 
+#line  2315 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		while (StartOf(34)) {
 			ParameterModifier(
-#line  2313 "VBNET.ATG" 
+#line  2316 "VBNET.ATG" 
 mod);
 		}
 		Identifier();
 
-#line  2314 "VBNET.ATG" 
+#line  2317 "VBNET.ATG" 
 		string parameterName = t.val; 
 		if (
-#line  2315 "VBNET.ATG" 
+#line  2318 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  2315 "VBNET.ATG" 
+#line  2318 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 49) {
 			lexer.NextToken();
 			TypeName(
-#line  2316 "VBNET.ATG" 
+#line  2319 "VBNET.ATG" 
 out type);
 		}
 
-#line  2318 "VBNET.ATG" 
+#line  2321 "VBNET.ATG" 
 		if(type != null) {
 		if (arrayModifiers != null) {
 			if (type.RankSpecifier != null) {
@@ -5021,11 +5035,11 @@ out type);
 		if (la.kind == 10) {
 			lexer.NextToken();
 			Expr(
-#line  2330 "VBNET.ATG" 
+#line  2333 "VBNET.ATG" 
 out expr);
 		}
 
-#line  2332 "VBNET.ATG" 
+#line  2335 "VBNET.ATG" 
 		mod.Check();
 		p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
 		p.Attributes = attributes;
@@ -5033,34 +5047,34 @@ out expr);
 	}
 
 	void ParameterModifier(
-#line  3004 "VBNET.ATG" 
+#line  3007 "VBNET.ATG" 
 ParamModifierList m) {
 		if (la.kind == 56) {
 			lexer.NextToken();
 
-#line  3005 "VBNET.ATG" 
+#line  3008 "VBNET.ATG" 
 			m.Add(ParameterModifiers.In); 
 		} else if (la.kind == 54) {
 			lexer.NextToken();
 
-#line  3006 "VBNET.ATG" 
+#line  3009 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Ref); 
 		} else if (la.kind == 150) {
 			lexer.NextToken();
 
-#line  3007 "VBNET.ATG" 
+#line  3010 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Optional); 
 		} else if (la.kind == 156) {
 			lexer.NextToken();
 
-#line  3008 "VBNET.ATG" 
+#line  3011 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Params); 
 		} else SynErr(252);
 	}
 
 	void Statement() {
 
-#line  2361 "VBNET.ATG" 
+#line  2364 "VBNET.ATG" 
 		Statement stmt = null;
 		Location startPos = la.Location;
 		string label = String.Empty;
@@ -5068,34 +5082,34 @@ ParamModifierList m) {
 		
 		if (la.kind == 1 || la.kind == 11) {
 		} else if (
-#line  2367 "VBNET.ATG" 
+#line  2370 "VBNET.ATG" 
 IsLabel()) {
 			LabelName(
-#line  2367 "VBNET.ATG" 
+#line  2370 "VBNET.ATG" 
 out label);
 
-#line  2369 "VBNET.ATG" 
+#line  2372 "VBNET.ATG" 
 			compilationUnit.AddChild(new LabelStatement(t.val));
 			
 			Expect(11);
 			Statement();
 		} else if (StartOf(35)) {
 			EmbeddedStatement(
-#line  2372 "VBNET.ATG" 
+#line  2375 "VBNET.ATG" 
 out stmt);
 
-#line  2372 "VBNET.ATG" 
+#line  2375 "VBNET.ATG" 
 			compilationUnit.AddChild(stmt); 
 		} else if (StartOf(36)) {
 			LocalDeclarationStatement(
-#line  2373 "VBNET.ATG" 
+#line  2376 "VBNET.ATG" 
 out stmt);
 
-#line  2373 "VBNET.ATG" 
+#line  2376 "VBNET.ATG" 
 			compilationUnit.AddChild(stmt); 
 		} else SynErr(253);
 
-#line  2376 "VBNET.ATG" 
+#line  2379 "VBNET.ATG" 
 		if (stmt != null) {
 		stmt.StartLocation = startPos;
 		stmt.EndLocation = t.Location;
@@ -5104,30 +5118,30 @@ out stmt);
 	}
 
 	void LabelName(
-#line  2782 "VBNET.ATG" 
+#line  2785 "VBNET.ATG" 
 out string name) {
 
-#line  2784 "VBNET.ATG" 
+#line  2787 "VBNET.ATG" 
 		name = String.Empty;
 		
 		if (StartOf(13)) {
 			Identifier();
 
-#line  2786 "VBNET.ATG" 
+#line  2789 "VBNET.ATG" 
 			name = t.val; 
 		} else if (la.kind == 5) {
 			lexer.NextToken();
 
-#line  2787 "VBNET.ATG" 
+#line  2790 "VBNET.ATG" 
 			name = t.val; 
 		} else SynErr(254);
 	}
 
 	void EmbeddedStatement(
-#line  2416 "VBNET.ATG" 
+#line  2419 "VBNET.ATG" 
 out Statement statement) {
 
-#line  2418 "VBNET.ATG" 
+#line  2421 "VBNET.ATG" 
 		Statement embeddedStatement = null;
 		statement = null;
 		Expression expr = null;
@@ -5138,103 +5152,103 @@ out Statement statement) {
 		case 101: {
 			lexer.NextToken();
 
-#line  2424 "VBNET.ATG" 
+#line  2427 "VBNET.ATG" 
 			ExitType exitType = ExitType.None; 
 			switch (la.kind) {
 			case 183: {
 				lexer.NextToken();
 
-#line  2426 "VBNET.ATG" 
+#line  2429 "VBNET.ATG" 
 				exitType = ExitType.Sub; 
 				break;
 			}
 			case 107: {
 				lexer.NextToken();
 
-#line  2428 "VBNET.ATG" 
+#line  2431 "VBNET.ATG" 
 				exitType = ExitType.Function; 
 				break;
 			}
 			case 160: {
 				lexer.NextToken();
 
-#line  2430 "VBNET.ATG" 
+#line  2433 "VBNET.ATG" 
 				exitType = ExitType.Property; 
 				break;
 			}
 			case 90: {
 				lexer.NextToken();
 
-#line  2432 "VBNET.ATG" 
+#line  2435 "VBNET.ATG" 
 				exitType = ExitType.Do; 
 				break;
 			}
 			case 105: {
 				lexer.NextToken();
 
-#line  2434 "VBNET.ATG" 
+#line  2437 "VBNET.ATG" 
 				exitType = ExitType.For; 
 				break;
 			}
 			case 190: {
 				lexer.NextToken();
 
-#line  2436 "VBNET.ATG" 
+#line  2439 "VBNET.ATG" 
 				exitType = ExitType.Try; 
 				break;
 			}
 			case 202: {
 				lexer.NextToken();
 
-#line  2438 "VBNET.ATG" 
+#line  2441 "VBNET.ATG" 
 				exitType = ExitType.While; 
 				break;
 			}
 			case 171: {
 				lexer.NextToken();
 
-#line  2440 "VBNET.ATG" 
+#line  2443 "VBNET.ATG" 
 				exitType = ExitType.Select; 
 				break;
 			}
 			default: SynErr(255); break;
 			}
 
-#line  2442 "VBNET.ATG" 
+#line  2445 "VBNET.ATG" 
 			statement = new ExitStatement(exitType); 
 			break;
 		}
 		case 190: {
 			TryStatement(
-#line  2443 "VBNET.ATG" 
+#line  2446 "VBNET.ATG" 
 out statement);
 			break;
 		}
 		case 73: {
 			lexer.NextToken();
 
-#line  2444 "VBNET.ATG" 
+#line  2447 "VBNET.ATG" 
 			ContinueType continueType = ContinueType.None; 
 			if (la.kind == 90 || la.kind == 105 || la.kind == 202) {
 				if (la.kind == 90) {
 					lexer.NextToken();
 
-#line  2444 "VBNET.ATG" 
+#line  2447 "VBNET.ATG" 
 					continueType = ContinueType.Do; 
 				} else if (la.kind == 105) {
 					lexer.NextToken();
 
-#line  2444 "VBNET.ATG" 
+#line  2447 "VBNET.ATG" 
 					continueType = ContinueType.For; 
 				} else {
 					lexer.NextToken();
 
-#line  2444 "VBNET.ATG" 
+#line  2447 "VBNET.ATG" 
 					continueType = ContinueType.While; 
 				}
 			}
 
-#line  2444 "VBNET.ATG" 
+#line  2447 "VBNET.ATG" 
 			statement = new ContinueStatement(continueType); 
 			break;
 		}
@@ -5242,11 +5256,11 @@ out statement);
 			lexer.NextToken();
 			if (StartOf(27)) {
 				Expr(
-#line  2446 "VBNET.ATG" 
+#line  2449 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2446 "VBNET.ATG" 
+#line  2449 "VBNET.ATG" 
 			statement = new ThrowStatement(expr); 
 			break;
 		}
@@ -5254,27 +5268,27 @@ out expr);
 			lexer.NextToken();
 			if (StartOf(27)) {
 				Expr(
-#line  2448 "VBNET.ATG" 
+#line  2451 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2448 "VBNET.ATG" 
+#line  2451 "VBNET.ATG" 
 			statement = new ReturnStatement(expr); 
 			break;
 		}
 		case 184: {
 			lexer.NextToken();
 			Expr(
-#line  2450 "VBNET.ATG" 
+#line  2453 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  2450 "VBNET.ATG" 
+#line  2453 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(95);
 			Expect(184);
 
-#line  2451 "VBNET.ATG" 
+#line  2454 "VBNET.ATG" 
 			statement = new LockStatement(expr, embeddedStatement); 
 			break;
 		}
@@ -5282,19 +5296,19 @@ out embeddedStatement);
 			lexer.NextToken();
 			Identifier();
 
-#line  2453 "VBNET.ATG" 
+#line  2456 "VBNET.ATG" 
 			name = t.val; 
 			if (la.kind == 25) {
 				lexer.NextToken();
 				if (StartOf(37)) {
 					ArgumentList(
-#line  2454 "VBNET.ATG" 
+#line  2457 "VBNET.ATG" 
 out p);
 				}
 				Expect(26);
 			}
 
-#line  2456 "VBNET.ATG" 
+#line  2459 "VBNET.ATG" 
 			statement = new RaiseEventStatement(name, p);
 			SetParent(p, statement);
 			
@@ -5302,24 +5316,24 @@ out p);
 		}
 		case 204: {
 			WithStatement(
-#line  2460 "VBNET.ATG" 
+#line  2463 "VBNET.ATG" 
 out statement);
 			break;
 		}
 		case 43: {
 			lexer.NextToken();
 
-#line  2462 "VBNET.ATG" 
+#line  2465 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  2463 "VBNET.ATG" 
+#line  2466 "VBNET.ATG" 
 out expr);
 			Expect(12);
 			Expr(
-#line  2463 "VBNET.ATG" 
+#line  2466 "VBNET.ATG" 
 out handlerExpr);
 
-#line  2465 "VBNET.ATG" 
+#line  2468 "VBNET.ATG" 
 			statement = new AddHandlerStatement(expr, handlerExpr);
 			
 			break;
@@ -5327,17 +5341,17 @@ out handlerExpr);
 		case 167: {
 			lexer.NextToken();
 
-#line  2468 "VBNET.ATG" 
+#line  2471 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  2469 "VBNET.ATG" 
+#line  2472 "VBNET.ATG" 
 out expr);
 			Expect(12);
 			Expr(
-#line  2469 "VBNET.ATG" 
+#line  2472 "VBNET.ATG" 
 out handlerExpr);
 
-#line  2471 "VBNET.ATG" 
+#line  2474 "VBNET.ATG" 
 			statement = new RemoveHandlerStatement(expr, handlerExpr);
 			
 			break;
@@ -5345,16 +5359,16 @@ out handlerExpr);
 		case 202: {
 			lexer.NextToken();
 			Expr(
-#line  2474 "VBNET.ATG" 
+#line  2477 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  2475 "VBNET.ATG" 
+#line  2478 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(95);
 			Expect(202);
 
-#line  2477 "VBNET.ATG" 
+#line  2480 "VBNET.ATG" 
 			statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
 			
 			break;
@@ -5362,23 +5376,23 @@ out embeddedStatement);
 		case 90: {
 			lexer.NextToken();
 
-#line  2482 "VBNET.ATG" 
+#line  2485 "VBNET.ATG" 
 			ConditionType conditionType = ConditionType.None;
 			
 			if (la.kind == 196 || la.kind == 202) {
 				WhileOrUntil(
-#line  2485 "VBNET.ATG" 
+#line  2488 "VBNET.ATG" 
 out conditionType);
 				Expr(
-#line  2485 "VBNET.ATG" 
+#line  2488 "VBNET.ATG" 
 out expr);
 				EndOfStmt();
 				Block(
-#line  2486 "VBNET.ATG" 
+#line  2489 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(128);
 
-#line  2489 "VBNET.ATG" 
+#line  2492 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, 
 				                               embeddedStatement, 
 				                               conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, 
@@ -5387,19 +5401,19 @@ out embeddedStatement);
 			} else if (la.kind == 1 || la.kind == 11) {
 				EndOfStmt();
 				Block(
-#line  2496 "VBNET.ATG" 
+#line  2499 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(128);
 				if (la.kind == 196 || la.kind == 202) {
 					WhileOrUntil(
-#line  2497 "VBNET.ATG" 
+#line  2500 "VBNET.ATG" 
 out conditionType);
 					Expr(
-#line  2497 "VBNET.ATG" 
+#line  2500 "VBNET.ATG" 
 out expr);
 				}
 
-#line  2499 "VBNET.ATG" 
+#line  2502 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End);
 				
 			} else SynErr(256);
@@ -5408,7 +5422,7 @@ out expr);
 		case 105: {
 			lexer.NextToken();
 
-#line  2504 "VBNET.ATG" 
+#line  2507 "VBNET.ATG" 
 			Expression group = null;
 			TypeReference typeReference;
 			string        typeName;
@@ -5417,24 +5431,24 @@ out expr);
 			if (la.kind == 92) {
 				lexer.NextToken();
 				LoopControlVariable(
-#line  2511 "VBNET.ATG" 
+#line  2514 "VBNET.ATG" 
 out typeReference, out typeName);
 				Expect(117);
 				Expr(
-#line  2512 "VBNET.ATG" 
+#line  2515 "VBNET.ATG" 
 out group);
 				EndOfStmt();
 				Block(
-#line  2513 "VBNET.ATG" 
+#line  2516 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(139);
 				if (StartOf(27)) {
 					Expr(
-#line  2514 "VBNET.ATG" 
+#line  2517 "VBNET.ATG" 
 out expr);
 				}
 
-#line  2516 "VBNET.ATG" 
+#line  2519 "VBNET.ATG" 
 				statement = new ForeachStatement(typeReference, 
 				                                typeName,
 				                                group, 
@@ -5446,55 +5460,55 @@ out expr);
 				
 			} else if (StartOf(13)) {
 
-#line  2527 "VBNET.ATG" 
+#line  2530 "VBNET.ATG" 
 				Expression start = null;
 				Expression end = null;
 				Expression step = null;
 				Expression nextExpr = null;List<Expression> nextExpressions = null;
 				
 				LoopControlVariable(
-#line  2532 "VBNET.ATG" 
+#line  2535 "VBNET.ATG" 
 out typeReference, out typeName);
 				Expect(10);
 				Expr(
-#line  2533 "VBNET.ATG" 
+#line  2536 "VBNET.ATG" 
 out start);
 				Expect(188);
 				Expr(
-#line  2533 "VBNET.ATG" 
+#line  2536 "VBNET.ATG" 
 out end);
 				if (la.kind == 178) {
 					lexer.NextToken();
 					Expr(
-#line  2533 "VBNET.ATG" 
+#line  2536 "VBNET.ATG" 
 out step);
 				}
 				EndOfStmt();
 				Block(
-#line  2534 "VBNET.ATG" 
+#line  2537 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(139);
 				if (StartOf(27)) {
 					Expr(
-#line  2537 "VBNET.ATG" 
+#line  2540 "VBNET.ATG" 
 out nextExpr);
 
-#line  2539 "VBNET.ATG" 
+#line  2542 "VBNET.ATG" 
 					nextExpressions = new List<Expression>();
 					nextExpressions.Add(nextExpr);
 					
 					while (la.kind == 12) {
 						lexer.NextToken();
 						Expr(
-#line  2542 "VBNET.ATG" 
+#line  2545 "VBNET.ATG" 
 out nextExpr);
 
-#line  2542 "VBNET.ATG" 
+#line  2545 "VBNET.ATG" 
 						nextExpressions.Add(nextExpr); 
 					}
 				}
 
-#line  2545 "VBNET.ATG" 
+#line  2548 "VBNET.ATG" 
 				statement = new ForNextStatement(typeReference, typeName, start, end, step, embeddedStatement, nextExpressions);
 				SetParent(nextExpressions, statement);
 				
@@ -5504,29 +5518,29 @@ out nextExpr);
 		case 99: {
 			lexer.NextToken();
 			Expr(
-#line  2550 "VBNET.ATG" 
+#line  2553 "VBNET.ATG" 
 out expr);
 
-#line  2550 "VBNET.ATG" 
+#line  2553 "VBNET.ATG" 
 			statement = new ErrorStatement(expr); 
 			break;
 		}
 		case 165: {
 			lexer.NextToken();
 
-#line  2552 "VBNET.ATG" 
+#line  2555 "VBNET.ATG" 
 			bool isPreserve = false; 
 			if (la.kind == 158) {
 				lexer.NextToken();
 
-#line  2552 "VBNET.ATG" 
+#line  2555 "VBNET.ATG" 
 				isPreserve = true; 
 			}
 			ReDimClause(
-#line  2553 "VBNET.ATG" 
+#line  2556 "VBNET.ATG" 
 out expr);
 
-#line  2555 "VBNET.ATG" 
+#line  2558 "VBNET.ATG" 
 			ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
 			statement = reDimStatement;
 			SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
@@ -5534,10 +5548,10 @@ out expr);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				ReDimClause(
-#line  2559 "VBNET.ATG" 
+#line  2562 "VBNET.ATG" 
 out expr);
 
-#line  2560 "VBNET.ATG" 
+#line  2563 "VBNET.ATG" 
 				SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression); 
 			}
 			break;
@@ -5545,41 +5559,41 @@ out expr);
 		case 98: {
 			lexer.NextToken();
 			Expr(
-#line  2564 "VBNET.ATG" 
+#line  2567 "VBNET.ATG" 
 out expr);
 
-#line  2566 "VBNET.ATG" 
+#line  2569 "VBNET.ATG" 
 			EraseStatement eraseStatement = new EraseStatement();
 			if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr);}
 			
 			while (la.kind == 12) {
 				lexer.NextToken();
 				Expr(
-#line  2569 "VBNET.ATG" 
+#line  2572 "VBNET.ATG" 
 out expr);
 
-#line  2569 "VBNET.ATG" 
+#line  2572 "VBNET.ATG" 
 				if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr); }
 			}
 
-#line  2570 "VBNET.ATG" 
+#line  2573 "VBNET.ATG" 
 			statement = eraseStatement; 
 			break;
 		}
 		case 179: {
 			lexer.NextToken();
 
-#line  2572 "VBNET.ATG" 
+#line  2575 "VBNET.ATG" 
 			statement = new StopStatement(); 
 			break;
 		}
 		case 114: {
 			lexer.NextToken();
 
-#line  2574 "VBNET.ATG" 
+#line  2577 "VBNET.ATG" 
 			Location ifStartLocation = t.Location; 
 			Expr(
-#line  2574 "VBNET.ATG" 
+#line  2577 "VBNET.ATG" 
 out expr);
 			if (la.kind == 186) {
 				lexer.NextToken();
@@ -5587,46 +5601,46 @@ out expr);
 			if (la.kind == 1 || la.kind == 11) {
 				EndOfStmt();
 				Block(
-#line  2577 "VBNET.ATG" 
+#line  2580 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2579 "VBNET.ATG" 
+#line  2582 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
 				ifStatement.StartLocation = ifStartLocation;
 				Location elseIfStart;
 				
 				while (la.kind == 94 || 
-#line  2585 "VBNET.ATG" 
+#line  2588 "VBNET.ATG" 
 IsElseIf()) {
 					if (
-#line  2585 "VBNET.ATG" 
+#line  2588 "VBNET.ATG" 
 IsElseIf()) {
 						Expect(93);
 
-#line  2585 "VBNET.ATG" 
+#line  2588 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 						Expect(114);
 					} else {
 						lexer.NextToken();
 
-#line  2586 "VBNET.ATG" 
+#line  2589 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 					}
 
-#line  2588 "VBNET.ATG" 
+#line  2591 "VBNET.ATG" 
 					Expression condition = null; Statement block = null; 
 					Expr(
-#line  2589 "VBNET.ATG" 
+#line  2592 "VBNET.ATG" 
 out condition);
 					if (la.kind == 186) {
 						lexer.NextToken();
 					}
 					EndOfStmt();
 					Block(
-#line  2590 "VBNET.ATG" 
+#line  2593 "VBNET.ATG" 
 out block);
 
-#line  2592 "VBNET.ATG" 
+#line  2595 "VBNET.ATG" 
 					ElseIfSection elseIfSection = new ElseIfSection(condition, block);
 					elseIfSection.StartLocation = elseIfStart;
 					elseIfSection.EndLocation = t.Location;
@@ -5638,43 +5652,43 @@ out block);
 					lexer.NextToken();
 					EndOfStmt();
 					Block(
-#line  2601 "VBNET.ATG" 
+#line  2604 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2603 "VBNET.ATG" 
+#line  2606 "VBNET.ATG" 
 					ifStatement.FalseStatement.Add(embeddedStatement);
 					
 				}
 				Expect(95);
 				Expect(114);
 
-#line  2607 "VBNET.ATG" 
+#line  2610 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location;
 				statement = ifStatement;
 				
 			} else if (StartOf(38)) {
 
-#line  2612 "VBNET.ATG" 
+#line  2615 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr);
 				ifStatement.StartLocation = ifStartLocation;
 				
 				SingleLineStatementList(
-#line  2615 "VBNET.ATG" 
+#line  2618 "VBNET.ATG" 
 ifStatement.TrueStatement);
 
-#line  2617 "VBNET.ATG" 
+#line  2620 "VBNET.ATG" 
 				SetParent(ifStatement.TrueStatement, ifStatement);
 				
 				if (la.kind == 93) {
 					lexer.NextToken();
 					if (StartOf(38)) {
 						SingleLineStatementList(
-#line  2621 "VBNET.ATG" 
+#line  2624 "VBNET.ATG" 
 ifStatement.FalseStatement);
 					}
 				}
 
-#line  2623 "VBNET.ATG" 
+#line  2626 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location; statement = ifStatement; 
 			} else SynErr(258);
 			break;
@@ -5685,46 +5699,46 @@ ifStatement.FalseStatement);
 				lexer.NextToken();
 			}
 			Expr(
-#line  2626 "VBNET.ATG" 
+#line  2629 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 
-#line  2627 "VBNET.ATG" 
+#line  2630 "VBNET.ATG" 
 			List<SwitchSection> selectSections = new List<SwitchSection>();
 			Statement block = null;
 			
 			while (la.kind == 58) {
 
-#line  2631 "VBNET.ATG" 
+#line  2634 "VBNET.ATG" 
 				List<CaseLabel> caseClauses = null; Location caseLocation = la.Location; 
 				lexer.NextToken();
 				CaseClauses(
-#line  2632 "VBNET.ATG" 
+#line  2635 "VBNET.ATG" 
 out caseClauses);
 				if (
-#line  2632 "VBNET.ATG" 
+#line  2635 "VBNET.ATG" 
 IsNotStatementSeparator()) {
 					lexer.NextToken();
 				}
 				EndOfStmt();
 
-#line  2634 "VBNET.ATG" 
+#line  2637 "VBNET.ATG" 
 				SwitchSection selectSection = new SwitchSection(caseClauses);
 				SetParent(caseClauses, selectSection);
 				selectSection.StartLocation = caseLocation;
 				
 				Block(
-#line  2638 "VBNET.ATG" 
+#line  2641 "VBNET.ATG" 
 out block);
 
-#line  2640 "VBNET.ATG" 
+#line  2643 "VBNET.ATG" 
 				selectSection.Children = block.Children;
 				selectSection.EndLocation = t.EndLocation;
 				selectSections.Add(selectSection);
 				
 			}
 
-#line  2646 "VBNET.ATG" 
+#line  2649 "VBNET.ATG" 
 			statement = new SwitchStatement(expr, selectSections);
 			SetParent(selectSections, statement);
 			
@@ -5734,43 +5748,43 @@ out block);
 		}
 		case 147: {
 
-#line  2650 "VBNET.ATG" 
+#line  2653 "VBNET.ATG" 
 			OnErrorStatement onErrorStatement = null; 
 			OnErrorStatement(
-#line  2651 "VBNET.ATG" 
+#line  2654 "VBNET.ATG" 
 out onErrorStatement);
 
-#line  2651 "VBNET.ATG" 
+#line  2654 "VBNET.ATG" 
 			statement = onErrorStatement; 
 			break;
 		}
 		case 112: {
 
-#line  2652 "VBNET.ATG" 
+#line  2655 "VBNET.ATG" 
 			GotoStatement goToStatement = null; 
 			GotoStatement(
-#line  2653 "VBNET.ATG" 
+#line  2656 "VBNET.ATG" 
 out goToStatement);
 
-#line  2653 "VBNET.ATG" 
+#line  2656 "VBNET.ATG" 
 			statement = goToStatement; 
 			break;
 		}
 		case 168: {
 
-#line  2654 "VBNET.ATG" 
+#line  2657 "VBNET.ATG" 
 			ResumeStatement resumeStatement = null; 
 			ResumeStatement(
-#line  2655 "VBNET.ATG" 
+#line  2658 "VBNET.ATG" 
 out resumeStatement);
 
-#line  2655 "VBNET.ATG" 
+#line  2658 "VBNET.ATG" 
 			statement = resumeStatement; 
 			break;
 		}
 		case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 16: case 25: case 44: case 48: case 50: case 51: case 52: case 53: case 55: case 60: case 61: case 62: case 63: case 64: case 65: case 66: case 67: case 69: case 70: case 71: case 74: case 75: case 76: case 77: case 78: case 79: case 80: case 81: case 82: case 83: case 84: case 89: case 91: case 102: case 103: case 109: case 110: case 120: case 127: case 129: case 134: case 135: case 138: case 141: case 144: case 146: case 158: case 170: case 175: case 176: case 181: case 185: case 189: case 191: case 192: case 193: case 194: case 195: case 196: case 197: {
 
-#line  2658 "VBNET.ATG" 
+#line  2661 "VBNET.ATG" 
 			Expression val = null;
 			AssignmentOperatorType op;
 			
@@ -5778,25 +5792,25 @@ out resumeStatement);
 			                        la.kind == Tokens.Not   || la.kind == Tokens.Times;
 			
 			SimpleExpr(
-#line  2664 "VBNET.ATG" 
+#line  2667 "VBNET.ATG" 
 out expr);
 			if (StartOf(39)) {
 				AssignmentOperator(
-#line  2666 "VBNET.ATG" 
+#line  2669 "VBNET.ATG" 
 out op);
 				Expr(
-#line  2666 "VBNET.ATG" 
+#line  2669 "VBNET.ATG" 
 out val);
 
-#line  2666 "VBNET.ATG" 
+#line  2669 "VBNET.ATG" 
 				expr = new AssignmentExpression(expr, op, val); 
 			} else if (la.kind == 1 || la.kind == 11 || la.kind == 93) {
 
-#line  2667 "VBNET.ATG" 
+#line  2670 "VBNET.ATG" 
 				if (mustBeAssignment) Error("error in assignment."); 
 			} else SynErr(259);
 
-#line  2670 "VBNET.ATG" 
+#line  2673 "VBNET.ATG" 
 			// a field reference expression that stands alone is a
 			// invocation expression without parantheses and arguments
 			if(expr is MemberReferenceExpression || expr is IdentifierExpression) {
@@ -5809,50 +5823,50 @@ out val);
 		case 57: {
 			lexer.NextToken();
 			SimpleExpr(
-#line  2677 "VBNET.ATG" 
+#line  2680 "VBNET.ATG" 
 out expr);
 
-#line  2677 "VBNET.ATG" 
+#line  2680 "VBNET.ATG" 
 			statement = new ExpressionStatement(expr); 
 			break;
 		}
 		case 198: {
 			lexer.NextToken();
 
-#line  2679 "VBNET.ATG" 
+#line  2682 "VBNET.ATG" 
 			Statement block;  
 			if (
-#line  2680 "VBNET.ATG" 
+#line  2683 "VBNET.ATG" 
 Peek(1).kind == Tokens.As) {
 
-#line  2681 "VBNET.ATG" 
+#line  2684 "VBNET.ATG" 
 				LocalVariableDeclaration resourceAquisition = new LocalVariableDeclaration(Modifiers.None); 
 				VariableDeclarator(
-#line  2682 "VBNET.ATG" 
+#line  2685 "VBNET.ATG" 
 resourceAquisition.Variables);
 				while (la.kind == 12) {
 					lexer.NextToken();
 					VariableDeclarator(
-#line  2684 "VBNET.ATG" 
+#line  2687 "VBNET.ATG" 
 resourceAquisition.Variables);
 				}
 				Block(
-#line  2686 "VBNET.ATG" 
+#line  2689 "VBNET.ATG" 
 out block);
 
-#line  2688 "VBNET.ATG" 
+#line  2691 "VBNET.ATG" 
 				statement = new UsingStatement(resourceAquisition, block);
 				SetParent(resourceAquisition.Variables, resourceAquisition);
 				
 			} else if (StartOf(27)) {
 				Expr(
-#line  2691 "VBNET.ATG" 
+#line  2694 "VBNET.ATG" 
 out expr);
 				Block(
-#line  2692 "VBNET.ATG" 
+#line  2695 "VBNET.ATG" 
 out block);
 
-#line  2693 "VBNET.ATG" 
+#line  2696 "VBNET.ATG" 
 				statement = new UsingStatement(new ExpressionStatement(expr), block); 
 			} else SynErr(260);
 			Expect(95);
@@ -5864,10 +5878,10 @@ out block);
 	}
 
 	void LocalDeclarationStatement(
-#line  2384 "VBNET.ATG" 
+#line  2387 "VBNET.ATG" 
 out Statement statement) {
 
-#line  2386 "VBNET.ATG" 
+#line  2389 "VBNET.ATG" 
 		ModifierList m = new ModifierList();
 		LocalVariableDeclaration localVariableDeclaration;
 		bool dimfound = false;
@@ -5876,22 +5890,22 @@ out Statement statement) {
 			if (la.kind == 72) {
 				lexer.NextToken();
 
-#line  2392 "VBNET.ATG" 
+#line  2395 "VBNET.ATG" 
 				m.Add(Modifiers.Const, t.Location); 
 			} else if (la.kind == 177) {
 				lexer.NextToken();
 
-#line  2393 "VBNET.ATG" 
+#line  2396 "VBNET.ATG" 
 				m.Add(Modifiers.Static, t.Location); 
 			} else {
 				lexer.NextToken();
 
-#line  2394 "VBNET.ATG" 
+#line  2397 "VBNET.ATG" 
 				dimfound = true; 
 			}
 		}
 
-#line  2397 "VBNET.ATG" 
+#line  2400 "VBNET.ATG" 
 		if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
 		Error("Dim is not allowed on constants.");
 		}
@@ -5904,136 +5918,136 @@ out Statement statement) {
 		localVariableDeclaration.StartLocation = t.Location;
 		
 		VariableDeclarator(
-#line  2408 "VBNET.ATG" 
+#line  2411 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		while (la.kind == 12) {
 			lexer.NextToken();
 			VariableDeclarator(
-#line  2409 "VBNET.ATG" 
+#line  2412 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		}
 
-#line  2411 "VBNET.ATG" 
+#line  2414 "VBNET.ATG" 
 		SetParent(localVariableDeclaration.Variables, localVariableDeclaration);
 		statement = localVariableDeclaration;
 		
 	}
 
 	void TryStatement(
-#line  2897 "VBNET.ATG" 
+#line  2900 "VBNET.ATG" 
 out Statement tryStatement) {
 
-#line  2899 "VBNET.ATG" 
+#line  2902 "VBNET.ATG" 
 		Statement blockStmt = null, finallyStmt = null;List<CatchClause> catchClauses = null;
 		
 		Expect(190);
 		EndOfStmt();
 		Block(
-#line  2902 "VBNET.ATG" 
+#line  2905 "VBNET.ATG" 
 out blockStmt);
 		if (la.kind == 59 || la.kind == 95 || la.kind == 104) {
 			CatchClauses(
-#line  2903 "VBNET.ATG" 
+#line  2906 "VBNET.ATG" 
 out catchClauses);
 		}
 		if (la.kind == 104) {
 			lexer.NextToken();
 			EndOfStmt();
 			Block(
-#line  2904 "VBNET.ATG" 
+#line  2907 "VBNET.ATG" 
 out finallyStmt);
 		}
 		Expect(95);
 		Expect(190);
 
-#line  2907 "VBNET.ATG" 
+#line  2910 "VBNET.ATG" 
 		tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
 		
 	}
 
 	void WithStatement(
-#line  2877 "VBNET.ATG" 
+#line  2880 "VBNET.ATG" 
 out Statement withStatement) {
 
-#line  2879 "VBNET.ATG" 
+#line  2882 "VBNET.ATG" 
 		Statement blockStmt = null;
 		Expression expr = null;
 		
 		Expect(204);
 
-#line  2882 "VBNET.ATG" 
+#line  2885 "VBNET.ATG" 
 		Location start = t.Location; 
 		Expr(
-#line  2883 "VBNET.ATG" 
+#line  2886 "VBNET.ATG" 
 out expr);
 		EndOfStmt();
 
-#line  2885 "VBNET.ATG" 
+#line  2888 "VBNET.ATG" 
 		withStatement = new WithStatement(expr);
 		withStatement.StartLocation = start;
 		
 		Block(
-#line  2888 "VBNET.ATG" 
+#line  2891 "VBNET.ATG" 
 out blockStmt);
 
-#line  2890 "VBNET.ATG" 
+#line  2893 "VBNET.ATG" 
 		((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
 		
 		Expect(95);
 		Expect(204);
 
-#line  2893 "VBNET.ATG" 
+#line  2896 "VBNET.ATG" 
 		withStatement.EndLocation = t.Location; 
 	}
 
 	void WhileOrUntil(
-#line  2870 "VBNET.ATG" 
+#line  2873 "VBNET.ATG" 
 out ConditionType conditionType) {
 
-#line  2871 "VBNET.ATG" 
+#line  2874 "VBNET.ATG" 
 		conditionType = ConditionType.None; 
 		if (la.kind == 202) {
 			lexer.NextToken();
 
-#line  2872 "VBNET.ATG" 
+#line  2875 "VBNET.ATG" 
 			conditionType = ConditionType.While; 
 		} else if (la.kind == 196) {
 			lexer.NextToken();
 
-#line  2873 "VBNET.ATG" 
+#line  2876 "VBNET.ATG" 
 			conditionType = ConditionType.Until; 
 		} else SynErr(262);
 	}
 
 	void LoopControlVariable(
-#line  2712 "VBNET.ATG" 
+#line  2715 "VBNET.ATG" 
 out TypeReference type, out string name) {
 
-#line  2713 "VBNET.ATG" 
+#line  2716 "VBNET.ATG" 
 		ArrayList arrayModifiers = null;
 		type = null;
 		
 		Qualident(
-#line  2717 "VBNET.ATG" 
+#line  2720 "VBNET.ATG" 
 out name);
 		if (
-#line  2718 "VBNET.ATG" 
+#line  2721 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  2718 "VBNET.ATG" 
+#line  2721 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 49) {
 			lexer.NextToken();
 			TypeName(
-#line  2719 "VBNET.ATG" 
+#line  2722 "VBNET.ATG" 
 out type);
 
-#line  2719 "VBNET.ATG" 
+#line  2722 "VBNET.ATG" 
 			if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } 
 		}
 
-#line  2721 "VBNET.ATG" 
+#line  2724 "VBNET.ATG" 
 		if (type != null) {
 		if(type.RankSpecifier != null && arrayModifiers != null) {
 			Error("array rank only allowed one time");
@@ -6045,34 +6059,34 @@ out type);
 	}
 
 	void ReDimClause(
-#line  2791 "VBNET.ATG" 
+#line  2794 "VBNET.ATG" 
 out Expression expr) {
 		SimpleNonInvocationExpression(
-#line  2793 "VBNET.ATG" 
+#line  2796 "VBNET.ATG" 
 out expr);
 		ReDimClauseInternal(
-#line  2794 "VBNET.ATG" 
+#line  2797 "VBNET.ATG" 
 ref expr);
 	}
 
 	void SingleLineStatementList(
-#line  2698 "VBNET.ATG" 
+#line  2701 "VBNET.ATG" 
 List<Statement> list) {
 
-#line  2699 "VBNET.ATG" 
+#line  2702 "VBNET.ATG" 
 		Statement embeddedStatement = null; 
 		if (la.kind == 95) {
 			lexer.NextToken();
 
-#line  2701 "VBNET.ATG" 
+#line  2704 "VBNET.ATG" 
 			embeddedStatement = new EndStatement(); 
 		} else if (StartOf(35)) {
 			EmbeddedStatement(
-#line  2702 "VBNET.ATG" 
+#line  2705 "VBNET.ATG" 
 out embeddedStatement);
 		} else SynErr(263);
 
-#line  2703 "VBNET.ATG" 
+#line  2706 "VBNET.ATG" 
 		if (embeddedStatement != null) list.Add(embeddedStatement); 
 		while (la.kind == 11) {
 			lexer.NextToken();
@@ -6082,62 +6096,62 @@ out embeddedStatement);
 			if (la.kind == 95) {
 				lexer.NextToken();
 
-#line  2705 "VBNET.ATG" 
+#line  2708 "VBNET.ATG" 
 				embeddedStatement = new EndStatement(); 
 			} else if (StartOf(35)) {
 				EmbeddedStatement(
-#line  2706 "VBNET.ATG" 
+#line  2709 "VBNET.ATG" 
 out embeddedStatement);
 			} else SynErr(264);
 
-#line  2707 "VBNET.ATG" 
+#line  2710 "VBNET.ATG" 
 			if (embeddedStatement != null) list.Add(embeddedStatement); 
 		}
 	}
 
 	void CaseClauses(
-#line  2830 "VBNET.ATG" 
+#line  2833 "VBNET.ATG" 
 out List<CaseLabel> caseClauses) {
 
-#line  2832 "VBNET.ATG" 
+#line  2835 "VBNET.ATG" 
 		caseClauses = new List<CaseLabel>();
 		CaseLabel caseClause = null;
 		
 		CaseClause(
-#line  2835 "VBNET.ATG" 
+#line  2838 "VBNET.ATG" 
 out caseClause);
 
-#line  2835 "VBNET.ATG" 
+#line  2838 "VBNET.ATG" 
 		if (caseClause != null) { caseClauses.Add(caseClause); } 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			CaseClause(
-#line  2836 "VBNET.ATG" 
+#line  2839 "VBNET.ATG" 
 out caseClause);
 
-#line  2836 "VBNET.ATG" 
+#line  2839 "VBNET.ATG" 
 			if (caseClause != null) { caseClauses.Add(caseClause); } 
 		}
 	}
 
 	void OnErrorStatement(
-#line  2732 "VBNET.ATG" 
+#line  2735 "VBNET.ATG" 
 out OnErrorStatement stmt) {
 
-#line  2734 "VBNET.ATG" 
+#line  2737 "VBNET.ATG" 
 		stmt = null;
 		GotoStatement goToStatement = null;
 		
 		Expect(147);
 		Expect(99);
 		if (
-#line  2740 "VBNET.ATG" 
+#line  2743 "VBNET.ATG" 
 IsNegativeLabelName()) {
 			Expect(112);
 			Expect(18);
 			Expect(5);
 
-#line  2742 "VBNET.ATG" 
+#line  2745 "VBNET.ATG" 
 			long intLabel = Int64.Parse(t.val);
 			if(intLabel != 1) {
 				Error("invalid label in on error statement.");
@@ -6146,10 +6160,10 @@ IsNegativeLabelName()) {
 			
 		} else if (la.kind == 112) {
 			GotoStatement(
-#line  2748 "VBNET.ATG" 
+#line  2751 "VBNET.ATG" 
 out goToStatement);
 
-#line  2750 "VBNET.ATG" 
+#line  2753 "VBNET.ATG" 
 			string val = goToStatement.Label;
 			
 			// if value is numeric, make sure that is 0
@@ -6166,88 +6180,88 @@ out goToStatement);
 			lexer.NextToken();
 			Expect(139);
 
-#line  2764 "VBNET.ATG" 
+#line  2767 "VBNET.ATG" 
 			stmt = new OnErrorStatement(new ResumeStatement(true));
 			
 		} else SynErr(265);
 	}
 
 	void GotoStatement(
-#line  2770 "VBNET.ATG" 
+#line  2773 "VBNET.ATG" 
 out GotoStatement goToStatement) {
 
-#line  2772 "VBNET.ATG" 
+#line  2775 "VBNET.ATG" 
 		string label = String.Empty;
 		
 		Expect(112);
 		LabelName(
-#line  2775 "VBNET.ATG" 
+#line  2778 "VBNET.ATG" 
 out label);
 
-#line  2777 "VBNET.ATG" 
+#line  2780 "VBNET.ATG" 
 		goToStatement = new GotoStatement(label);
 		
 	}
 
 	void ResumeStatement(
-#line  2819 "VBNET.ATG" 
+#line  2822 "VBNET.ATG" 
 out ResumeStatement resumeStatement) {
 
-#line  2821 "VBNET.ATG" 
+#line  2824 "VBNET.ATG" 
 		resumeStatement = null;
 		string label = String.Empty;
 		
 		if (
-#line  2824 "VBNET.ATG" 
+#line  2827 "VBNET.ATG" 
 IsResumeNext()) {
 			Expect(168);
 			Expect(139);
 
-#line  2825 "VBNET.ATG" 
+#line  2828 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(true); 
 		} else if (la.kind == 168) {
 			lexer.NextToken();
 			if (StartOf(40)) {
 				LabelName(
-#line  2826 "VBNET.ATG" 
+#line  2829 "VBNET.ATG" 
 out label);
 			}
 
-#line  2826 "VBNET.ATG" 
+#line  2829 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(label); 
 		} else SynErr(266);
 	}
 
 	void ReDimClauseInternal(
-#line  2797 "VBNET.ATG" 
+#line  2800 "VBNET.ATG" 
 ref Expression expr) {
 
-#line  2798 "VBNET.ATG" 
+#line  2801 "VBNET.ATG" 
 		List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; 
 		while (la.kind == 16 || 
-#line  2801 "VBNET.ATG" 
+#line  2804 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			if (la.kind == 16) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  2800 "VBNET.ATG" 
+#line  2803 "VBNET.ATG" 
 out name);
 
-#line  2800 "VBNET.ATG" 
+#line  2803 "VBNET.ATG" 
 				expr = new MemberReferenceExpression(expr, name); 
 			} else {
 				InvocationExpression(
-#line  2802 "VBNET.ATG" 
+#line  2805 "VBNET.ATG" 
 ref expr);
 			}
 		}
 		Expect(25);
 		NormalOrReDimArgumentList(
-#line  2805 "VBNET.ATG" 
+#line  2808 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeRedim);
 		Expect(26);
 
-#line  2807 "VBNET.ATG" 
+#line  2810 "VBNET.ATG" 
 		expr = new InvocationExpression(expr, arguments);
 		SetParent(arguments, expr);
 		if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
@@ -6260,10 +6274,10 @@ out arguments, out canBeNormal, out canBeRedim);
 	}
 
 	void CaseClause(
-#line  2840 "VBNET.ATG" 
+#line  2843 "VBNET.ATG" 
 out CaseLabel caseClause) {
 
-#line  2842 "VBNET.ATG" 
+#line  2845 "VBNET.ATG" 
 		Expression expr = null;
 		Expression sexpr = null;
 		BinaryOperatorType op = BinaryOperatorType.None;
@@ -6272,7 +6286,7 @@ out CaseLabel caseClause) {
 		if (la.kind == 93) {
 			lexer.NextToken();
 
-#line  2848 "VBNET.ATG" 
+#line  2851 "VBNET.ATG" 
 			caseClause = new CaseLabel(); 
 		} else if (StartOf(41)) {
 			if (la.kind == 122) {
@@ -6282,76 +6296,76 @@ out CaseLabel caseClause) {
 			case 28: {
 				lexer.NextToken();
 
-#line  2852 "VBNET.ATG" 
+#line  2855 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 27: {
 				lexer.NextToken();
 
-#line  2853 "VBNET.ATG" 
+#line  2856 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 31: {
 				lexer.NextToken();
 
-#line  2854 "VBNET.ATG" 
+#line  2857 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 30: {
 				lexer.NextToken();
 
-#line  2855 "VBNET.ATG" 
+#line  2858 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 10: {
 				lexer.NextToken();
 
-#line  2856 "VBNET.ATG" 
+#line  2859 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 29: {
 				lexer.NextToken();
 
-#line  2857 "VBNET.ATG" 
+#line  2860 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			default: SynErr(267); break;
 			}
 			Expr(
-#line  2859 "VBNET.ATG" 
+#line  2862 "VBNET.ATG" 
 out expr);
 
-#line  2861 "VBNET.ATG" 
+#line  2864 "VBNET.ATG" 
 			caseClause = new CaseLabel(op, expr);
 			
 		} else if (StartOf(27)) {
 			Expr(
-#line  2863 "VBNET.ATG" 
+#line  2866 "VBNET.ATG" 
 out expr);
 			if (la.kind == 188) {
 				lexer.NextToken();
 				Expr(
-#line  2863 "VBNET.ATG" 
+#line  2866 "VBNET.ATG" 
 out sexpr);
 			}
 
-#line  2865 "VBNET.ATG" 
+#line  2868 "VBNET.ATG" 
 			caseClause = new CaseLabel(expr, sexpr);
 			
 		} else SynErr(268);
 	}
 
 	void CatchClauses(
-#line  2912 "VBNET.ATG" 
+#line  2915 "VBNET.ATG" 
 out List<CatchClause> catchClauses) {
 
-#line  2914 "VBNET.ATG" 
+#line  2917 "VBNET.ATG" 
 		catchClauses = new List<CatchClause>();
 		TypeReference type = null;
 		Statement blockStmt = null;
@@ -6363,27 +6377,27 @@ out List<CatchClause> catchClauses) {
 			if (StartOf(13)) {
 				Identifier();
 
-#line  2922 "VBNET.ATG" 
+#line  2925 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 49) {
 					lexer.NextToken();
 					TypeName(
-#line  2922 "VBNET.ATG" 
+#line  2925 "VBNET.ATG" 
 out type);
 				}
 			}
 			if (la.kind == 201) {
 				lexer.NextToken();
 				Expr(
-#line  2923 "VBNET.ATG" 
+#line  2926 "VBNET.ATG" 
 out expr);
 			}
 			EndOfStmt();
 			Block(
-#line  2925 "VBNET.ATG" 
+#line  2928 "VBNET.ATG" 
 out blockStmt);
 
-#line  2926 "VBNET.ATG" 
+#line  2929 "VBNET.ATG" 
 			catchClauses.Add(new CatchClause(type, name, blockStmt, expr)); 
 		}
 	}
@@ -6688,7 +6702,7 @@ out blockStmt);
 	{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, T,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x},
 	{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, T,T,x,T, x,x,x,x, x,x,x,x, x,x,T,x, T,x,x,T, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,T, T,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x},
 	{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, T,T,x,T, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,T,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, x,T,T,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x},
-	{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,T, T,x,x,x, x,x,x,x, x,x,T,x, x,T,T,T, T,x,x,x, x,x,x,x, x,T,x,x, T,x,T,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,T, T,T,x,x, x,T,x,x, x,x,T,T, x,x,T,x, T,x,x,x, x,T,T,T, x,T,T,T, T,T,T,x, T,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,T, x,T,T,x, x,x},
+	{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,T, T,x,x,x, x,x,x,x, x,x,T,x, x,T,T,T, T,x,x,x, x,x,x,x, x,T,x,x, T,x,T,x, x,x,T,T, x,x,x,x, x,x,x,x, x,x,T,x, x,T,x,x, x,x,x,x, x,x,x,T, T,T,x,x, x,T,x,x, x,x,T,T, x,x,T,x, T,x,x,x, x,T,T,T, x,T,T,T, T,T,T,x, T,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,T,T, x,T,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,T, x,T,T,x, x,x},
 	{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,T,x,x, x,x,x,x, x,x,T,T, x,x,x,x, x,x,x,x, x,T,T,T, x,T,x,T, x,T,T,x, T,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,x},
 	{x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,T,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, x,x},
 	{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,x,T, T,x,x,x, x,T,x,x, x,x,x,x, x,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, x,x,x,x, x,x},
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
index 3172ea8437..31cfd99aba 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
@@ -253,6 +253,9 @@ OptionStmt (. INode node = null; bool val = true; .) =
 		"Compare" ( "Binary" (. node = new OptionDeclaration(OptionType.CompareBinary, val); .)
 				  | "Text" (. node = new OptionDeclaration(OptionType.CompareText, val); .)
 				  )
+		|
+		"Infer" [ OptionValue<ref val> ]
+		(. node = new OptionDeclaration(OptionType.Infer, val); .)
 	)
 	EndOfStmt
 	(.
@@ -2962,7 +2965,6 @@ IdentifierForFieldDeclaration =
 	| "Text"
 	| "Binary"
 	| "Compare"
-	/*| "Custom" Custom is not valid for field declaration */
 	| "Assembly"
 	| "Ansi"
 	| "Auto"
@@ -2971,6 +2973,7 @@ IdentifierForFieldDeclaration =
 	| "Until"
 	| "Off"
 	| "Explicit"
+	| "Infer"
 .
 
 /* 2.2 */
diff --git a/src/Libraries/NRefactory/Test/Parser/GlobalScope/OptionDeclarationTests.cs b/src/Libraries/NRefactory/Test/Parser/GlobalScope/OptionDeclarationTests.cs
index 701954b341..eefd7da219 100644
--- a/src/Libraries/NRefactory/Test/Parser/GlobalScope/OptionDeclarationTests.cs
+++ b/src/Libraries/NRefactory/Test/Parser/GlobalScope/OptionDeclarationTests.cs
@@ -51,6 +51,33 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual(OptionType.CompareText, opDec.OptionType);
 			Assert.IsTrue(opDec.OptionValue);
 		}
+
+		[Test]
+		public void VBNetInferOnOptionDeclarationTest()
+		{
+			string program = "Option Infer On\n";
+			OptionDeclaration opDec = ParseUtilVBNet.ParseGlobal<OptionDeclaration>(program);
+			Assert.AreEqual(OptionType.Infer, opDec.OptionType);
+			Assert.IsTrue(opDec.OptionValue);
+		}
+
+		[Test]
+		public void VBNetInferOffOptionDeclarationTest()
+		{
+			string program = "Option Infer\n";
+			OptionDeclaration opDec = ParseUtilVBNet.ParseGlobal<OptionDeclaration>(program);
+			Assert.AreEqual(OptionType.Infer, opDec.OptionType);
+			Assert.IsTrue(opDec.OptionValue);
+		}
+		
+		[Test]
+		public void VBNetInferOptionDeclarationTest()
+		{
+			string program = "Option Infer\n";
+			OptionDeclaration opDec = ParseUtilVBNet.ParseGlobal<OptionDeclaration>(program);
+			Assert.AreEqual(OptionType.Infer, opDec.OptionType);
+			Assert.IsTrue(opDec.OptionValue);
+		}
 		
 		[Test]
 		public void VBNetInvalidOptionDeclarationTest()