diff --git a/src/Libraries/NRefactory/Project/Src/Ast/TypeReference.cs b/src/Libraries/NRefactory/Project/Src/Ast/TypeReference.cs
index 862a8ba58a..d9f1f1af40 100644
--- a/src/Libraries/NRefactory/Project/Src/Ast/TypeReference.cs
+++ b/src/Libraries/NRefactory/Project/Src/Ast/TypeReference.cs
@@ -15,6 +15,10 @@ namespace ICSharpCode.NRefactory.Ast
 {
 	public class TypeReference : AbstractNode, INullable, ICloneable
 	{
+		public static readonly TypeReference StructConstraint = new TypeReference("constraint: struct");
+		public static readonly TypeReference ClassConstraint = new TypeReference("constraint: class");
+		public static readonly TypeReference NewConstraint = new TypeReference("constraint: new");
+		
 		string type = "";
 		string systemType = "";
 		int    pointerNestingLevel;
@@ -211,6 +215,8 @@ namespace ICSharpCode.NRefactory.Ast
 		
 		static string GetSystemType(string type)
 		{
+			if (types == null) return type;
+			
 			if (types.ContainsKey(type)) {
 				return types[type];
 			}
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
index 43869d3a5f..121001d54c 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
@@ -5012,19 +5012,19 @@ out TypeReference type) {
 			lexer.NextToken();
 
 #line  2038 "cs.ATG" 
-			type = new TypeReference("struct"); 
+			type = TypeReference.StructConstraint; 
 		} else if (la.kind == 58) {
 			lexer.NextToken();
 
 #line  2039 "cs.ATG" 
-			type = new TypeReference("struct"); 
+			type = TypeReference.ClassConstraint; 
 		} else if (la.kind == 88) {
 			lexer.NextToken();
 			Expect(20);
 			Expect(21);
 
 #line  2040 "cs.ATG" 
-			type = new TypeReference("struct"); 
+			type = TypeReference.NewConstraint; 
 		} else if (StartOf(9)) {
 			Type(
 #line  2041 "cs.ATG" 
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG
index 44f5d38967..26cc543e43 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG
@@ -2035,9 +2035,9 @@ TypeParameterConstraintsClause<List<TemplateDefinition> templates>
 TypeParameterConstraintsClauseBase<out TypeReference type>
 (. TypeReference t; type = null; .)
 =
-	"struct"          (. type = new TypeReference("struct"); .)
-	| "class"         (. type = new TypeReference("struct"); .)
-	| "new" "(" ")"   (. type = new TypeReference("struct"); .)
+	"struct"          (. type = TypeReference.StructConstraint; .)
+	| "class"         (. type = TypeReference.ClassConstraint; .)
+	| "new" "(" ")"   (. type = TypeReference.NewConstraint; .)
 	| Type<out t>     (. type = t; .)
 .
 
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
index 0d88da91c8..92ea2ec992 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
@@ -149,7 +149,7 @@ out u);
 
 	void GlobalAttributeSection() {
 
-#line  2005 "VBNET.ATG" 
+#line  2013 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		Expect(27);
 		if (la.kind == 49) {
@@ -158,20 +158,20 @@ out u);
 			lexer.NextToken();
 		} else SynErr(208);
 
-#line  2007 "VBNET.ATG" 
+#line  2015 "VBNET.ATG" 
 		string attributeTarget = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
 		List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		Expect(13);
 		Attribute(
-#line  2011 "VBNET.ATG" 
+#line  2019 "VBNET.ATG" 
 out attribute);
 
-#line  2011 "VBNET.ATG" 
+#line  2019 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2012 "VBNET.ATG" 
+#line  2020 "VBNET.ATG" 
 NotFinalComma()) {
 			if (la.kind == 12) {
 				lexer.NextToken();
@@ -183,10 +183,10 @@ NotFinalComma()) {
 				Expect(13);
 			}
 			Attribute(
-#line  2012 "VBNET.ATG" 
+#line  2020 "VBNET.ATG" 
 out attribute);
 
-#line  2012 "VBNET.ATG" 
+#line  2020 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 12) {
@@ -195,7 +195,7 @@ out attribute);
 		Expect(26);
 		EndOfStmt();
 
-#line  2017 "VBNET.ATG" 
+#line  2025 "VBNET.ATG" 
 		AttributeSection section = new AttributeSection(attributeTarget, attributes);
 		section.StartLocation = startPos;
 		section.EndLocation = t.EndLocation;
@@ -312,47 +312,47 @@ out aliasedType);
 	}
 
 	void Qualident(
-#line  2722 "VBNET.ATG" 
+#line  2730 "VBNET.ATG" 
 out string qualident) {
 
-#line  2724 "VBNET.ATG" 
+#line  2732 "VBNET.ATG" 
 		string name;
 		qualidentBuilder.Length = 0; 
 		
 		Identifier();
 
-#line  2728 "VBNET.ATG" 
+#line  2736 "VBNET.ATG" 
 		qualidentBuilder.Append(t.val); 
 		while (
-#line  2729 "VBNET.ATG" 
+#line  2737 "VBNET.ATG" 
 DotAndIdentOrKw()) {
 			Expect(10);
 			IdentifierOrKeyword(
-#line  2729 "VBNET.ATG" 
+#line  2737 "VBNET.ATG" 
 out name);
 
-#line  2729 "VBNET.ATG" 
+#line  2737 "VBNET.ATG" 
 			qualidentBuilder.Append('.'); qualidentBuilder.Append(name); 
 		}
 
-#line  2731 "VBNET.ATG" 
+#line  2739 "VBNET.ATG" 
 		qualident = qualidentBuilder.ToString(); 
 	}
 
 	void TypeName(
-#line  1898 "VBNET.ATG" 
+#line  1906 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  1899 "VBNET.ATG" 
+#line  1907 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  1901 "VBNET.ATG" 
+#line  1909 "VBNET.ATG" 
 out typeref, false);
 		ArrayTypeModifiers(
-#line  1902 "VBNET.ATG" 
+#line  1910 "VBNET.ATG" 
 out rank);
 
-#line  1903 "VBNET.ATG" 
+#line  1911 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -369,35 +369,35 @@ out rank);
 	}
 
 	void AttributeSection(
-#line  2075 "VBNET.ATG" 
+#line  2083 "VBNET.ATG" 
 out AttributeSection section) {
 
-#line  2077 "VBNET.ATG" 
+#line  2085 "VBNET.ATG" 
 		string attributeTarget = "";List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		
 		Expect(27);
 
-#line  2081 "VBNET.ATG" 
+#line  2089 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (
-#line  2082 "VBNET.ATG" 
+#line  2090 "VBNET.ATG" 
 IsLocalAttrTarget()) {
 			if (la.kind == 93) {
 				lexer.NextToken();
 
-#line  2083 "VBNET.ATG" 
+#line  2091 "VBNET.ATG" 
 				attributeTarget = "event";
 			} else if (la.kind == 154) {
 				lexer.NextToken();
 
-#line  2084 "VBNET.ATG" 
+#line  2092 "VBNET.ATG" 
 				attributeTarget = "return";
 			} else {
 				Identifier();
 
-#line  2087 "VBNET.ATG" 
+#line  2095 "VBNET.ATG" 
 				string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
 				if (val != "field"	|| val != "method" ||
 					val != "module" || val != "param"  ||
@@ -410,20 +410,20 @@ IsLocalAttrTarget()) {
 			Expect(13);
 		}
 		Attribute(
-#line  2097 "VBNET.ATG" 
+#line  2105 "VBNET.ATG" 
 out attribute);
 
-#line  2097 "VBNET.ATG" 
+#line  2105 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2098 "VBNET.ATG" 
+#line  2106 "VBNET.ATG" 
 NotFinalComma()) {
 			Expect(12);
 			Attribute(
-#line  2098 "VBNET.ATG" 
+#line  2106 "VBNET.ATG" 
 out attribute);
 
-#line  2098 "VBNET.ATG" 
+#line  2106 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 12) {
@@ -431,7 +431,7 @@ out attribute);
 		}
 		Expect(26);
 
-#line  2102 "VBNET.ATG" 
+#line  2110 "VBNET.ATG" 
 		section = new AttributeSection(attributeTarget, attributes);
 		section.StartLocation = startPos;
 		section.EndLocation = t.EndLocation;
@@ -439,69 +439,69 @@ out attribute);
 	}
 
 	void TypeModifier(
-#line  2798 "VBNET.ATG" 
+#line  2806 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 148: {
 			lexer.NextToken();
 
-#line  2799 "VBNET.ATG" 
+#line  2807 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location); 
 			break;
 		}
 		case 147: {
 			lexer.NextToken();
 
-#line  2800 "VBNET.ATG" 
+#line  2808 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location); 
 			break;
 		}
 		case 99: {
 			lexer.NextToken();
 
-#line  2801 "VBNET.ATG" 
+#line  2809 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location); 
 			break;
 		}
 		case 145: {
 			lexer.NextToken();
 
-#line  2802 "VBNET.ATG" 
+#line  2810 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location); 
 			break;
 		}
 		case 158: {
 			lexer.NextToken();
 
-#line  2803 "VBNET.ATG" 
+#line  2811 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location); 
 			break;
 		}
 		case 157: {
 			lexer.NextToken();
 
-#line  2804 "VBNET.ATG" 
+#line  2812 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location); 
 			break;
 		}
 		case 122: {
 			lexer.NextToken();
 
-#line  2805 "VBNET.ATG" 
+#line  2813 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location); 
 			break;
 		}
 		case 131: {
 			lexer.NextToken();
 
-#line  2806 "VBNET.ATG" 
+#line  2814 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location); 
 			break;
 		}
 		case 203: {
 			lexer.NextToken();
 
-#line  2807 "VBNET.ATG" 
+#line  2815 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location); 
 			break;
 		}
@@ -510,21 +510,21 @@ ModifierList m) {
 	}
 
 	void NonModuleDeclaration(
-#line  396 "VBNET.ATG" 
+#line  404 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 
-#line  398 "VBNET.ATG" 
+#line  406 "VBNET.ATG" 
 		TypeReference typeRef = null;
 		List<TypeReference> baseInterfaces = null;
 		
 		switch (la.kind) {
 		case 67: {
 
-#line  401 "VBNET.ATG" 
+#line  409 "VBNET.ATG" 
 			m.Check(Modifiers.Classes); 
 			lexer.NextToken();
 
-#line  404 "VBNET.ATG" 
+#line  412 "VBNET.ATG" 
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = t.Location;
 			compilationUnit.AddChild(newType);
@@ -534,36 +534,36 @@ ModifierList m, List<AttributeSection> attributes) {
 			
 			Identifier();
 
-#line  411 "VBNET.ATG" 
+#line  419 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-#line  412 "VBNET.ATG" 
+#line  420 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-#line  414 "VBNET.ATG" 
+#line  422 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			if (la.kind == 110) {
 				ClassBaseType(
-#line  415 "VBNET.ATG" 
+#line  423 "VBNET.ATG" 
 out typeRef);
 
-#line  415 "VBNET.ATG" 
+#line  423 "VBNET.ATG" 
 				newType.BaseTypes.Add(typeRef); 
 			}
 			while (la.kind == 107) {
 				TypeImplementsClause(
-#line  416 "VBNET.ATG" 
+#line  424 "VBNET.ATG" 
 out baseInterfaces);
 
-#line  416 "VBNET.ATG" 
+#line  424 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces); 
 			}
 			ClassBody(
-#line  417 "VBNET.ATG" 
+#line  425 "VBNET.ATG" 
 newType);
 
-#line  419 "VBNET.ATG" 
+#line  427 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -571,7 +571,7 @@ newType);
 		case 121: {
 			lexer.NextToken();
 
-#line  423 "VBNET.ATG" 
+#line  431 "VBNET.ATG" 
 			m.Check(Modifiers.VBModules);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			compilationUnit.AddChild(newType);
@@ -581,17 +581,17 @@ newType);
 			
 			Identifier();
 
-#line  430 "VBNET.ATG" 
+#line  438 "VBNET.ATG" 
 			newType.Name = t.val; 
 			Expect(1);
 
-#line  432 "VBNET.ATG" 
+#line  440 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			ModuleBody(
-#line  433 "VBNET.ATG" 
+#line  441 "VBNET.ATG" 
 newType);
 
-#line  435 "VBNET.ATG" 
+#line  443 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -599,7 +599,7 @@ newType);
 		case 166: {
 			lexer.NextToken();
 
-#line  439 "VBNET.ATG" 
+#line  447 "VBNET.ATG" 
 			m.Check(Modifiers.VBStructures);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			compilationUnit.AddChild(newType);
@@ -609,28 +609,28 @@ newType);
 			
 			Identifier();
 
-#line  446 "VBNET.ATG" 
+#line  454 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-#line  447 "VBNET.ATG" 
+#line  455 "VBNET.ATG" 
 newType.Templates);
 			Expect(1);
 
-#line  449 "VBNET.ATG" 
+#line  457 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			while (la.kind == 107) {
 				TypeImplementsClause(
-#line  450 "VBNET.ATG" 
+#line  458 "VBNET.ATG" 
 out baseInterfaces);
 
-#line  450 "VBNET.ATG" 
+#line  458 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces);
 			}
 			StructureBody(
-#line  451 "VBNET.ATG" 
+#line  459 "VBNET.ATG" 
 newType);
 
-#line  453 "VBNET.ATG" 
+#line  461 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -638,7 +638,7 @@ newType);
 		case 90: {
 			lexer.NextToken();
 
-#line  458 "VBNET.ATG" 
+#line  466 "VBNET.ATG" 
 			m.Check(Modifiers.VBEnums);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -649,26 +649,26 @@ newType);
 			
 			Identifier();
 
-#line  466 "VBNET.ATG" 
+#line  474 "VBNET.ATG" 
 			newType.Name = t.val; 
 			if (la.kind == 48) {
 				lexer.NextToken();
 				NonArrayTypeName(
-#line  467 "VBNET.ATG" 
+#line  475 "VBNET.ATG" 
 out typeRef, false);
 
-#line  467 "VBNET.ATG" 
+#line  475 "VBNET.ATG" 
 				newType.BaseTypes.Add(typeRef); 
 			}
 			Expect(1);
 
-#line  469 "VBNET.ATG" 
+#line  477 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			EnumBody(
-#line  470 "VBNET.ATG" 
+#line  478 "VBNET.ATG" 
 newType);
 
-#line  472 "VBNET.ATG" 
+#line  480 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -676,7 +676,7 @@ newType);
 		case 112: {
 			lexer.NextToken();
 
-#line  477 "VBNET.ATG" 
+#line  485 "VBNET.ATG" 
 			m.Check(Modifiers.VBInterfacs);
 			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
 			newType.StartLocation = m.GetDeclarationLocation(t.Location);
@@ -686,28 +686,28 @@ newType);
 			
 			Identifier();
 
-#line  484 "VBNET.ATG" 
+#line  492 "VBNET.ATG" 
 			newType.Name = t.val; 
 			TypeParameterList(
-#line  485 "VBNET.ATG" 
+#line  493 "VBNET.ATG" 
 newType.Templates);
 			EndOfStmt();
 
-#line  487 "VBNET.ATG" 
+#line  495 "VBNET.ATG" 
 			newType.BodyStartLocation = t.Location; 
 			while (la.kind == 110) {
 				InterfaceBase(
-#line  488 "VBNET.ATG" 
+#line  496 "VBNET.ATG" 
 out baseInterfaces);
 
-#line  488 "VBNET.ATG" 
+#line  496 "VBNET.ATG" 
 				newType.BaseTypes.AddRange(baseInterfaces); 
 			}
 			InterfaceBody(
-#line  489 "VBNET.ATG" 
+#line  497 "VBNET.ATG" 
 newType);
 
-#line  491 "VBNET.ATG" 
+#line  499 "VBNET.ATG" 
 			compilationUnit.BlockEnd();
 			
 			break;
@@ -715,7 +715,7 @@ newType);
 		case 80: {
 			lexer.NextToken();
 
-#line  496 "VBNET.ATG" 
+#line  504 "VBNET.ATG" 
 			m.Check(Modifiers.VBDelegates);
 			DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes);
 			delegateDeclr.ReturnType = new TypeReference("", "System.Void");
@@ -726,63 +726,63 @@ newType);
 				lexer.NextToken();
 				Identifier();
 
-#line  503 "VBNET.ATG" 
+#line  511 "VBNET.ATG" 
 				delegateDeclr.Name = t.val; 
 				TypeParameterList(
-#line  504 "VBNET.ATG" 
+#line  512 "VBNET.ATG" 
 delegateDeclr.Templates);
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  505 "VBNET.ATG" 
+#line  513 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
 
-#line  505 "VBNET.ATG" 
+#line  513 "VBNET.ATG" 
 					delegateDeclr.Parameters = p; 
 				}
 			} else if (la.kind == 100) {
 				lexer.NextToken();
 				Identifier();
 
-#line  507 "VBNET.ATG" 
+#line  515 "VBNET.ATG" 
 				delegateDeclr.Name = t.val; 
 				TypeParameterList(
-#line  508 "VBNET.ATG" 
+#line  516 "VBNET.ATG" 
 delegateDeclr.Templates);
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  509 "VBNET.ATG" 
+#line  517 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
 
-#line  509 "VBNET.ATG" 
+#line  517 "VBNET.ATG" 
 					delegateDeclr.Parameters = p; 
 				}
 				if (la.kind == 48) {
 					lexer.NextToken();
 
-#line  510 "VBNET.ATG" 
+#line  518 "VBNET.ATG" 
 					TypeReference type; 
 					TypeName(
-#line  510 "VBNET.ATG" 
+#line  518 "VBNET.ATG" 
 out type);
 
-#line  510 "VBNET.ATG" 
+#line  518 "VBNET.ATG" 
 					delegateDeclr.ReturnType = type; 
 				}
 			} else SynErr(214);
 
-#line  512 "VBNET.ATG" 
+#line  520 "VBNET.ATG" 
 			delegateDeclr.EndLocation = t.EndLocation; 
 			Expect(1);
 
-#line  515 "VBNET.ATG" 
+#line  523 "VBNET.ATG" 
 			compilationUnit.AddChild(delegateDeclr);
 			
 			break;
@@ -898,7 +898,7 @@ TemplateDefinition template) {
 		Expect(48);
 		if (la.kind == 22) {
 			lexer.NextToken();
-			TypeName(
+			TypeParameterConstraint(
 #line  385 "VBNET.ATG" 
 out constraint);
 
@@ -906,7 +906,7 @@ out constraint);
 			if (constraint != null) { template.Bases.Add(constraint); } 
 			while (la.kind == 12) {
 				lexer.NextToken();
-				TypeName(
+				TypeParameterConstraint(
 #line  388 "VBNET.ATG" 
 out constraint);
 
@@ -915,7 +915,7 @@ out constraint);
 			}
 			Expect(23);
 		} else if (StartOf(5)) {
-			TypeName(
+			TypeParameterConstraint(
 #line  391 "VBNET.ATG" 
 out constraint);
 
@@ -924,294 +924,322 @@ out constraint);
 		} else SynErr(217);
 	}
 
+	void TypeParameterConstraint(
+#line  395 "VBNET.ATG" 
+out TypeReference constraint) {
+
+#line  396 "VBNET.ATG" 
+		constraint = null; 
+		if (la.kind == 67) {
+			lexer.NextToken();
+
+#line  397 "VBNET.ATG" 
+			constraint = TypeReference.ClassConstraint; 
+		} else if (la.kind == 166) {
+			lexer.NextToken();
+
+#line  398 "VBNET.ATG" 
+			constraint = TypeReference.StructConstraint; 
+		} else if (la.kind == 127) {
+			lexer.NextToken();
+
+#line  399 "VBNET.ATG" 
+			constraint = TypeReference.NewConstraint; 
+		} else if (StartOf(6)) {
+			TypeName(
+#line  400 "VBNET.ATG" 
+out constraint);
+		} else SynErr(218);
+	}
+
 	void ClassBaseType(
-#line  692 "VBNET.ATG" 
+#line  700 "VBNET.ATG" 
 out TypeReference typeRef) {
 
-#line  694 "VBNET.ATG" 
+#line  702 "VBNET.ATG" 
 		typeRef = null;
 		
 		Expect(110);
 		TypeName(
-#line  697 "VBNET.ATG" 
+#line  705 "VBNET.ATG" 
 out typeRef);
 		EndOfStmt();
 	}
 
 	void TypeImplementsClause(
-#line  1470 "VBNET.ATG" 
+#line  1478 "VBNET.ATG" 
 out List<TypeReference> baseInterfaces) {
 
-#line  1472 "VBNET.ATG" 
+#line  1480 "VBNET.ATG" 
 		baseInterfaces = new List<TypeReference>();
 		TypeReference type = null;
 		
 		Expect(107);
 		TypeName(
-#line  1475 "VBNET.ATG" 
+#line  1483 "VBNET.ATG" 
 out type);
 
-#line  1477 "VBNET.ATG" 
+#line  1485 "VBNET.ATG" 
 		baseInterfaces.Add(type);
 		
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  1480 "VBNET.ATG" 
+#line  1488 "VBNET.ATG" 
 out type);
 
-#line  1481 "VBNET.ATG" 
+#line  1489 "VBNET.ATG" 
 			baseInterfaces.Add(type); 
 		}
 		EndOfStmt();
 	}
 
 	void ClassBody(
-#line  525 "VBNET.ATG" 
+#line  533 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  526 "VBNET.ATG" 
+#line  534 "VBNET.ATG" 
 		AttributeSection section; 
-		while (StartOf(6)) {
+		while (StartOf(7)) {
 
-#line  528 "VBNET.ATG" 
+#line  536 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 27) {
 				AttributeSection(
-#line  531 "VBNET.ATG" 
+#line  539 "VBNET.ATG" 
 out section);
 
-#line  531 "VBNET.ATG" 
+#line  539 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
-			while (StartOf(7)) {
+			while (StartOf(8)) {
 				MemberModifier(
-#line  532 "VBNET.ATG" 
+#line  540 "VBNET.ATG" 
 m);
 			}
 			ClassMemberDecl(
-#line  533 "VBNET.ATG" 
+#line  541 "VBNET.ATG" 
 m, attributes);
 		}
 		Expect(88);
 		Expect(67);
 
-#line  535 "VBNET.ATG" 
+#line  543 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		Expect(1);
 	}
 
 	void ModuleBody(
-#line  554 "VBNET.ATG" 
+#line  562 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  555 "VBNET.ATG" 
+#line  563 "VBNET.ATG" 
 		AttributeSection section; 
-		while (StartOf(6)) {
+		while (StartOf(7)) {
 
-#line  557 "VBNET.ATG" 
+#line  565 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 27) {
 				AttributeSection(
-#line  560 "VBNET.ATG" 
+#line  568 "VBNET.ATG" 
 out section);
 
-#line  560 "VBNET.ATG" 
+#line  568 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
-			while (StartOf(7)) {
+			while (StartOf(8)) {
 				MemberModifier(
-#line  561 "VBNET.ATG" 
+#line  569 "VBNET.ATG" 
 m);
 			}
 			ClassMemberDecl(
-#line  562 "VBNET.ATG" 
+#line  570 "VBNET.ATG" 
 m, attributes);
 		}
 		Expect(88);
 		Expect(121);
 
-#line  564 "VBNET.ATG" 
+#line  572 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		Expect(1);
 	}
 
 	void StructureBody(
-#line  539 "VBNET.ATG" 
+#line  547 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  540 "VBNET.ATG" 
+#line  548 "VBNET.ATG" 
 		AttributeSection section; 
-		while (StartOf(6)) {
+		while (StartOf(7)) {
 
-#line  542 "VBNET.ATG" 
+#line  550 "VBNET.ATG" 
 			List<AttributeSection> attributes = new List<AttributeSection>();
 			ModifierList m = new ModifierList();
 			
 			while (la.kind == 27) {
 				AttributeSection(
-#line  545 "VBNET.ATG" 
+#line  553 "VBNET.ATG" 
 out section);
 
-#line  545 "VBNET.ATG" 
+#line  553 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
-			while (StartOf(7)) {
+			while (StartOf(8)) {
 				MemberModifier(
-#line  546 "VBNET.ATG" 
+#line  554 "VBNET.ATG" 
 m);
 			}
 			StructureMemberDecl(
-#line  547 "VBNET.ATG" 
+#line  555 "VBNET.ATG" 
 m, attributes);
 		}
 		Expect(88);
 		Expect(166);
 
-#line  549 "VBNET.ATG" 
+#line  557 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		Expect(1);
 	}
 
 	void NonArrayTypeName(
-#line  1921 "VBNET.ATG" 
+#line  1929 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  1923 "VBNET.ATG" 
+#line  1931 "VBNET.ATG" 
 		string name;
 		typeref = null;
 		bool isGlobal = false;
 		
-		if (StartOf(8)) {
+		if (StartOf(9)) {
 			if (la.kind == 198) {
 				lexer.NextToken();
 				Expect(10);
 
-#line  1928 "VBNET.ATG" 
+#line  1936 "VBNET.ATG" 
 				isGlobal = true; 
 			}
 			QualIdentAndTypeArguments(
-#line  1929 "VBNET.ATG" 
+#line  1937 "VBNET.ATG" 
 out typeref, canBeUnbound);
 
-#line  1930 "VBNET.ATG" 
+#line  1938 "VBNET.ATG" 
 			typeref.IsGlobal = isGlobal; 
 			while (la.kind == 10) {
 				lexer.NextToken();
 
-#line  1931 "VBNET.ATG" 
+#line  1939 "VBNET.ATG" 
 				TypeReference nestedTypeRef; 
 				QualIdentAndTypeArguments(
-#line  1932 "VBNET.ATG" 
+#line  1940 "VBNET.ATG" 
 out nestedTypeRef, canBeUnbound);
 
-#line  1933 "VBNET.ATG" 
+#line  1941 "VBNET.ATG" 
 				typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes); 
 			}
 		} else if (la.kind == 133) {
 			lexer.NextToken();
 
-#line  1936 "VBNET.ATG" 
+#line  1944 "VBNET.ATG" 
 			typeref = new TypeReference("System.Object"); 
-		} else if (StartOf(9)) {
+		} else if (StartOf(10)) {
 			PrimitiveTypeName(
-#line  1937 "VBNET.ATG" 
+#line  1945 "VBNET.ATG" 
 out name);
 
-#line  1937 "VBNET.ATG" 
+#line  1945 "VBNET.ATG" 
 			typeref = new TypeReference(name); 
-		} else SynErr(218);
+		} else SynErr(219);
 	}
 
 	void EnumBody(
-#line  568 "VBNET.ATG" 
+#line  576 "VBNET.ATG" 
 TypeDeclaration newType) {
 
-#line  569 "VBNET.ATG" 
+#line  577 "VBNET.ATG" 
 		FieldDeclaration f; 
-		while (StartOf(10)) {
+		while (StartOf(11)) {
 			EnumMemberDecl(
-#line  571 "VBNET.ATG" 
+#line  579 "VBNET.ATG" 
 out f);
 
-#line  571 "VBNET.ATG" 
+#line  579 "VBNET.ATG" 
 			compilationUnit.AddChild(f); 
 		}
 		Expect(88);
 		Expect(90);
 
-#line  573 "VBNET.ATG" 
+#line  581 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		Expect(1);
 	}
 
 	void InterfaceBase(
-#line  1455 "VBNET.ATG" 
+#line  1463 "VBNET.ATG" 
 out List<TypeReference> bases) {
 
-#line  1457 "VBNET.ATG" 
+#line  1465 "VBNET.ATG" 
 		TypeReference type;
 		bases = new List<TypeReference>();
 		
 		Expect(110);
 		TypeName(
-#line  1461 "VBNET.ATG" 
+#line  1469 "VBNET.ATG" 
 out type);
 
-#line  1461 "VBNET.ATG" 
+#line  1469 "VBNET.ATG" 
 		bases.Add(type); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  1464 "VBNET.ATG" 
+#line  1472 "VBNET.ATG" 
 out type);
 
-#line  1464 "VBNET.ATG" 
+#line  1472 "VBNET.ATG" 
 			bases.Add(type); 
 		}
 		Expect(1);
 	}
 
 	void InterfaceBody(
-#line  577 "VBNET.ATG" 
+#line  585 "VBNET.ATG" 
 TypeDeclaration newType) {
-		while (StartOf(11)) {
+		while (StartOf(12)) {
 			InterfaceMemberDecl();
 		}
 		Expect(88);
 		Expect(112);
 
-#line  579 "VBNET.ATG" 
+#line  587 "VBNET.ATG" 
 		newType.EndLocation = t.EndLocation; 
 		Expect(1);
 	}
 
 	void FormalParameterList(
-#line  2109 "VBNET.ATG" 
+#line  2117 "VBNET.ATG" 
 List<ParameterDeclarationExpression> parameter) {
 
-#line  2111 "VBNET.ATG" 
+#line  2119 "VBNET.ATG" 
 		ParameterDeclarationExpression p;
 		AttributeSection section;
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		
 		while (la.kind == 27) {
 			AttributeSection(
-#line  2115 "VBNET.ATG" 
+#line  2123 "VBNET.ATG" 
 out section);
 
-#line  2115 "VBNET.ATG" 
+#line  2123 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		FormalParameter(
-#line  2117 "VBNET.ATG" 
+#line  2125 "VBNET.ATG" 
 out p);
 
-#line  2119 "VBNET.ATG" 
+#line  2127 "VBNET.ATG" 
 		bool paramsFound = false;
 		p.Attributes = attributes;
 		parameter.Add(p);
@@ -1219,172 +1247,172 @@ out p);
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  2124 "VBNET.ATG" 
+#line  2132 "VBNET.ATG" 
 			if (paramsFound) Error("params array must be at end of parameter list"); 
 			while (la.kind == 27) {
 				AttributeSection(
-#line  2125 "VBNET.ATG" 
+#line  2133 "VBNET.ATG" 
 out section);
 
-#line  2125 "VBNET.ATG" 
+#line  2133 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
 			FormalParameter(
-#line  2127 "VBNET.ATG" 
+#line  2135 "VBNET.ATG" 
 out p);
 
-#line  2127 "VBNET.ATG" 
+#line  2135 "VBNET.ATG" 
 			p.Attributes = attributes; parameter.Add(p); 
 		}
 	}
 
 	void MemberModifier(
-#line  2810 "VBNET.ATG" 
+#line  2818 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 122: {
 			lexer.NextToken();
 
-#line  2811 "VBNET.ATG" 
+#line  2819 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 79: {
 			lexer.NextToken();
 
-#line  2812 "VBNET.ATG" 
+#line  2820 "VBNET.ATG" 
 			m.Add(Modifiers.Default, t.Location);
 			break;
 		}
 		case 99: {
 			lexer.NextToken();
 
-#line  2813 "VBNET.ATG" 
+#line  2821 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location);
 			break;
 		}
 		case 157: {
 			lexer.NextToken();
 
-#line  2814 "VBNET.ATG" 
+#line  2822 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location);
 			break;
 		}
 		case 142: {
 			lexer.NextToken();
 
-#line  2815 "VBNET.ATG" 
+#line  2823 "VBNET.ATG" 
 			m.Add(Modifiers.Override, t.Location);
 			break;
 		}
 		case 123: {
 			lexer.NextToken();
 
-#line  2816 "VBNET.ATG" 
+#line  2824 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 145: {
 			lexer.NextToken();
 
-#line  2817 "VBNET.ATG" 
+#line  2825 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location);
 			break;
 		}
 		case 147: {
 			lexer.NextToken();
 
-#line  2818 "VBNET.ATG" 
+#line  2826 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location);
 			break;
 		}
 		case 148: {
 			lexer.NextToken();
 
-#line  2819 "VBNET.ATG" 
+#line  2827 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location);
 			break;
 		}
 		case 131: {
 			lexer.NextToken();
 
-#line  2820 "VBNET.ATG" 
+#line  2828 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 132: {
 			lexer.NextToken();
 
-#line  2821 "VBNET.ATG" 
+#line  2829 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 158: {
 			lexer.NextToken();
 
-#line  2822 "VBNET.ATG" 
+#line  2830 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location);
 			break;
 		}
 		case 141: {
 			lexer.NextToken();
 
-#line  2823 "VBNET.ATG" 
+#line  2831 "VBNET.ATG" 
 			m.Add(Modifiers.Virtual, t.Location);
 			break;
 		}
 		case 140: {
 			lexer.NextToken();
 
-#line  2824 "VBNET.ATG" 
+#line  2832 "VBNET.ATG" 
 			m.Add(Modifiers.Overloads, t.Location);
 			break;
 		}
 		case 150: {
 			lexer.NextToken();
 
-#line  2825 "VBNET.ATG" 
+#line  2833 "VBNET.ATG" 
 			m.Add(Modifiers.ReadOnly, t.Location);
 			break;
 		}
 		case 184: {
 			lexer.NextToken();
 
-#line  2826 "VBNET.ATG" 
+#line  2834 "VBNET.ATG" 
 			m.Add(Modifiers.WriteOnly, t.Location);
 			break;
 		}
 		case 183: {
 			lexer.NextToken();
 
-#line  2827 "VBNET.ATG" 
+#line  2835 "VBNET.ATG" 
 			m.Add(Modifiers.WithEvents, t.Location);
 			break;
 		}
 		case 81: {
 			lexer.NextToken();
 
-#line  2828 "VBNET.ATG" 
+#line  2836 "VBNET.ATG" 
 			m.Add(Modifiers.Dim, t.Location);
 			break;
 		}
-		default: SynErr(219); break;
+		default: SynErr(220); break;
 		}
 	}
 
 	void ClassMemberDecl(
-#line  688 "VBNET.ATG" 
+#line  696 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 		StructureMemberDecl(
-#line  689 "VBNET.ATG" 
+#line  697 "VBNET.ATG" 
 m, attributes);
 	}
 
 	void StructureMemberDecl(
-#line  702 "VBNET.ATG" 
+#line  710 "VBNET.ATG" 
 ModifierList m, List<AttributeSection> attributes) {
 
-#line  704 "VBNET.ATG" 
+#line  712 "VBNET.ATG" 
 		TypeReference type = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		Statement stmt = null;
@@ -1394,37 +1422,37 @@ ModifierList m, List<AttributeSection> attributes) {
 		switch (la.kind) {
 		case 67: case 80: case 90: case 112: case 121: case 166: {
 			NonModuleDeclaration(
-#line  711 "VBNET.ATG" 
+#line  719 "VBNET.ATG" 
 m, attributes);
 			break;
 		}
 		case 167: {
 			lexer.NextToken();
 
-#line  715 "VBNET.ATG" 
+#line  723 "VBNET.ATG" 
 			Location startPos = t.Location;
 			
-			if (StartOf(12)) {
+			if (StartOf(13)) {
 
-#line  719 "VBNET.ATG" 
+#line  727 "VBNET.ATG" 
 				string name = String.Empty;
 				MethodDeclaration methodDeclaration; List<string> handlesClause = null;
 				List<InterfaceImplementation> implementsClause = null;
 				
 				Identifier();
 
-#line  725 "VBNET.ATG" 
+#line  733 "VBNET.ATG" 
 				name = t.val;
 				m.Check(Modifiers.VBMethods);
 				
 				TypeParameterList(
-#line  728 "VBNET.ATG" 
+#line  736 "VBNET.ATG" 
 templates);
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  729 "VBNET.ATG" 
+#line  737 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
@@ -1432,23 +1460,23 @@ p);
 				if (la.kind == 105 || la.kind == 107) {
 					if (la.kind == 107) {
 						ImplementsClause(
-#line  732 "VBNET.ATG" 
+#line  740 "VBNET.ATG" 
 out implementsClause);
 					} else {
 						HandlesClause(
-#line  734 "VBNET.ATG" 
+#line  742 "VBNET.ATG" 
 out handlesClause);
 					}
 				}
 
-#line  737 "VBNET.ATG" 
+#line  745 "VBNET.ATG" 
 				Location endLocation = t.EndLocation; 
 				Expect(1);
 				if (
-#line  741 "VBNET.ATG" 
+#line  749 "VBNET.ATG" 
 IsMustOverride(m)) {
 
-#line  743 "VBNET.ATG" 
+#line  751 "VBNET.ATG" 
 					methodDeclaration = new MethodDeclaration(name, m.Modifier,  null, p, attributes);
 					methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 					methodDeclaration.EndLocation   = endLocation;
@@ -1460,9 +1488,9 @@ IsMustOverride(m)) {
 					
 					compilationUnit.AddChild(methodDeclaration);
 					
-				} else if (StartOf(13)) {
+				} else if (StartOf(14)) {
 
-#line  756 "VBNET.ATG" 
+#line  764 "VBNET.ATG" 
 					methodDeclaration = new MethodDeclaration(name, m.Modifier,  null, p, attributes);
 					methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 					methodDeclaration.EndLocation   = endLocation;
@@ -1475,67 +1503,67 @@ IsMustOverride(m)) {
 					compilationUnit.AddChild(methodDeclaration);
 					
 
-#line  768 "VBNET.ATG" 
+#line  776 "VBNET.ATG" 
 					if (ParseMethodBodies) { 
 					Block(
-#line  769 "VBNET.ATG" 
+#line  777 "VBNET.ATG" 
 out stmt);
 					Expect(88);
 					Expect(167);
 
-#line  771 "VBNET.ATG" 
+#line  779 "VBNET.ATG" 
 					} else {
 					// don't parse method body
 					lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
 					  }
 					
 
-#line  777 "VBNET.ATG" 
+#line  785 "VBNET.ATG" 
 					methodDeclaration.Body  = (BlockStatement)stmt; 
 
-#line  778 "VBNET.ATG" 
+#line  786 "VBNET.ATG" 
 					methodDeclaration.Body.EndLocation = t.EndLocation; 
 					Expect(1);
-				} else SynErr(220);
+				} else SynErr(221);
 			} else if (la.kind == 127) {
 				lexer.NextToken();
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  781 "VBNET.ATG" 
+#line  789 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
 				}
 
-#line  782 "VBNET.ATG" 
+#line  790 "VBNET.ATG" 
 				m.Check(Modifiers.Constructors); 
 
-#line  783 "VBNET.ATG" 
+#line  791 "VBNET.ATG" 
 				Location constructorEndLocation = t.EndLocation; 
 				Expect(1);
 
-#line  786 "VBNET.ATG" 
+#line  794 "VBNET.ATG" 
 				if (ParseMethodBodies) { 
 				Block(
-#line  787 "VBNET.ATG" 
+#line  795 "VBNET.ATG" 
 out stmt);
 				Expect(88);
 				Expect(167);
 
-#line  789 "VBNET.ATG" 
+#line  797 "VBNET.ATG" 
 				} else {
 				// don't parse method body
 				lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
 				  }
 				
 
-#line  795 "VBNET.ATG" 
+#line  803 "VBNET.ATG" 
 				Location endLocation = t.EndLocation; 
 				Expect(1);
 
-#line  797 "VBNET.ATG" 
+#line  805 "VBNET.ATG" 
 				ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes); 
 				cd.StartLocation = m.GetDeclarationLocation(startPos);
 				cd.EndLocation   = constructorEndLocation;
@@ -1543,13 +1571,13 @@ out stmt);
 				cd.Body.EndLocation   = endLocation;
 				compilationUnit.AddChild(cd);
 				
-			} else SynErr(221);
+			} else SynErr(222);
 			break;
 		}
 		case 100: {
 			lexer.NextToken();
 
-#line  809 "VBNET.ATG" 
+#line  817 "VBNET.ATG" 
 			m.Check(Modifiers.VBMethods);
 			string name = String.Empty;
 			Location startPos = t.Location;
@@ -1559,16 +1587,16 @@ out stmt);
 			
 			Identifier();
 
-#line  816 "VBNET.ATG" 
+#line  824 "VBNET.ATG" 
 			name = t.val; 
 			TypeParameterList(
-#line  817 "VBNET.ATG" 
+#line  825 "VBNET.ATG" 
 templates);
 			if (la.kind == 24) {
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  818 "VBNET.ATG" 
+#line  826 "VBNET.ATG" 
 p);
 				}
 				Expect(25);
@@ -1577,15 +1605,15 @@ p);
 				lexer.NextToken();
 				while (la.kind == 27) {
 					AttributeSection(
-#line  819 "VBNET.ATG" 
+#line  827 "VBNET.ATG" 
 out returnTypeAttributeSection);
 				}
 				TypeName(
-#line  819 "VBNET.ATG" 
+#line  827 "VBNET.ATG" 
 out type);
 			}
 
-#line  821 "VBNET.ATG" 
+#line  829 "VBNET.ATG" 
 			if(type == null) {
 			type = new TypeReference("System.Object");
 			}
@@ -1593,20 +1621,20 @@ out type);
 			if (la.kind == 105 || la.kind == 107) {
 				if (la.kind == 107) {
 					ImplementsClause(
-#line  827 "VBNET.ATG" 
+#line  835 "VBNET.ATG" 
 out implementsClause);
 				} else {
 					HandlesClause(
-#line  829 "VBNET.ATG" 
+#line  837 "VBNET.ATG" 
 out handlesClause);
 				}
 			}
 			Expect(1);
 			if (
-#line  835 "VBNET.ATG" 
+#line  843 "VBNET.ATG" 
 IsMustOverride(m)) {
 
-#line  837 "VBNET.ATG" 
+#line  845 "VBNET.ATG" 
 				methodDeclaration = new MethodDeclaration(name, m.Modifier,  type, p, attributes);
 				methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				methodDeclaration.EndLocation   = t.EndLocation;
@@ -1620,9 +1648,9 @@ IsMustOverride(m)) {
 				}
 				compilationUnit.AddChild(methodDeclaration);
 				
-			} else if (StartOf(13)) {
+			} else if (StartOf(14)) {
 
-#line  852 "VBNET.ATG" 
+#line  860 "VBNET.ATG" 
 				methodDeclaration = new MethodDeclaration(name, m.Modifier,  type, p, attributes);
 				methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				methodDeclaration.EndLocation   = t.EndLocation;
@@ -1639,12 +1667,12 @@ IsMustOverride(m)) {
 				
 				if (ParseMethodBodies) { 
 				Block(
-#line  867 "VBNET.ATG" 
+#line  875 "VBNET.ATG" 
 out stmt);
 				Expect(88);
 				Expect(100);
 
-#line  869 "VBNET.ATG" 
+#line  877 "VBNET.ATG" 
 				} else {
 				// don't parse method body
 				lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
@@ -1654,13 +1682,13 @@ out stmt);
 				methodDeclaration.Body.EndLocation   = t.EndLocation;
 				
 				Expect(1);
-			} else SynErr(222);
+			} else SynErr(223);
 			break;
 		}
 		case 78: {
 			lexer.NextToken();
 
-#line  883 "VBNET.ATG" 
+#line  891 "VBNET.ATG" 
 			m.Check(Modifiers.VBExternalMethods);
 			Location startPos = t.Location;
 			CharsetModifier charsetModifer = CharsetModifier.None;
@@ -1668,41 +1696,41 @@ out stmt);
 			string alias = null;
 			string name = String.Empty;
 			
-			if (StartOf(14)) {
+			if (StartOf(15)) {
 				Charset(
-#line  890 "VBNET.ATG" 
+#line  898 "VBNET.ATG" 
 out charsetModifer);
 			}
 			if (la.kind == 167) {
 				lexer.NextToken();
 				Identifier();
 
-#line  893 "VBNET.ATG" 
+#line  901 "VBNET.ATG" 
 				name = t.val; 
 				Expect(115);
 				Expect(3);
 
-#line  894 "VBNET.ATG" 
+#line  902 "VBNET.ATG" 
 				library = t.literalValue.ToString(); 
 				if (la.kind == 44) {
 					lexer.NextToken();
 					Expect(3);
 
-#line  895 "VBNET.ATG" 
+#line  903 "VBNET.ATG" 
 					alias = t.literalValue.ToString(); 
 				}
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  896 "VBNET.ATG" 
+#line  904 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
 				}
 				Expect(1);
 
-#line  899 "VBNET.ATG" 
+#line  907 "VBNET.ATG" 
 				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
 				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				declareDeclaration.EndLocation   = t.EndLocation;
@@ -1712,25 +1740,25 @@ p);
 				lexer.NextToken();
 				Identifier();
 
-#line  906 "VBNET.ATG" 
+#line  914 "VBNET.ATG" 
 				name = t.val; 
 				Expect(115);
 				Expect(3);
 
-#line  907 "VBNET.ATG" 
+#line  915 "VBNET.ATG" 
 				library = t.literalValue.ToString(); 
 				if (la.kind == 44) {
 					lexer.NextToken();
 					Expect(3);
 
-#line  908 "VBNET.ATG" 
+#line  916 "VBNET.ATG" 
 					alias = t.literalValue.ToString(); 
 				}
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  909 "VBNET.ATG" 
+#line  917 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
@@ -1738,24 +1766,24 @@ p);
 				if (la.kind == 48) {
 					lexer.NextToken();
 					TypeName(
-#line  910 "VBNET.ATG" 
+#line  918 "VBNET.ATG" 
 out type);
 				}
 				Expect(1);
 
-#line  913 "VBNET.ATG" 
+#line  921 "VBNET.ATG" 
 				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
 				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 				declareDeclaration.EndLocation   = t.EndLocation;
 				compilationUnit.AddChild(declareDeclaration);
 				
-			} else SynErr(223);
+			} else SynErr(224);
 			break;
 		}
 		case 93: {
 			lexer.NextToken();
 
-#line  923 "VBNET.ATG" 
+#line  931 "VBNET.ATG" 
 			m.Check(Modifiers.VBEvents);
 			Location startPos = t.Location;
 			EventDeclaration eventDeclaration;
@@ -1764,31 +1792,31 @@ out type);
 			
 			Identifier();
 
-#line  929 "VBNET.ATG" 
+#line  937 "VBNET.ATG" 
 			name= t.val; 
 			if (la.kind == 48) {
 				lexer.NextToken();
 				TypeName(
-#line  931 "VBNET.ATG" 
+#line  939 "VBNET.ATG" 
 out type);
 			} else if (la.kind == 1 || la.kind == 24 || la.kind == 107) {
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  933 "VBNET.ATG" 
+#line  941 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
 				}
-			} else SynErr(224);
+			} else SynErr(225);
 			if (la.kind == 107) {
 				ImplementsClause(
-#line  935 "VBNET.ATG" 
+#line  943 "VBNET.ATG" 
 out implementsClause);
 			}
 
-#line  937 "VBNET.ATG" 
+#line  945 "VBNET.ATG" 
 			eventDeclaration = new EventDeclaration(type, m.Modifier, p, attributes, name, implementsClause);
 			eventDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
 			eventDeclaration.EndLocation = t.EndLocation;
@@ -1799,30 +1827,30 @@ out implementsClause);
 		}
 		case 2: case 47: case 49: case 50: case 51: case 70: case 144: case 169: case 176: case 177: {
 
-#line  944 "VBNET.ATG" 
+#line  952 "VBNET.ATG" 
 			Location startPos = t.Location; 
 
-#line  946 "VBNET.ATG" 
+#line  954 "VBNET.ATG" 
 			m.Check(Modifiers.Fields);
 			FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);
 			fd.StartLocation = m.GetDeclarationLocation(startPos); 
 			
 			IdentifierForFieldDeclaration();
 
-#line  950 "VBNET.ATG" 
+#line  958 "VBNET.ATG" 
 			string name = t.val; 
 			VariableDeclaratorPartAfterIdentifier(
-#line  951 "VBNET.ATG" 
+#line  959 "VBNET.ATG" 
 variableDeclarators, name);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				VariableDeclarator(
-#line  952 "VBNET.ATG" 
+#line  960 "VBNET.ATG" 
 variableDeclarators);
 			}
 			Expect(1);
 
-#line  955 "VBNET.ATG" 
+#line  963 "VBNET.ATG" 
 			fd.EndLocation = t.EndLocation;
 			fd.Fields = variableDeclarators;
 			compilationUnit.AddChild(fd);
@@ -1831,35 +1859,35 @@ variableDeclarators);
 		}
 		case 71: {
 
-#line  960 "VBNET.ATG" 
+#line  968 "VBNET.ATG" 
 			m.Check(Modifiers.Fields); 
 			lexer.NextToken();
 
-#line  961 "VBNET.ATG" 
+#line  969 "VBNET.ATG" 
 			m.Add(Modifiers.Const, t.Location);  
 
-#line  963 "VBNET.ATG" 
+#line  971 "VBNET.ATG" 
 			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
 			fd.StartLocation = m.GetDeclarationLocation(t.Location);
 			List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();
 			
 			ConstantDeclarator(
-#line  967 "VBNET.ATG" 
+#line  975 "VBNET.ATG" 
 constantDeclarators);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				ConstantDeclarator(
-#line  968 "VBNET.ATG" 
+#line  976 "VBNET.ATG" 
 constantDeclarators);
 			}
 
-#line  970 "VBNET.ATG" 
+#line  978 "VBNET.ATG" 
 			fd.Fields = constantDeclarators;
 			fd.EndLocation = t.Location;
 			
 			Expect(1);
 
-#line  975 "VBNET.ATG" 
+#line  983 "VBNET.ATG" 
 			fd.EndLocation = t.EndLocation;
 			compilationUnit.AddChild(fd);
 			
@@ -1868,20 +1896,20 @@ constantDeclarators);
 		case 146: {
 			lexer.NextToken();
 
-#line  981 "VBNET.ATG" 
+#line  989 "VBNET.ATG" 
 			m.Check(Modifiers.VBProperties);
 			Location startPos = t.Location;
 			List<InterfaceImplementation> implementsClause = null;
 			
 			Identifier();
 
-#line  985 "VBNET.ATG" 
+#line  993 "VBNET.ATG" 
 			string propertyName = t.val; 
 			if (la.kind == 24) {
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  986 "VBNET.ATG" 
+#line  994 "VBNET.ATG" 
 p);
 				}
 				Expect(25);
@@ -1889,26 +1917,26 @@ p);
 			if (la.kind == 48) {
 				lexer.NextToken();
 				TypeName(
-#line  987 "VBNET.ATG" 
+#line  995 "VBNET.ATG" 
 out type);
 			}
 
-#line  989 "VBNET.ATG" 
+#line  997 "VBNET.ATG" 
 			if(type == null) {
 			type = new TypeReference("System.Object");
 			}
 			
 			if (la.kind == 107) {
 				ImplementsClause(
-#line  993 "VBNET.ATG" 
+#line  1001 "VBNET.ATG" 
 out implementsClause);
 			}
 			Expect(1);
 			if (
-#line  997 "VBNET.ATG" 
+#line  1005 "VBNET.ATG" 
 IsMustOverride(m)) {
 
-#line  999 "VBNET.ATG" 
+#line  1007 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -1917,9 +1945,9 @@ IsMustOverride(m)) {
 				pDecl.Parameters = p;
 				compilationUnit.AddChild(pDecl);
 				
-			} else if (StartOf(15)) {
+			} else if (StartOf(16)) {
 
-#line  1009 "VBNET.ATG" 
+#line  1017 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -1931,29 +1959,29 @@ IsMustOverride(m)) {
 				PropertySetRegion setRegion;
 				
 				AccessorDecls(
-#line  1019 "VBNET.ATG" 
+#line  1027 "VBNET.ATG" 
 out getRegion, out setRegion);
 				Expect(88);
 				Expect(146);
 				Expect(1);
 
-#line  1023 "VBNET.ATG" 
+#line  1031 "VBNET.ATG" 
 				pDecl.GetRegion = getRegion;
 				pDecl.SetRegion = setRegion;
 				pDecl.BodyEnd = t.EndLocation;
 				compilationUnit.AddChild(pDecl);
 				
-			} else SynErr(225);
+			} else SynErr(226);
 			break;
 		}
 		case 204: {
 			lexer.NextToken();
 
-#line  1030 "VBNET.ATG" 
+#line  1038 "VBNET.ATG" 
 			Location startPos = t.Location; 
 			Expect(93);
 
-#line  1032 "VBNET.ATG" 
+#line  1040 "VBNET.ATG" 
 			m.Check(Modifiers.VBCustomEvents);
 			EventAddRemoveRegion eventAccessorDeclaration;
 			EventAddRegion addHandlerAccessorDeclaration = null;
@@ -1963,24 +1991,24 @@ out getRegion, out setRegion);
 			
 			Identifier();
 
-#line  1039 "VBNET.ATG" 
+#line  1047 "VBNET.ATG" 
 			string customEventName = t.val; 
 			Expect(48);
 			TypeName(
-#line  1040 "VBNET.ATG" 
+#line  1048 "VBNET.ATG" 
 out type);
 			if (la.kind == 107) {
 				ImplementsClause(
-#line  1041 "VBNET.ATG" 
+#line  1049 "VBNET.ATG" 
 out implementsClause);
 			}
 			Expect(1);
-			while (StartOf(16)) {
+			while (StartOf(17)) {
 				EventAccessorDeclaration(
-#line  1044 "VBNET.ATG" 
+#line  1052 "VBNET.ATG" 
 out eventAccessorDeclaration);
 
-#line  1046 "VBNET.ATG" 
+#line  1054 "VBNET.ATG" 
 				if(eventAccessorDeclaration is EventAddRegion)
 				{
 					addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
@@ -1999,7 +2027,7 @@ out eventAccessorDeclaration);
 			Expect(93);
 			Expect(1);
 
-#line  1062 "VBNET.ATG" 
+#line  1070 "VBNET.ATG" 
 			if(addHandlerAccessorDeclaration == null)
 			{
 				Error("Need to provide AddHandler accessor.");
@@ -2027,24 +2055,24 @@ out eventAccessorDeclaration);
 		}
 		case 187: case 201: case 202: {
 
-#line  1085 "VBNET.ATG" 
+#line  1093 "VBNET.ATG" 
 			ConversionType opConversionType = ConversionType.None; 
 			if (la.kind == 201 || la.kind == 202) {
 				if (la.kind == 202) {
 					lexer.NextToken();
 
-#line  1086 "VBNET.ATG" 
+#line  1094 "VBNET.ATG" 
 					opConversionType = ConversionType.Implicit; 
 				} else {
 					lexer.NextToken();
 
-#line  1087 "VBNET.ATG" 
+#line  1095 "VBNET.ATG" 
 					opConversionType = ConversionType.Explicit;
 				}
 			}
 			Expect(187);
 
-#line  1090 "VBNET.ATG" 
+#line  1098 "VBNET.ATG" 
 			m.Check(Modifiers.VBOperators);
 			Location startPos = t.Location;
 			TypeReference returnType = NullTypeReference.Instance;
@@ -2056,7 +2084,7 @@ out eventAccessorDeclaration);
 			List<AttributeSection> returnTypeAttributes = new List<AttributeSection>();
 			
 			OverloadableOperator(
-#line  1100 "VBNET.ATG" 
+#line  1108 "VBNET.ATG" 
 out operatorType);
 			Expect(24);
 			if (la.kind == 55) {
@@ -2064,16 +2092,16 @@ out operatorType);
 			}
 			Identifier();
 
-#line  1101 "VBNET.ATG" 
+#line  1109 "VBNET.ATG" 
 			operandName = t.val; 
 			if (la.kind == 48) {
 				lexer.NextToken();
 				TypeName(
-#line  1102 "VBNET.ATG" 
+#line  1110 "VBNET.ATG" 
 out operandType);
 			}
 
-#line  1103 "VBNET.ATG" 
+#line  1111 "VBNET.ATG" 
 			parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In)); 
 			while (la.kind == 12) {
 				lexer.NextToken();
@@ -2082,48 +2110,48 @@ out operandType);
 				}
 				Identifier();
 
-#line  1107 "VBNET.ATG" 
+#line  1115 "VBNET.ATG" 
 				operandName = t.val; 
 				if (la.kind == 48) {
 					lexer.NextToken();
 					TypeName(
-#line  1108 "VBNET.ATG" 
+#line  1116 "VBNET.ATG" 
 out operandType);
 				}
 
-#line  1109 "VBNET.ATG" 
+#line  1117 "VBNET.ATG" 
 				parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In)); 
 			}
 			Expect(25);
 
-#line  1112 "VBNET.ATG" 
+#line  1120 "VBNET.ATG" 
 			Location endPos = t.EndLocation; 
 			if (la.kind == 48) {
 				lexer.NextToken();
 				while (la.kind == 27) {
 					AttributeSection(
-#line  1113 "VBNET.ATG" 
+#line  1121 "VBNET.ATG" 
 out section);
 
-#line  1113 "VBNET.ATG" 
+#line  1121 "VBNET.ATG" 
 					returnTypeAttributes.Add(section); 
 				}
 				TypeName(
-#line  1113 "VBNET.ATG" 
+#line  1121 "VBNET.ATG" 
 out returnType);
 
-#line  1113 "VBNET.ATG" 
+#line  1121 "VBNET.ATG" 
 				endPos = t.EndLocation; 
 				Expect(1);
 			}
 			Block(
-#line  1114 "VBNET.ATG" 
+#line  1122 "VBNET.ATG" 
 out stmt);
 			Expect(88);
 			Expect(187);
 			Expect(1);
 
-#line  1116 "VBNET.ATG" 
+#line  1124 "VBNET.ATG" 
 			OperatorDeclaration operatorDeclaration = new OperatorDeclaration(m.Modifier, 
 			                                                                 attributes, 
 			                                                                 parameters, 
@@ -2141,30 +2169,30 @@ out stmt);
 			
 			break;
 		}
-		default: SynErr(226); break;
+		default: SynErr(227); break;
 		}
 	}
 
 	void EnumMemberDecl(
-#line  670 "VBNET.ATG" 
+#line  678 "VBNET.ATG" 
 out FieldDeclaration f) {
 
-#line  672 "VBNET.ATG" 
+#line  680 "VBNET.ATG" 
 		Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
 		AttributeSection section = null;
 		VariableDeclaration varDecl = null;
 		
 		while (la.kind == 27) {
 			AttributeSection(
-#line  676 "VBNET.ATG" 
+#line  684 "VBNET.ATG" 
 out section);
 
-#line  676 "VBNET.ATG" 
+#line  684 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		Identifier();
 
-#line  679 "VBNET.ATG" 
+#line  687 "VBNET.ATG" 
 		f = new FieldDeclaration(attributes);
 		varDecl = new VariableDeclaration(t.val);
 		f.Fields.Add(varDecl);
@@ -2173,10 +2201,10 @@ out section);
 		if (la.kind == 11) {
 			lexer.NextToken();
 			Expr(
-#line  684 "VBNET.ATG" 
+#line  692 "VBNET.ATG" 
 out expr);
 
-#line  684 "VBNET.ATG" 
+#line  692 "VBNET.ATG" 
 			varDecl.Initializer = expr; 
 		}
 		Expect(1);
@@ -2184,7 +2212,7 @@ out expr);
 
 	void InterfaceMemberDecl() {
 
-#line  587 "VBNET.ATG" 
+#line  595 "VBNET.ATG" 
 		TypeReference type =null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		List<TemplateDefinition> templates = new List<TemplateDefinition>();
@@ -2193,34 +2221,34 @@ out expr);
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		string name;
 		
-		if (StartOf(17)) {
+		if (StartOf(18)) {
 			while (la.kind == 27) {
 				AttributeSection(
-#line  595 "VBNET.ATG" 
+#line  603 "VBNET.ATG" 
 out section);
 
-#line  595 "VBNET.ATG" 
+#line  603 "VBNET.ATG" 
 				attributes.Add(section); 
 			}
-			while (StartOf(7)) {
+			while (StartOf(8)) {
 				MemberModifier(
-#line  598 "VBNET.ATG" 
+#line  606 "VBNET.ATG" 
 mod);
 			}
 			if (la.kind == 93) {
 				lexer.NextToken();
 
-#line  601 "VBNET.ATG" 
+#line  609 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceEvents); 
 				Identifier();
 
-#line  602 "VBNET.ATG" 
+#line  610 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  603 "VBNET.ATG" 
+#line  611 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
@@ -2228,12 +2256,12 @@ p);
 				if (la.kind == 48) {
 					lexer.NextToken();
 					TypeName(
-#line  604 "VBNET.ATG" 
+#line  612 "VBNET.ATG" 
 out type);
 				}
 				Expect(1);
 
-#line  607 "VBNET.ATG" 
+#line  615 "VBNET.ATG" 
 				EventDeclaration ed = new EventDeclaration(type, mod.Modifier, p, attributes, name, null);
 				compilationUnit.AddChild(ed);
 				ed.EndLocation = t.EndLocation;
@@ -2241,27 +2269,27 @@ out type);
 			} else if (la.kind == 167) {
 				lexer.NextToken();
 
-#line  613 "VBNET.ATG" 
+#line  621 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceMethods); 
 				Identifier();
 
-#line  614 "VBNET.ATG" 
+#line  622 "VBNET.ATG" 
 				name = t.val; 
 				TypeParameterList(
-#line  615 "VBNET.ATG" 
+#line  623 "VBNET.ATG" 
 templates);
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  616 "VBNET.ATG" 
+#line  624 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
 				}
 				Expect(1);
 
-#line  619 "VBNET.ATG" 
+#line  627 "VBNET.ATG" 
 				MethodDeclaration md = new MethodDeclaration(name, mod.Modifier, null, p, attributes);
 				md.TypeReference = new TypeReference("", "System.Void");
 				md.EndLocation = t.EndLocation;
@@ -2271,20 +2299,20 @@ p);
 			} else if (la.kind == 100) {
 				lexer.NextToken();
 
-#line  627 "VBNET.ATG" 
+#line  635 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceMethods); 
 				Identifier();
 
-#line  628 "VBNET.ATG" 
+#line  636 "VBNET.ATG" 
 				name = t.val; 
 				TypeParameterList(
-#line  629 "VBNET.ATG" 
+#line  637 "VBNET.ATG" 
 templates);
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  630 "VBNET.ATG" 
+#line  638 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
@@ -2293,15 +2321,15 @@ p);
 					lexer.NextToken();
 					while (la.kind == 27) {
 						AttributeSection(
-#line  631 "VBNET.ATG" 
+#line  639 "VBNET.ATG" 
 out returnTypeAttributeSection);
 					}
 					TypeName(
-#line  631 "VBNET.ATG" 
+#line  639 "VBNET.ATG" 
 out type);
 				}
 
-#line  633 "VBNET.ATG" 
+#line  641 "VBNET.ATG" 
 				if(type == null) {
 				type = new TypeReference("System.Object");
 				}
@@ -2318,17 +2346,17 @@ out type);
 			} else if (la.kind == 146) {
 				lexer.NextToken();
 
-#line  648 "VBNET.ATG" 
+#line  656 "VBNET.ATG" 
 				mod.Check(Modifiers.VBInterfaceProperties); 
 				Identifier();
 
-#line  649 "VBNET.ATG" 
+#line  657 "VBNET.ATG" 
 				name = t.val;  
 				if (la.kind == 24) {
 					lexer.NextToken();
 					if (StartOf(4)) {
 						FormalParameterList(
-#line  650 "VBNET.ATG" 
+#line  658 "VBNET.ATG" 
 p);
 					}
 					Expect(25);
@@ -2336,117 +2364,117 @@ p);
 				if (la.kind == 48) {
 					lexer.NextToken();
 					TypeName(
-#line  651 "VBNET.ATG" 
+#line  659 "VBNET.ATG" 
 out type);
 				}
 
-#line  653 "VBNET.ATG" 
+#line  661 "VBNET.ATG" 
 				if(type == null) {
 				type = new TypeReference("System.Object");
 				}
 				
 				Expect(1);
 
-#line  659 "VBNET.ATG" 
+#line  667 "VBNET.ATG" 
 				PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes);
 				pd.Parameters = p;
 				pd.EndLocation = t.EndLocation;
 				compilationUnit.AddChild(pd);
 				
-			} else SynErr(227);
-		} else if (StartOf(18)) {
+			} else SynErr(228);
+		} else if (StartOf(19)) {
 			NonModuleDeclaration(
-#line  666 "VBNET.ATG" 
+#line  674 "VBNET.ATG" 
 mod, attributes);
-		} else SynErr(228);
+		} else SynErr(229);
 	}
 
 	void Expr(
-#line  1516 "VBNET.ATG" 
+#line  1524 "VBNET.ATG" 
 out Expression expr) {
 		DisjunctionExpr(
-#line  1518 "VBNET.ATG" 
+#line  1526 "VBNET.ATG" 
 out expr);
 	}
 
 	void ImplementsClause(
-#line  1487 "VBNET.ATG" 
+#line  1495 "VBNET.ATG" 
 out List<InterfaceImplementation> baseInterfaces) {
 
-#line  1489 "VBNET.ATG" 
+#line  1497 "VBNET.ATG" 
 		baseInterfaces = new List<InterfaceImplementation>();
 		TypeReference type = null;
 		string memberName = null;
 		
 		Expect(107);
 		NonArrayTypeName(
-#line  1494 "VBNET.ATG" 
+#line  1502 "VBNET.ATG" 
 out type, false);
 
-#line  1495 "VBNET.ATG" 
+#line  1503 "VBNET.ATG" 
 		if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-#line  1496 "VBNET.ATG" 
+#line  1504 "VBNET.ATG" 
 		baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			NonArrayTypeName(
-#line  1498 "VBNET.ATG" 
+#line  1506 "VBNET.ATG" 
 out type, false);
 
-#line  1499 "VBNET.ATG" 
+#line  1507 "VBNET.ATG" 
 			if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-#line  1500 "VBNET.ATG" 
+#line  1508 "VBNET.ATG" 
 			baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		}
 	}
 
 	void HandlesClause(
-#line  1445 "VBNET.ATG" 
+#line  1453 "VBNET.ATG" 
 out List<string> handlesClause) {
 
-#line  1447 "VBNET.ATG" 
+#line  1455 "VBNET.ATG" 
 		handlesClause = new List<string>();
 		string name;
 		
 		Expect(105);
 		EventMemberSpecifier(
-#line  1450 "VBNET.ATG" 
+#line  1458 "VBNET.ATG" 
 out name);
 
-#line  1450 "VBNET.ATG" 
+#line  1458 "VBNET.ATG" 
 		handlesClause.Add(name); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			EventMemberSpecifier(
-#line  1451 "VBNET.ATG" 
+#line  1459 "VBNET.ATG" 
 out name);
 
-#line  1451 "VBNET.ATG" 
+#line  1459 "VBNET.ATG" 
 			handlesClause.Add(name); 
 		}
 	}
 
 	void Block(
-#line  2165 "VBNET.ATG" 
+#line  2173 "VBNET.ATG" 
 out Statement stmt) {
 
-#line  2168 "VBNET.ATG" 
+#line  2176 "VBNET.ATG" 
 		BlockStatement blockStmt = new BlockStatement();
 		blockStmt.StartLocation = t.Location;
 		compilationUnit.BlockStart(blockStmt);
 		
-		while (StartOf(19) || 
-#line  2173 "VBNET.ATG" 
+		while (StartOf(20) || 
+#line  2181 "VBNET.ATG" 
 IsEndStmtAhead()) {
 			if (
-#line  2173 "VBNET.ATG" 
+#line  2181 "VBNET.ATG" 
 IsEndStmtAhead()) {
 				Expect(88);
 				EndOfStmt();
 
-#line  2173 "VBNET.ATG" 
+#line  2181 "VBNET.ATG" 
 				compilationUnit.AddChild(new EndStatement()); 
 			} else {
 				Statement();
@@ -2454,7 +2482,7 @@ IsEndStmtAhead()) {
 			}
 		}
 
-#line  2178 "VBNET.ATG" 
+#line  2186 "VBNET.ATG" 
 		stmt = blockStmt;
 		blockStmt.EndLocation = t.EndLocation;
 		compilationUnit.BlockEnd();
@@ -2462,28 +2490,28 @@ IsEndStmtAhead()) {
 	}
 
 	void Charset(
-#line  1437 "VBNET.ATG" 
+#line  1445 "VBNET.ATG" 
 out CharsetModifier charsetModifier) {
 
-#line  1438 "VBNET.ATG" 
+#line  1446 "VBNET.ATG" 
 		charsetModifier = CharsetModifier.None; 
 		if (la.kind == 100 || la.kind == 167) {
 		} else if (la.kind == 47) {
 			lexer.NextToken();
 
-#line  1439 "VBNET.ATG" 
+#line  1447 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Ansi; 
 		} else if (la.kind == 50) {
 			lexer.NextToken();
 
-#line  1440 "VBNET.ATG" 
+#line  1448 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Auto; 
 		} else if (la.kind == 176) {
 			lexer.NextToken();
 
-#line  1441 "VBNET.ATG" 
+#line  1449 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Unicode; 
-		} else SynErr(229);
+		} else SynErr(230);
 	}
 
 	void IdentifierForFieldDeclaration() {
@@ -2528,57 +2556,57 @@ out CharsetModifier charsetModifier) {
 			lexer.NextToken();
 			break;
 		}
-		default: SynErr(230); break;
+		default: SynErr(231); break;
 		}
 	}
 
 	void VariableDeclaratorPartAfterIdentifier(
-#line  1317 "VBNET.ATG" 
+#line  1325 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration, string name) {
 
-#line  1319 "VBNET.ATG" 
+#line  1327 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		ArrayList rank = null;
 		List<Expression> dimension = null;
 		
 		if (
-#line  1324 "VBNET.ATG" 
+#line  1332 "VBNET.ATG" 
 IsSize() && !IsDims()) {
 			ArrayInitializationModifier(
-#line  1324 "VBNET.ATG" 
+#line  1332 "VBNET.ATG" 
 out dimension);
 		}
 		if (
-#line  1325 "VBNET.ATG" 
+#line  1333 "VBNET.ATG" 
 IsDims()) {
 			ArrayNameModifier(
-#line  1325 "VBNET.ATG" 
+#line  1333 "VBNET.ATG" 
 out rank);
 		}
 		if (
-#line  1327 "VBNET.ATG" 
+#line  1335 "VBNET.ATG" 
 IsObjectCreation()) {
 			Expect(48);
 			ObjectCreateExpression(
-#line  1327 "VBNET.ATG" 
+#line  1335 "VBNET.ATG" 
 out expr);
 
-#line  1329 "VBNET.ATG" 
+#line  1337 "VBNET.ATG" 
 			if (expr is ObjectCreateExpression) {
 			type = ((ObjectCreateExpression)expr).CreateType;
 			} else {
 				type = ((ArrayCreateExpression)expr).CreateType;
 			}
 			
-		} else if (StartOf(20)) {
+		} else if (StartOf(21)) {
 			if (la.kind == 48) {
 				lexer.NextToken();
 				TypeName(
-#line  1336 "VBNET.ATG" 
+#line  1344 "VBNET.ATG" 
 out type);
 
-#line  1338 "VBNET.ATG" 
+#line  1346 "VBNET.ATG" 
 				if (type != null) {
 				for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
 					VariableDeclaration vd = fieldDeclaration[i];
@@ -2591,7 +2619,7 @@ out type);
 				 
 			}
 
-#line  1350 "VBNET.ATG" 
+#line  1358 "VBNET.ATG" 
 			if (type == null && (dimension != null || rank != null)) {
 			type = new TypeReference("");
 			}
@@ -2620,52 +2648,52 @@ out type);
 			if (la.kind == 11) {
 				lexer.NextToken();
 				VariableInitializer(
-#line  1375 "VBNET.ATG" 
+#line  1383 "VBNET.ATG" 
 out expr);
 			}
-		} else SynErr(231);
+		} else SynErr(232);
 
-#line  1377 "VBNET.ATG" 
+#line  1385 "VBNET.ATG" 
 		fieldDeclaration.Add(new VariableDeclaration(name, expr, type)); 
 	}
 
 	void VariableDeclarator(
-#line  1311 "VBNET.ATG" 
+#line  1319 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration) {
 		Identifier();
 
-#line  1313 "VBNET.ATG" 
+#line  1321 "VBNET.ATG" 
 		string name = t.val; 
 		VariableDeclaratorPartAfterIdentifier(
-#line  1314 "VBNET.ATG" 
+#line  1322 "VBNET.ATG" 
 fieldDeclaration, name);
 	}
 
 	void ConstantDeclarator(
-#line  1294 "VBNET.ATG" 
+#line  1302 "VBNET.ATG" 
 List<VariableDeclaration> constantDeclaration) {
 
-#line  1296 "VBNET.ATG" 
+#line  1304 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		string name = String.Empty;
 		
 		Identifier();
 
-#line  1300 "VBNET.ATG" 
+#line  1308 "VBNET.ATG" 
 		name = t.val; 
 		if (la.kind == 48) {
 			lexer.NextToken();
 			TypeName(
-#line  1301 "VBNET.ATG" 
+#line  1309 "VBNET.ATG" 
 out type);
 		}
 		Expect(11);
 		Expr(
-#line  1302 "VBNET.ATG" 
+#line  1310 "VBNET.ATG" 
 out expr);
 
-#line  1304 "VBNET.ATG" 
+#line  1312 "VBNET.ATG" 
 		VariableDeclaration f = new VariableDeclaration(name, expr);
 		f.TypeReference = type;
 		constantDeclaration.Add(f);
@@ -2673,10 +2701,10 @@ out expr);
 	}
 
 	void AccessorDecls(
-#line  1228 "VBNET.ATG" 
+#line  1236 "VBNET.ATG" 
 out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 
-#line  1230 "VBNET.ATG" 
+#line  1238 "VBNET.ATG" 
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		AttributeSection section;
 		getBlock = null;
@@ -2684,60 +2712,60 @@ out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 		
 		while (la.kind == 27) {
 			AttributeSection(
-#line  1235 "VBNET.ATG" 
+#line  1243 "VBNET.ATG" 
 out section);
 
-#line  1235 "VBNET.ATG" 
+#line  1243 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
-		if (StartOf(21)) {
+		if (StartOf(22)) {
 			GetAccessorDecl(
-#line  1237 "VBNET.ATG" 
+#line  1245 "VBNET.ATG" 
 out getBlock, attributes);
-			if (StartOf(22)) {
+			if (StartOf(23)) {
 
-#line  1239 "VBNET.ATG" 
+#line  1247 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 27) {
 					AttributeSection(
-#line  1240 "VBNET.ATG" 
+#line  1248 "VBNET.ATG" 
 out section);
 
-#line  1240 "VBNET.ATG" 
+#line  1248 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				SetAccessorDecl(
-#line  1241 "VBNET.ATG" 
+#line  1249 "VBNET.ATG" 
 out setBlock, attributes);
 			}
-		} else if (StartOf(23)) {
+		} else if (StartOf(24)) {
 			SetAccessorDecl(
-#line  1244 "VBNET.ATG" 
+#line  1252 "VBNET.ATG" 
 out setBlock, attributes);
-			if (StartOf(24)) {
+			if (StartOf(25)) {
 
-#line  1246 "VBNET.ATG" 
+#line  1254 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 27) {
 					AttributeSection(
-#line  1247 "VBNET.ATG" 
+#line  1255 "VBNET.ATG" 
 out section);
 
-#line  1247 "VBNET.ATG" 
+#line  1255 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				GetAccessorDecl(
-#line  1248 "VBNET.ATG" 
+#line  1256 "VBNET.ATG" 
 out getBlock, attributes);
 			}
-		} else SynErr(232);
+		} else SynErr(233);
 	}
 
 	void EventAccessorDeclaration(
-#line  1191 "VBNET.ATG" 
+#line  1199 "VBNET.ATG" 
 out EventAddRemoveRegion eventAccessorDeclaration) {
 
-#line  1193 "VBNET.ATG" 
+#line  1201 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		AttributeSection section;
@@ -2746,10 +2774,10 @@ out EventAddRemoveRegion eventAccessorDeclaration) {
 		
 		while (la.kind == 27) {
 			AttributeSection(
-#line  1199 "VBNET.ATG" 
+#line  1207 "VBNET.ATG" 
 out section);
 
-#line  1199 "VBNET.ATG" 
+#line  1207 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		if (la.kind == 42) {
@@ -2758,20 +2786,20 @@ out section);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1201 "VBNET.ATG" 
+#line  1209 "VBNET.ATG" 
 p);
 				}
 				Expect(25);
 			}
 			Expect(1);
 			Block(
-#line  1202 "VBNET.ATG" 
+#line  1210 "VBNET.ATG" 
 out stmt);
 			Expect(88);
 			Expect(42);
 			Expect(1);
 
-#line  1204 "VBNET.ATG" 
+#line  1212 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventAddRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -2782,20 +2810,20 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1209 "VBNET.ATG" 
+#line  1217 "VBNET.ATG" 
 p);
 				}
 				Expect(25);
 			}
 			Expect(1);
 			Block(
-#line  1210 "VBNET.ATG" 
+#line  1218 "VBNET.ATG" 
 out stmt);
 			Expect(88);
 			Expect(152);
 			Expect(1);
 
-#line  1212 "VBNET.ATG" 
+#line  1220 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRemoveRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -2806,185 +2834,185 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1217 "VBNET.ATG" 
+#line  1225 "VBNET.ATG" 
 p);
 				}
 				Expect(25);
 			}
 			Expect(1);
 			Block(
-#line  1218 "VBNET.ATG" 
+#line  1226 "VBNET.ATG" 
 out stmt);
 			Expect(88);
 			Expect(149);
 			Expect(1);
 
-#line  1220 "VBNET.ATG" 
+#line  1228 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRaiseRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
 			
-		} else SynErr(233);
+		} else SynErr(234);
 	}
 
 	void OverloadableOperator(
-#line  1133 "VBNET.ATG" 
+#line  1141 "VBNET.ATG" 
 out OverloadableOperatorType operatorType) {
 
-#line  1134 "VBNET.ATG" 
+#line  1142 "VBNET.ATG" 
 		operatorType = OverloadableOperatorType.None; 
 		switch (la.kind) {
 		case 14: {
 			lexer.NextToken();
 
-#line  1136 "VBNET.ATG" 
+#line  1144 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Add; 
 			break;
 		}
 		case 15: {
 			lexer.NextToken();
 
-#line  1138 "VBNET.ATG" 
+#line  1146 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Subtract; 
 			break;
 		}
 		case 16: {
 			lexer.NextToken();
 
-#line  1140 "VBNET.ATG" 
+#line  1148 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Multiply; 
 			break;
 		}
 		case 17: {
 			lexer.NextToken();
 
-#line  1142 "VBNET.ATG" 
+#line  1150 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Divide; 
 			break;
 		}
 		case 18: {
 			lexer.NextToken();
 
-#line  1144 "VBNET.ATG" 
+#line  1152 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.DivideInteger; 
 			break;
 		}
 		case 19: {
 			lexer.NextToken();
 
-#line  1146 "VBNET.ATG" 
+#line  1154 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Concat; 
 			break;
 		}
 		case 116: {
 			lexer.NextToken();
 
-#line  1148 "VBNET.ATG" 
+#line  1156 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Like; 
 			break;
 		}
 		case 120: {
 			lexer.NextToken();
 
-#line  1150 "VBNET.ATG" 
+#line  1158 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Modulus; 
 			break;
 		}
 		case 45: {
 			lexer.NextToken();
 
-#line  1152 "VBNET.ATG" 
+#line  1160 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseAnd; 
 			break;
 		}
 		case 138: {
 			lexer.NextToken();
 
-#line  1154 "VBNET.ATG" 
+#line  1162 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseOr; 
 			break;
 		}
 		case 185: {
 			lexer.NextToken();
 
-#line  1156 "VBNET.ATG" 
+#line  1164 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ExclusiveOr; 
 			break;
 		}
 		case 20: {
 			lexer.NextToken();
 
-#line  1158 "VBNET.ATG" 
+#line  1166 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Power; 
 			break;
 		}
 		case 31: {
 			lexer.NextToken();
 
-#line  1160 "VBNET.ATG" 
+#line  1168 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftLeft; 
 			break;
 		}
 		case 32: {
 			lexer.NextToken();
 
-#line  1162 "VBNET.ATG" 
+#line  1170 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftRight; 
 			break;
 		}
 		case 11: {
 			lexer.NextToken();
 
-#line  1164 "VBNET.ATG" 
+#line  1172 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Equality; 
 			break;
 		}
 		case 28: {
 			lexer.NextToken();
 
-#line  1166 "VBNET.ATG" 
+#line  1174 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.InEquality; 
 			break;
 		}
 		case 27: {
 			lexer.NextToken();
 
-#line  1168 "VBNET.ATG" 
+#line  1176 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThan; 
 			break;
 		}
 		case 30: {
 			lexer.NextToken();
 
-#line  1170 "VBNET.ATG" 
+#line  1178 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThanOrEqual; 
 			break;
 		}
 		case 26: {
 			lexer.NextToken();
 
-#line  1172 "VBNET.ATG" 
+#line  1180 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThan; 
 			break;
 		}
 		case 29: {
 			lexer.NextToken();
 
-#line  1174 "VBNET.ATG" 
+#line  1182 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThanOrEqual; 
 			break;
 		}
 		case 75: {
 			lexer.NextToken();
 
-#line  1176 "VBNET.ATG" 
+#line  1184 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.CType; 
 			break;
 		}
 		case 2: case 47: case 49: case 50: case 51: case 70: case 144: case 169: case 176: case 177: case 204: {
 			Identifier();
 
-#line  1180 "VBNET.ATG" 
+#line  1188 "VBNET.ATG" 
 			string opName = t.val; 
 			if (string.Equals(opName, "istrue", StringComparison.InvariantCultureIgnoreCase)) {
 				operatorType = OverloadableOperatorType.IsTrue;
@@ -2996,72 +3024,72 @@ out OverloadableOperatorType operatorType) {
 			
 			break;
 		}
-		default: SynErr(234); break;
+		default: SynErr(235); break;
 		}
 	}
 
 	void GetAccessorDecl(
-#line  1254 "VBNET.ATG" 
+#line  1262 "VBNET.ATG" 
 out PropertyGetRegion getBlock, List<AttributeSection> attributes) {
 
-#line  1255 "VBNET.ATG" 
+#line  1263 "VBNET.ATG" 
 		Statement stmt = null; Modifiers m; 
 		PropertyAccessorAccessModifier(
-#line  1257 "VBNET.ATG" 
+#line  1265 "VBNET.ATG" 
 out m);
 		Expect(101);
 
-#line  1259 "VBNET.ATG" 
+#line  1267 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		Expect(1);
 		Block(
-#line  1261 "VBNET.ATG" 
+#line  1269 "VBNET.ATG" 
 out stmt);
 
-#line  1262 "VBNET.ATG" 
+#line  1270 "VBNET.ATG" 
 		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); 
 		Expect(88);
 		Expect(101);
 
-#line  1264 "VBNET.ATG" 
+#line  1272 "VBNET.ATG" 
 		getBlock.Modifier = m; 
 
-#line  1265 "VBNET.ATG" 
+#line  1273 "VBNET.ATG" 
 		getBlock.StartLocation = startLocation; getBlock.EndLocation = t.EndLocation; 
 		Expect(1);
 	}
 
 	void SetAccessorDecl(
-#line  1270 "VBNET.ATG" 
+#line  1278 "VBNET.ATG" 
 out PropertySetRegion setBlock, List<AttributeSection> attributes) {
 
-#line  1272 "VBNET.ATG" 
+#line  1280 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		Modifiers m;
 		
 		PropertyAccessorAccessModifier(
-#line  1277 "VBNET.ATG" 
+#line  1285 "VBNET.ATG" 
 out m);
 		Expect(156);
 
-#line  1279 "VBNET.ATG" 
+#line  1287 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		if (la.kind == 24) {
 			lexer.NextToken();
 			if (StartOf(4)) {
 				FormalParameterList(
-#line  1280 "VBNET.ATG" 
+#line  1288 "VBNET.ATG" 
 p);
 			}
 			Expect(25);
 		}
 		Expect(1);
 		Block(
-#line  1282 "VBNET.ATG" 
+#line  1290 "VBNET.ATG" 
 out stmt);
 
-#line  1284 "VBNET.ATG" 
+#line  1292 "VBNET.ATG" 
 		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
 		setBlock.Modifier = m;
 		setBlock.Parameters = p;
@@ -3069,73 +3097,73 @@ out stmt);
 		Expect(88);
 		Expect(156);
 
-#line  1289 "VBNET.ATG" 
+#line  1297 "VBNET.ATG" 
 		setBlock.StartLocation = startLocation; setBlock.EndLocation = t.EndLocation; 
 		Expect(1);
 	}
 
 	void PropertyAccessorAccessModifier(
-#line  2831 "VBNET.ATG" 
+#line  2839 "VBNET.ATG" 
 out Modifiers m) {
 
-#line  2832 "VBNET.ATG" 
+#line  2840 "VBNET.ATG" 
 		m = Modifiers.None; 
-		while (StartOf(25)) {
+		while (StartOf(26)) {
 			if (la.kind == 148) {
 				lexer.NextToken();
 
-#line  2834 "VBNET.ATG" 
+#line  2842 "VBNET.ATG" 
 				m |= Modifiers.Public; 
 			} else if (la.kind == 147) {
 				lexer.NextToken();
 
-#line  2835 "VBNET.ATG" 
+#line  2843 "VBNET.ATG" 
 				m |= Modifiers.Protected; 
 			} else if (la.kind == 99) {
 				lexer.NextToken();
 
-#line  2836 "VBNET.ATG" 
+#line  2844 "VBNET.ATG" 
 				m |= Modifiers.Internal; 
 			} else {
 				lexer.NextToken();
 
-#line  2837 "VBNET.ATG" 
+#line  2845 "VBNET.ATG" 
 				m |= Modifiers.Private; 
 			}
 		}
 	}
 
 	void ArrayInitializationModifier(
-#line  1381 "VBNET.ATG" 
+#line  1389 "VBNET.ATG" 
 out List<Expression> arrayModifiers) {
 
-#line  1383 "VBNET.ATG" 
+#line  1391 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		Expect(24);
 		InitializationRankList(
-#line  1385 "VBNET.ATG" 
+#line  1393 "VBNET.ATG" 
 out arrayModifiers);
 		Expect(25);
 	}
 
 	void ArrayNameModifier(
-#line  1957 "VBNET.ATG" 
+#line  1965 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  1959 "VBNET.ATG" 
+#line  1967 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		ArrayTypeModifiers(
-#line  1961 "VBNET.ATG" 
+#line  1969 "VBNET.ATG" 
 out arrayModifiers);
 	}
 
 	void ObjectCreateExpression(
-#line  1810 "VBNET.ATG" 
+#line  1818 "VBNET.ATG" 
 out Expression oce) {
 
-#line  1812 "VBNET.ATG" 
+#line  1820 "VBNET.ATG" 
 		TypeReference type = null;
 		Expression initializer = null;
 		List<Expression> arguments = null;
@@ -3145,38 +3173,38 @@ out Expression oce) {
 		
 		Expect(127);
 		NonArrayTypeName(
-#line  1819 "VBNET.ATG" 
+#line  1827 "VBNET.ATG" 
 out type, false);
 		if (la.kind == 24) {
 			lexer.NextToken();
 			NormalOrReDimArgumentList(
-#line  1820 "VBNET.ATG" 
+#line  1828 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeReDim);
 			Expect(25);
 			if (la.kind == 22 || 
-#line  1821 "VBNET.ATG" 
+#line  1829 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 				if (
-#line  1821 "VBNET.ATG" 
+#line  1829 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 					ArrayTypeModifiers(
-#line  1822 "VBNET.ATG" 
+#line  1830 "VBNET.ATG" 
 out dimensions);
 					ArrayInitializer(
-#line  1823 "VBNET.ATG" 
+#line  1831 "VBNET.ATG" 
 out initializer);
 				} else {
 					ArrayInitializer(
-#line  1824 "VBNET.ATG" 
+#line  1832 "VBNET.ATG" 
 out initializer);
 				}
 			}
 
-#line  1826 "VBNET.ATG" 
+#line  1834 "VBNET.ATG" 
 			if (canBeReDim && !canBeNormal && initializer == null) initializer = new ArrayInitializerExpression(); 
 		}
 
-#line  1829 "VBNET.ATG" 
+#line  1837 "VBNET.ATG" 
 		if (type == null) type = new TypeReference("Object"); // fallback type on parser errors
 		if (initializer == null) {
 			oce = new ObjectCreateExpression(type, arguments);
@@ -3192,430 +3220,430 @@ out initializer);
 	}
 
 	void VariableInitializer(
-#line  1409 "VBNET.ATG" 
+#line  1417 "VBNET.ATG" 
 out Expression initializerExpression) {
 
-#line  1411 "VBNET.ATG" 
+#line  1419 "VBNET.ATG" 
 		initializerExpression = null;
 		
-		if (StartOf(26)) {
+		if (StartOf(27)) {
 			Expr(
-#line  1413 "VBNET.ATG" 
+#line  1421 "VBNET.ATG" 
 out initializerExpression);
 		} else if (la.kind == 22) {
 			ArrayInitializer(
-#line  1414 "VBNET.ATG" 
+#line  1422 "VBNET.ATG" 
 out initializerExpression);
-		} else SynErr(235);
+		} else SynErr(236);
 	}
 
 	void InitializationRankList(
-#line  1389 "VBNET.ATG" 
+#line  1397 "VBNET.ATG" 
 out List<Expression> rank) {
 
-#line  1391 "VBNET.ATG" 
+#line  1399 "VBNET.ATG" 
 		rank = new List<Expression>();
 		Expression expr = null;
 		
 		Expr(
-#line  1394 "VBNET.ATG" 
+#line  1402 "VBNET.ATG" 
 out expr);
 		if (la.kind == 172) {
 			lexer.NextToken();
 
-#line  1395 "VBNET.ATG" 
+#line  1403 "VBNET.ATG" 
 			EnsureIsZero(expr); 
 			Expr(
-#line  1396 "VBNET.ATG" 
+#line  1404 "VBNET.ATG" 
 out expr);
 		}
 
-#line  1398 "VBNET.ATG" 
+#line  1406 "VBNET.ATG" 
 		if (expr != null) { rank.Add(expr); } 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			Expr(
-#line  1400 "VBNET.ATG" 
+#line  1408 "VBNET.ATG" 
 out expr);
 			if (la.kind == 172) {
 				lexer.NextToken();
 
-#line  1401 "VBNET.ATG" 
+#line  1409 "VBNET.ATG" 
 				EnsureIsZero(expr); 
 				Expr(
-#line  1402 "VBNET.ATG" 
+#line  1410 "VBNET.ATG" 
 out expr);
 			}
 
-#line  1404 "VBNET.ATG" 
+#line  1412 "VBNET.ATG" 
 			if (expr != null) { rank.Add(expr); } 
 		}
 	}
 
 	void ArrayInitializer(
-#line  1418 "VBNET.ATG" 
+#line  1426 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1420 "VBNET.ATG" 
+#line  1428 "VBNET.ATG" 
 		Expression expr = null;
 		ArrayInitializerExpression initializer = new ArrayInitializerExpression();
 		
 		Expect(22);
-		if (StartOf(27)) {
+		if (StartOf(28)) {
 			VariableInitializer(
-#line  1425 "VBNET.ATG" 
+#line  1433 "VBNET.ATG" 
 out expr);
 
-#line  1427 "VBNET.ATG" 
+#line  1435 "VBNET.ATG" 
 			if (expr != null) { initializer.CreateExpressions.Add(expr); }
 			
 			while (
-#line  1430 "VBNET.ATG" 
+#line  1438 "VBNET.ATG" 
 NotFinalComma()) {
 				Expect(12);
 				VariableInitializer(
-#line  1430 "VBNET.ATG" 
+#line  1438 "VBNET.ATG" 
 out expr);
 
-#line  1431 "VBNET.ATG" 
+#line  1439 "VBNET.ATG" 
 				if (expr != null) { initializer.CreateExpressions.Add(expr); } 
 			}
 		}
 		Expect(23);
 
-#line  1434 "VBNET.ATG" 
+#line  1442 "VBNET.ATG" 
 		outExpr = initializer; 
 	}
 
 	void EventMemberSpecifier(
-#line  1504 "VBNET.ATG" 
+#line  1512 "VBNET.ATG" 
 out string name) {
 
-#line  1505 "VBNET.ATG" 
+#line  1513 "VBNET.ATG" 
 		string type; name = String.Empty; 
-		if (StartOf(12)) {
+		if (StartOf(13)) {
 			Identifier();
 
-#line  1506 "VBNET.ATG" 
+#line  1514 "VBNET.ATG" 
 			type = t.val; 
 			Expect(10);
 			Identifier();
 
-#line  1508 "VBNET.ATG" 
+#line  1516 "VBNET.ATG" 
 			name = type + "." + t.val; 
 		} else if (la.kind == 124) {
 			lexer.NextToken();
 			Expect(10);
-			if (StartOf(12)) {
+			if (StartOf(13)) {
 				Identifier();
 
-#line  1511 "VBNET.ATG" 
+#line  1519 "VBNET.ATG" 
 				name = "MyBase." + t.val; 
 			} else if (la.kind == 92) {
 				lexer.NextToken();
 
-#line  1512 "VBNET.ATG" 
+#line  1520 "VBNET.ATG" 
 				name = "MyBase.Error"; 
-			} else SynErr(236);
-		} else SynErr(237);
+			} else SynErr(237);
+		} else SynErr(238);
 	}
 
 	void DisjunctionExpr(
-#line  1654 "VBNET.ATG" 
+#line  1662 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1656 "VBNET.ATG" 
+#line  1664 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ConjunctionExpr(
-#line  1659 "VBNET.ATG" 
+#line  1667 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 138 || la.kind == 139 || la.kind == 185) {
 			if (la.kind == 138) {
 				lexer.NextToken();
 
-#line  1662 "VBNET.ATG" 
+#line  1670 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseOr; 
 			} else if (la.kind == 139) {
 				lexer.NextToken();
 
-#line  1663 "VBNET.ATG" 
+#line  1671 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalOr; 
 			} else {
 				lexer.NextToken();
 
-#line  1664 "VBNET.ATG" 
+#line  1672 "VBNET.ATG" 
 				op = BinaryOperatorType.ExclusiveOr; 
 			}
 			ConjunctionExpr(
-#line  1666 "VBNET.ATG" 
+#line  1674 "VBNET.ATG" 
 out expr);
 
-#line  1666 "VBNET.ATG" 
+#line  1674 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void AssignmentOperator(
-#line  1521 "VBNET.ATG" 
+#line  1529 "VBNET.ATG" 
 out AssignmentOperatorType op) {
 
-#line  1522 "VBNET.ATG" 
+#line  1530 "VBNET.ATG" 
 		op = AssignmentOperatorType.None; 
 		switch (la.kind) {
 		case 11: {
 			lexer.NextToken();
 
-#line  1523 "VBNET.ATG" 
+#line  1531 "VBNET.ATG" 
 			op = AssignmentOperatorType.Assign; 
 			break;
 		}
 		case 41: {
 			lexer.NextToken();
 
-#line  1524 "VBNET.ATG" 
+#line  1532 "VBNET.ATG" 
 			op = AssignmentOperatorType.ConcatString; 
 			break;
 		}
 		case 33: {
 			lexer.NextToken();
 
-#line  1525 "VBNET.ATG" 
+#line  1533 "VBNET.ATG" 
 			op = AssignmentOperatorType.Add; 
 			break;
 		}
 		case 35: {
 			lexer.NextToken();
 
-#line  1526 "VBNET.ATG" 
+#line  1534 "VBNET.ATG" 
 			op = AssignmentOperatorType.Subtract; 
 			break;
 		}
 		case 36: {
 			lexer.NextToken();
 
-#line  1527 "VBNET.ATG" 
+#line  1535 "VBNET.ATG" 
 			op = AssignmentOperatorType.Multiply; 
 			break;
 		}
 		case 37: {
 			lexer.NextToken();
 
-#line  1528 "VBNET.ATG" 
+#line  1536 "VBNET.ATG" 
 			op = AssignmentOperatorType.Divide; 
 			break;
 		}
 		case 38: {
 			lexer.NextToken();
 
-#line  1529 "VBNET.ATG" 
+#line  1537 "VBNET.ATG" 
 			op = AssignmentOperatorType.DivideInteger; 
 			break;
 		}
 		case 34: {
 			lexer.NextToken();
 
-#line  1530 "VBNET.ATG" 
+#line  1538 "VBNET.ATG" 
 			op = AssignmentOperatorType.Power; 
 			break;
 		}
 		case 39: {
 			lexer.NextToken();
 
-#line  1531 "VBNET.ATG" 
+#line  1539 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftLeft; 
 			break;
 		}
 		case 40: {
 			lexer.NextToken();
 
-#line  1532 "VBNET.ATG" 
+#line  1540 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftRight; 
 			break;
 		}
-		default: SynErr(238); break;
+		default: SynErr(239); break;
 		}
 	}
 
 	void SimpleExpr(
-#line  1536 "VBNET.ATG" 
+#line  1544 "VBNET.ATG" 
 out Expression pexpr) {
 		SimpleNonInvocationExpression(
-#line  1538 "VBNET.ATG" 
+#line  1546 "VBNET.ATG" 
 out pexpr);
 		while (la.kind == 10 || la.kind == 24) {
 			if (la.kind == 10) {
 
-#line  1539 "VBNET.ATG" 
+#line  1547 "VBNET.ATG" 
 				string name; 
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  1540 "VBNET.ATG" 
+#line  1548 "VBNET.ATG" 
 out name);
 
-#line  1540 "VBNET.ATG" 
+#line  1548 "VBNET.ATG" 
 				pexpr = new FieldReferenceExpression(pexpr, name); 
 			} else {
 				InvocationExpression(
-#line  1541 "VBNET.ATG" 
+#line  1549 "VBNET.ATG" 
 ref pexpr);
 			}
 		}
 	}
 
 	void SimpleNonInvocationExpression(
-#line  1545 "VBNET.ATG" 
+#line  1553 "VBNET.ATG" 
 out Expression pexpr) {
 
-#line  1547 "VBNET.ATG" 
+#line  1555 "VBNET.ATG" 
 		Expression expr;
 		TypeReference type = null;
 		string name = String.Empty;
 		pexpr = null;
 		
-		if (StartOf(28)) {
+		if (StartOf(29)) {
 			switch (la.kind) {
 			case 3: {
 				lexer.NextToken();
 
-#line  1555 "VBNET.ATG" 
+#line  1563 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 				break;
 			}
 			case 4: {
 				lexer.NextToken();
 
-#line  1556 "VBNET.ATG" 
+#line  1564 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 				break;
 			}
 			case 7: {
 				lexer.NextToken();
 
-#line  1557 "VBNET.ATG" 
+#line  1565 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 				break;
 			}
 			case 6: {
 				lexer.NextToken();
 
-#line  1558 "VBNET.ATG" 
+#line  1566 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 				break;
 			}
 			case 5: {
 				lexer.NextToken();
 
-#line  1559 "VBNET.ATG" 
+#line  1567 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 				break;
 			}
 			case 9: {
 				lexer.NextToken();
 
-#line  1560 "VBNET.ATG" 
+#line  1568 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 				break;
 			}
 			case 8: {
 				lexer.NextToken();
 
-#line  1561 "VBNET.ATG" 
+#line  1569 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 				break;
 			}
 			case 173: {
 				lexer.NextToken();
 
-#line  1563 "VBNET.ATG" 
+#line  1571 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(true, "true");  
 				break;
 			}
 			case 96: {
 				lexer.NextToken();
 
-#line  1564 "VBNET.ATG" 
+#line  1572 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(false, "false"); 
 				break;
 			}
 			case 130: {
 				lexer.NextToken();
 
-#line  1565 "VBNET.ATG" 
+#line  1573 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(null, "null");  
 				break;
 			}
 			case 24: {
 				lexer.NextToken();
 				Expr(
-#line  1566 "VBNET.ATG" 
+#line  1574 "VBNET.ATG" 
 out expr);
 				Expect(25);
 
-#line  1566 "VBNET.ATG" 
+#line  1574 "VBNET.ATG" 
 				pexpr = new ParenthesizedExpression(expr); 
 				break;
 			}
 			case 2: case 47: case 49: case 50: case 51: case 70: case 144: case 169: case 176: case 177: case 204: {
 				Identifier();
 
-#line  1567 "VBNET.ATG" 
+#line  1575 "VBNET.ATG" 
 				pexpr = new IdentifierExpression(t.val); 
 				break;
 			}
 			case 52: case 54: case 65: case 76: case 77: case 84: case 111: case 117: case 133: case 159: case 160: case 165: case 190: case 191: case 192: case 193: {
 
-#line  1568 "VBNET.ATG" 
+#line  1576 "VBNET.ATG" 
 				string val = String.Empty; 
-				if (StartOf(9)) {
+				if (StartOf(10)) {
 					PrimitiveTypeName(
-#line  1569 "VBNET.ATG" 
+#line  1577 "VBNET.ATG" 
 out val);
 				} else if (la.kind == 133) {
 					lexer.NextToken();
 
-#line  1569 "VBNET.ATG" 
+#line  1577 "VBNET.ATG" 
 					val = "Object"; 
-				} else SynErr(239);
+				} else SynErr(240);
 				Expect(10);
 
-#line  1570 "VBNET.ATG" 
+#line  1578 "VBNET.ATG" 
 				t.val = ""; 
 				Identifier();
 
-#line  1570 "VBNET.ATG" 
+#line  1578 "VBNET.ATG" 
 				pexpr = new FieldReferenceExpression(new TypeReferenceExpression(val), t.val); 
 				break;
 			}
 			case 119: {
 				lexer.NextToken();
 
-#line  1571 "VBNET.ATG" 
+#line  1579 "VBNET.ATG" 
 				pexpr = new ThisReferenceExpression(); 
 				break;
 			}
 			case 124: case 125: {
 
-#line  1572 "VBNET.ATG" 
+#line  1580 "VBNET.ATG" 
 				Expression retExpr = null; 
 				if (la.kind == 124) {
 					lexer.NextToken();
 
-#line  1573 "VBNET.ATG" 
+#line  1581 "VBNET.ATG" 
 					retExpr = new BaseReferenceExpression(); 
 				} else if (la.kind == 125) {
 					lexer.NextToken();
 
-#line  1574 "VBNET.ATG" 
+#line  1582 "VBNET.ATG" 
 					retExpr = new ClassReferenceExpression(); 
-				} else SynErr(240);
+				} else SynErr(241);
 				Expect(10);
 				IdentifierOrKeyword(
-#line  1576 "VBNET.ATG" 
+#line  1584 "VBNET.ATG" 
 out name);
 
-#line  1576 "VBNET.ATG" 
+#line  1584 "VBNET.ATG" 
 				pexpr = new FieldReferenceExpression(retExpr, name); 
 				break;
 			}
@@ -3624,77 +3652,77 @@ out name);
 				Expect(10);
 				Identifier();
 
-#line  1578 "VBNET.ATG" 
+#line  1586 "VBNET.ATG" 
 				type = new TypeReference(t.val ?? ""); 
 
-#line  1580 "VBNET.ATG" 
+#line  1588 "VBNET.ATG" 
 				type.IsGlobal = true; 
 
-#line  1581 "VBNET.ATG" 
+#line  1589 "VBNET.ATG" 
 				pexpr = new TypeReferenceExpression(type); 
 				break;
 			}
 			case 127: {
 				ObjectCreateExpression(
-#line  1582 "VBNET.ATG" 
+#line  1590 "VBNET.ATG" 
 out expr);
 
-#line  1582 "VBNET.ATG" 
+#line  1590 "VBNET.ATG" 
 				pexpr = expr; 
 				break;
 			}
 			case 75: case 82: case 199: {
 
-#line  1584 "VBNET.ATG" 
+#line  1592 "VBNET.ATG" 
 				CastType castType = CastType.Cast; 
 				if (la.kind == 82) {
 					lexer.NextToken();
 				} else if (la.kind == 75) {
 					lexer.NextToken();
 
-#line  1586 "VBNET.ATG" 
+#line  1594 "VBNET.ATG" 
 					castType = CastType.Conversion; 
 				} else if (la.kind == 199) {
 					lexer.NextToken();
 
-#line  1587 "VBNET.ATG" 
+#line  1595 "VBNET.ATG" 
 					castType = CastType.TryCast; 
-				} else SynErr(241);
+				} else SynErr(242);
 				Expect(24);
 				Expr(
-#line  1589 "VBNET.ATG" 
+#line  1597 "VBNET.ATG" 
 out expr);
 				Expect(12);
 				TypeName(
-#line  1589 "VBNET.ATG" 
+#line  1597 "VBNET.ATG" 
 out type);
 				Expect(25);
 
-#line  1590 "VBNET.ATG" 
+#line  1598 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, castType); 
 				break;
 			}
 			case 59: case 60: case 61: case 62: case 63: case 64: case 66: case 68: case 69: case 72: case 73: case 74: case 194: case 195: case 196: case 197: {
 				CastTarget(
-#line  1591 "VBNET.ATG" 
+#line  1599 "VBNET.ATG" 
 out type);
 				Expect(24);
 				Expr(
-#line  1591 "VBNET.ATG" 
+#line  1599 "VBNET.ATG" 
 out expr);
 				Expect(25);
 
-#line  1591 "VBNET.ATG" 
+#line  1599 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); 
 				break;
 			}
 			case 43: {
 				lexer.NextToken();
 				Expr(
-#line  1592 "VBNET.ATG" 
+#line  1600 "VBNET.ATG" 
 out expr);
 
-#line  1592 "VBNET.ATG" 
+#line  1600 "VBNET.ATG" 
 				pexpr = new AddressOfExpression(expr); 
 				break;
 			}
@@ -3702,25 +3730,25 @@ out expr);
 				lexer.NextToken();
 				Expect(24);
 				GetTypeTypeName(
-#line  1593 "VBNET.ATG" 
+#line  1601 "VBNET.ATG" 
 out type);
 				Expect(25);
 
-#line  1593 "VBNET.ATG" 
+#line  1601 "VBNET.ATG" 
 				pexpr = new TypeOfExpression(type); 
 				break;
 			}
 			case 175: {
 				lexer.NextToken();
 				SimpleExpr(
-#line  1594 "VBNET.ATG" 
+#line  1602 "VBNET.ATG" 
 out expr);
 				Expect(113);
 				TypeName(
-#line  1594 "VBNET.ATG" 
+#line  1602 "VBNET.ATG" 
 out type);
 
-#line  1594 "VBNET.ATG" 
+#line  1602 "VBNET.ATG" 
 				pexpr = new TypeOfIsExpression(expr, type); 
 				break;
 			}
@@ -3728,49 +3756,49 @@ out type);
 		} else if (la.kind == 10) {
 			lexer.NextToken();
 			IdentifierOrKeyword(
-#line  1598 "VBNET.ATG" 
+#line  1606 "VBNET.ATG" 
 out name);
 
-#line  1598 "VBNET.ATG" 
+#line  1606 "VBNET.ATG" 
 			pexpr = new FieldReferenceExpression(null, name);
-		} else SynErr(242);
+		} else SynErr(243);
 	}
 
 	void IdentifierOrKeyword(
-#line  2765 "VBNET.ATG" 
+#line  2773 "VBNET.ATG" 
 out string name) {
 
-#line  2767 "VBNET.ATG" 
+#line  2775 "VBNET.ATG" 
 		lexer.NextToken(); name = t.val;  
 	}
 
 	void InvocationExpression(
-#line  1602 "VBNET.ATG" 
+#line  1610 "VBNET.ATG" 
 ref Expression pexpr) {
 
-#line  1603 "VBNET.ATG" 
+#line  1611 "VBNET.ATG" 
 		List<TypeReference> typeParameters = new List<TypeReference>();
 		List<Expression> parameters = null;
 		TypeReference type; 
 		Expect(24);
 
-#line  1607 "VBNET.ATG" 
+#line  1615 "VBNET.ATG" 
 		Location start = t.Location; 
 		if (la.kind == 200) {
 			lexer.NextToken();
 			TypeName(
-#line  1609 "VBNET.ATG" 
+#line  1617 "VBNET.ATG" 
 out type);
 
-#line  1609 "VBNET.ATG" 
+#line  1617 "VBNET.ATG" 
 			if (type != null) typeParameters.Add(type); 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				TypeName(
-#line  1612 "VBNET.ATG" 
+#line  1620 "VBNET.ATG" 
 out type);
 
-#line  1612 "VBNET.ATG" 
+#line  1620 "VBNET.ATG" 
 				if (type != null) typeParameters.Add(type); 
 			}
 			Expect(25);
@@ -3778,286 +3806,286 @@ out type);
 				lexer.NextToken();
 				Identifier();
 
-#line  1617 "VBNET.ATG" 
+#line  1625 "VBNET.ATG" 
 				pexpr = new FieldReferenceExpression(GetTypeReferenceExpression(pexpr, typeParameters), t.val); 
 			} else if (la.kind == 24) {
 				lexer.NextToken();
 				ArgumentList(
-#line  1619 "VBNET.ATG" 
+#line  1627 "VBNET.ATG" 
 out parameters);
 				Expect(25);
 
-#line  1621 "VBNET.ATG" 
+#line  1629 "VBNET.ATG" 
 				pexpr = new InvocationExpression(pexpr, parameters, typeParameters); 
-			} else SynErr(243);
-		} else if (StartOf(29)) {
+			} else SynErr(244);
+		} else if (StartOf(30)) {
 			ArgumentList(
-#line  1623 "VBNET.ATG" 
+#line  1631 "VBNET.ATG" 
 out parameters);
 			Expect(25);
 
-#line  1625 "VBNET.ATG" 
+#line  1633 "VBNET.ATG" 
 			pexpr = new InvocationExpression(pexpr, parameters, typeParameters); 
-		} else SynErr(244);
+		} else SynErr(245);
 
-#line  1627 "VBNET.ATG" 
+#line  1635 "VBNET.ATG" 
 		pexpr.StartLocation = start; pexpr.EndLocation = t.Location; 
 	}
 
 	void PrimitiveTypeName(
-#line  2772 "VBNET.ATG" 
+#line  2780 "VBNET.ATG" 
 out string type) {
 
-#line  2773 "VBNET.ATG" 
+#line  2781 "VBNET.ATG" 
 		type = String.Empty; 
 		switch (la.kind) {
 		case 52: {
 			lexer.NextToken();
 
-#line  2774 "VBNET.ATG" 
+#line  2782 "VBNET.ATG" 
 			type = "Boolean"; 
 			break;
 		}
 		case 76: {
 			lexer.NextToken();
 
-#line  2775 "VBNET.ATG" 
+#line  2783 "VBNET.ATG" 
 			type = "Date"; 
 			break;
 		}
 		case 65: {
 			lexer.NextToken();
 
-#line  2776 "VBNET.ATG" 
+#line  2784 "VBNET.ATG" 
 			type = "Char"; 
 			break;
 		}
 		case 165: {
 			lexer.NextToken();
 
-#line  2777 "VBNET.ATG" 
+#line  2785 "VBNET.ATG" 
 			type = "String"; 
 			break;
 		}
 		case 77: {
 			lexer.NextToken();
 
-#line  2778 "VBNET.ATG" 
+#line  2786 "VBNET.ATG" 
 			type = "Decimal"; 
 			break;
 		}
 		case 54: {
 			lexer.NextToken();
 
-#line  2779 "VBNET.ATG" 
+#line  2787 "VBNET.ATG" 
 			type = "Byte"; 
 			break;
 		}
 		case 159: {
 			lexer.NextToken();
 
-#line  2780 "VBNET.ATG" 
+#line  2788 "VBNET.ATG" 
 			type = "Short"; 
 			break;
 		}
 		case 111: {
 			lexer.NextToken();
 
-#line  2781 "VBNET.ATG" 
+#line  2789 "VBNET.ATG" 
 			type = "Integer"; 
 			break;
 		}
 		case 117: {
 			lexer.NextToken();
 
-#line  2782 "VBNET.ATG" 
+#line  2790 "VBNET.ATG" 
 			type = "Long"; 
 			break;
 		}
 		case 160: {
 			lexer.NextToken();
 
-#line  2783 "VBNET.ATG" 
+#line  2791 "VBNET.ATG" 
 			type = "Single"; 
 			break;
 		}
 		case 84: {
 			lexer.NextToken();
 
-#line  2784 "VBNET.ATG" 
+#line  2792 "VBNET.ATG" 
 			type = "Double"; 
 			break;
 		}
 		case 191: {
 			lexer.NextToken();
 
-#line  2785 "VBNET.ATG" 
+#line  2793 "VBNET.ATG" 
 			type = "UInteger"; 
 			break;
 		}
 		case 192: {
 			lexer.NextToken();
 
-#line  2786 "VBNET.ATG" 
+#line  2794 "VBNET.ATG" 
 			type = "ULong"; 
 			break;
 		}
 		case 193: {
 			lexer.NextToken();
 
-#line  2787 "VBNET.ATG" 
+#line  2795 "VBNET.ATG" 
 			type = "UShort"; 
 			break;
 		}
 		case 190: {
 			lexer.NextToken();
 
-#line  2788 "VBNET.ATG" 
+#line  2796 "VBNET.ATG" 
 			type = "SByte"; 
 			break;
 		}
-		default: SynErr(245); break;
+		default: SynErr(246); break;
 		}
 	}
 
 	void CastTarget(
-#line  1632 "VBNET.ATG" 
+#line  1640 "VBNET.ATG" 
 out TypeReference type) {
 
-#line  1634 "VBNET.ATG" 
+#line  1642 "VBNET.ATG" 
 		type = null;
 		
 		switch (la.kind) {
 		case 59: {
 			lexer.NextToken();
 
-#line  1636 "VBNET.ATG" 
+#line  1644 "VBNET.ATG" 
 			type = new TypeReference("System.Boolean"); 
 			break;
 		}
 		case 60: {
 			lexer.NextToken();
 
-#line  1637 "VBNET.ATG" 
+#line  1645 "VBNET.ATG" 
 			type = new TypeReference("System.Byte"); 
 			break;
 		}
 		case 194: {
 			lexer.NextToken();
 
-#line  1638 "VBNET.ATG" 
+#line  1646 "VBNET.ATG" 
 			type = new TypeReference("System.SByte"); 
 			break;
 		}
 		case 61: {
 			lexer.NextToken();
 
-#line  1639 "VBNET.ATG" 
+#line  1647 "VBNET.ATG" 
 			type = new TypeReference("System.Char"); 
 			break;
 		}
 		case 62: {
 			lexer.NextToken();
 
-#line  1640 "VBNET.ATG" 
+#line  1648 "VBNET.ATG" 
 			type = new TypeReference("System.DateTime"); 
 			break;
 		}
 		case 64: {
 			lexer.NextToken();
 
-#line  1641 "VBNET.ATG" 
+#line  1649 "VBNET.ATG" 
 			type = new TypeReference("System.Decimal"); 
 			break;
 		}
 		case 63: {
 			lexer.NextToken();
 
-#line  1642 "VBNET.ATG" 
+#line  1650 "VBNET.ATG" 
 			type = new TypeReference("System.Double"); 
 			break;
 		}
 		case 72: {
 			lexer.NextToken();
 
-#line  1643 "VBNET.ATG" 
+#line  1651 "VBNET.ATG" 
 			type = new TypeReference("System.Int16"); 
 			break;
 		}
 		case 66: {
 			lexer.NextToken();
 
-#line  1644 "VBNET.ATG" 
+#line  1652 "VBNET.ATG" 
 			type = new TypeReference("System.Int32"); 
 			break;
 		}
 		case 68: {
 			lexer.NextToken();
 
-#line  1645 "VBNET.ATG" 
+#line  1653 "VBNET.ATG" 
 			type = new TypeReference("System.Int64"); 
 			break;
 		}
 		case 195: {
 			lexer.NextToken();
 
-#line  1646 "VBNET.ATG" 
+#line  1654 "VBNET.ATG" 
 			type = new TypeReference("System.UInt16"); 
 			break;
 		}
 		case 196: {
 			lexer.NextToken();
 
-#line  1647 "VBNET.ATG" 
+#line  1655 "VBNET.ATG" 
 			type = new TypeReference("System.UInt32"); 
 			break;
 		}
 		case 197: {
 			lexer.NextToken();
 
-#line  1648 "VBNET.ATG" 
+#line  1656 "VBNET.ATG" 
 			type = new TypeReference("System.UInt64"); 
 			break;
 		}
 		case 69: {
 			lexer.NextToken();
 
-#line  1649 "VBNET.ATG" 
+#line  1657 "VBNET.ATG" 
 			type = new TypeReference("System.Object"); 
 			break;
 		}
 		case 73: {
 			lexer.NextToken();
 
-#line  1650 "VBNET.ATG" 
+#line  1658 "VBNET.ATG" 
 			type = new TypeReference("System.Single"); 
 			break;
 		}
 		case 74: {
 			lexer.NextToken();
 
-#line  1651 "VBNET.ATG" 
+#line  1659 "VBNET.ATG" 
 			type = new TypeReference("System.String"); 
 			break;
 		}
-		default: SynErr(246); break;
+		default: SynErr(247); break;
 		}
 	}
 
 	void GetTypeTypeName(
-#line  1909 "VBNET.ATG" 
+#line  1917 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  1910 "VBNET.ATG" 
+#line  1918 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  1912 "VBNET.ATG" 
+#line  1920 "VBNET.ATG" 
 out typeref, true);
 		ArrayTypeModifiers(
-#line  1913 "VBNET.ATG" 
+#line  1921 "VBNET.ATG" 
 out rank);
 
-#line  1914 "VBNET.ATG" 
+#line  1922 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -4065,348 +4093,348 @@ out rank);
 	}
 
 	void ArgumentList(
-#line  1844 "VBNET.ATG" 
+#line  1852 "VBNET.ATG" 
 out List<Expression> arguments) {
 
-#line  1846 "VBNET.ATG" 
+#line  1854 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		Expression expr = null;
 		
-		if (StartOf(26)) {
+		if (StartOf(27)) {
 			Argument(
-#line  1849 "VBNET.ATG" 
+#line  1857 "VBNET.ATG" 
 out expr);
 		}
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  1850 "VBNET.ATG" 
+#line  1858 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
-			if (StartOf(26)) {
+			if (StartOf(27)) {
 				Argument(
-#line  1851 "VBNET.ATG" 
+#line  1859 "VBNET.ATG" 
 out expr);
 			}
 
-#line  1852 "VBNET.ATG" 
+#line  1860 "VBNET.ATG" 
 			if (expr == null) expr = Expression.Null; 
 		}
 
-#line  1854 "VBNET.ATG" 
+#line  1862 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); 
 	}
 
 	void ConjunctionExpr(
-#line  1670 "VBNET.ATG" 
+#line  1678 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1672 "VBNET.ATG" 
+#line  1680 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		NotExpr(
-#line  1675 "VBNET.ATG" 
+#line  1683 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 45 || la.kind == 46) {
 			if (la.kind == 45) {
 				lexer.NextToken();
 
-#line  1678 "VBNET.ATG" 
+#line  1686 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseAnd; 
 			} else {
 				lexer.NextToken();
 
-#line  1679 "VBNET.ATG" 
+#line  1687 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalAnd; 
 			}
 			NotExpr(
-#line  1681 "VBNET.ATG" 
+#line  1689 "VBNET.ATG" 
 out expr);
 
-#line  1681 "VBNET.ATG" 
+#line  1689 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void NotExpr(
-#line  1685 "VBNET.ATG" 
+#line  1693 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1686 "VBNET.ATG" 
+#line  1694 "VBNET.ATG" 
 		UnaryOperatorType uop = UnaryOperatorType.None; 
 		while (la.kind == 129) {
 			lexer.NextToken();
 
-#line  1687 "VBNET.ATG" 
+#line  1695 "VBNET.ATG" 
 			uop = UnaryOperatorType.Not; 
 		}
 		ComparisonExpr(
-#line  1688 "VBNET.ATG" 
+#line  1696 "VBNET.ATG" 
 out outExpr);
 
-#line  1689 "VBNET.ATG" 
+#line  1697 "VBNET.ATG" 
 		if (uop != UnaryOperatorType.None)
 		outExpr = new UnaryOperatorExpression(outExpr, uop);
 		
 	}
 
 	void ComparisonExpr(
-#line  1694 "VBNET.ATG" 
+#line  1702 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1696 "VBNET.ATG" 
+#line  1704 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ShiftExpr(
-#line  1699 "VBNET.ATG" 
+#line  1707 "VBNET.ATG" 
 out outExpr);
-		while (StartOf(30)) {
+		while (StartOf(31)) {
 			switch (la.kind) {
 			case 27: {
 				lexer.NextToken();
 
-#line  1702 "VBNET.ATG" 
+#line  1710 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 26: {
 				lexer.NextToken();
 
-#line  1703 "VBNET.ATG" 
+#line  1711 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 30: {
 				lexer.NextToken();
 
-#line  1704 "VBNET.ATG" 
+#line  1712 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 29: {
 				lexer.NextToken();
 
-#line  1705 "VBNET.ATG" 
+#line  1713 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 28: {
 				lexer.NextToken();
 
-#line  1706 "VBNET.ATG" 
+#line  1714 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			case 11: {
 				lexer.NextToken();
 
-#line  1707 "VBNET.ATG" 
+#line  1715 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 116: {
 				lexer.NextToken();
 
-#line  1708 "VBNET.ATG" 
+#line  1716 "VBNET.ATG" 
 				op = BinaryOperatorType.Like; 
 				break;
 			}
 			case 113: {
 				lexer.NextToken();
 
-#line  1709 "VBNET.ATG" 
+#line  1717 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceEquality; 
 				break;
 			}
 			case 189: {
 				lexer.NextToken();
 
-#line  1710 "VBNET.ATG" 
+#line  1718 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceInequality; 
 				break;
 			}
 			}
-			if (StartOf(31)) {
+			if (StartOf(32)) {
 				ShiftExpr(
-#line  1713 "VBNET.ATG" 
+#line  1721 "VBNET.ATG" 
 out expr);
 
-#line  1713 "VBNET.ATG" 
+#line  1721 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 			} else if (la.kind == 129) {
 				lexer.NextToken();
 				ShiftExpr(
-#line  1716 "VBNET.ATG" 
+#line  1724 "VBNET.ATG" 
 out expr);
 
-#line  1716 "VBNET.ATG" 
+#line  1724 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not));  
-			} else SynErr(247);
+			} else SynErr(248);
 		}
 	}
 
 	void ShiftExpr(
-#line  1721 "VBNET.ATG" 
+#line  1729 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1723 "VBNET.ATG" 
+#line  1731 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ConcatenationExpr(
-#line  1726 "VBNET.ATG" 
+#line  1734 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 31 || la.kind == 32) {
 			if (la.kind == 31) {
 				lexer.NextToken();
 
-#line  1729 "VBNET.ATG" 
+#line  1737 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftLeft; 
 			} else {
 				lexer.NextToken();
 
-#line  1730 "VBNET.ATG" 
+#line  1738 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftRight; 
 			}
 			ConcatenationExpr(
-#line  1732 "VBNET.ATG" 
+#line  1740 "VBNET.ATG" 
 out expr);
 
-#line  1732 "VBNET.ATG" 
+#line  1740 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void ConcatenationExpr(
-#line  1736 "VBNET.ATG" 
+#line  1744 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1737 "VBNET.ATG" 
+#line  1745 "VBNET.ATG" 
 		Expression expr; 
 		AdditiveExpr(
-#line  1739 "VBNET.ATG" 
+#line  1747 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 19) {
 			lexer.NextToken();
 			AdditiveExpr(
-#line  1739 "VBNET.ATG" 
+#line  1747 "VBNET.ATG" 
 out expr);
 
-#line  1739 "VBNET.ATG" 
+#line  1747 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr);  
 		}
 	}
 
 	void AdditiveExpr(
-#line  1742 "VBNET.ATG" 
+#line  1750 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1744 "VBNET.ATG" 
+#line  1752 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ModuloExpr(
-#line  1747 "VBNET.ATG" 
+#line  1755 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 14 || la.kind == 15) {
 			if (la.kind == 14) {
 				lexer.NextToken();
 
-#line  1750 "VBNET.ATG" 
+#line  1758 "VBNET.ATG" 
 				op = BinaryOperatorType.Add; 
 			} else {
 				lexer.NextToken();
 
-#line  1751 "VBNET.ATG" 
+#line  1759 "VBNET.ATG" 
 				op = BinaryOperatorType.Subtract; 
 			}
 			ModuloExpr(
-#line  1753 "VBNET.ATG" 
+#line  1761 "VBNET.ATG" 
 out expr);
 
-#line  1753 "VBNET.ATG" 
+#line  1761 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void ModuloExpr(
-#line  1757 "VBNET.ATG" 
+#line  1765 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1758 "VBNET.ATG" 
+#line  1766 "VBNET.ATG" 
 		Expression expr; 
 		IntegerDivisionExpr(
-#line  1760 "VBNET.ATG" 
+#line  1768 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 120) {
 			lexer.NextToken();
 			IntegerDivisionExpr(
-#line  1760 "VBNET.ATG" 
+#line  1768 "VBNET.ATG" 
 out expr);
 
-#line  1760 "VBNET.ATG" 
+#line  1768 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr);  
 		}
 	}
 
 	void IntegerDivisionExpr(
-#line  1763 "VBNET.ATG" 
+#line  1771 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1764 "VBNET.ATG" 
+#line  1772 "VBNET.ATG" 
 		Expression expr; 
 		MultiplicativeExpr(
-#line  1766 "VBNET.ATG" 
+#line  1774 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 18) {
 			lexer.NextToken();
 			MultiplicativeExpr(
-#line  1766 "VBNET.ATG" 
+#line  1774 "VBNET.ATG" 
 out expr);
 
-#line  1766 "VBNET.ATG" 
+#line  1774 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr);  
 		}
 	}
 
 	void MultiplicativeExpr(
-#line  1769 "VBNET.ATG" 
+#line  1777 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1771 "VBNET.ATG" 
+#line  1779 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		UnaryExpr(
-#line  1774 "VBNET.ATG" 
+#line  1782 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 16 || la.kind == 17) {
 			if (la.kind == 16) {
 				lexer.NextToken();
 
-#line  1777 "VBNET.ATG" 
+#line  1785 "VBNET.ATG" 
 				op = BinaryOperatorType.Multiply; 
 			} else {
 				lexer.NextToken();
 
-#line  1778 "VBNET.ATG" 
+#line  1786 "VBNET.ATG" 
 				op = BinaryOperatorType.Divide; 
 			}
 			UnaryExpr(
-#line  1780 "VBNET.ATG" 
+#line  1788 "VBNET.ATG" 
 out expr);
 
-#line  1780 "VBNET.ATG" 
+#line  1788 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr); 
 		}
 	}
 
 	void UnaryExpr(
-#line  1784 "VBNET.ATG" 
+#line  1792 "VBNET.ATG" 
 out Expression uExpr) {
 
-#line  1786 "VBNET.ATG" 
+#line  1794 "VBNET.ATG" 
 		Expression expr;
 		UnaryOperatorType uop = UnaryOperatorType.None;
 		bool isUOp = false;
@@ -4415,25 +4443,25 @@ out Expression uExpr) {
 			if (la.kind == 14) {
 				lexer.NextToken();
 
-#line  1790 "VBNET.ATG" 
+#line  1798 "VBNET.ATG" 
 				uop = UnaryOperatorType.Plus; isUOp = true; 
 			} else if (la.kind == 15) {
 				lexer.NextToken();
 
-#line  1791 "VBNET.ATG" 
+#line  1799 "VBNET.ATG" 
 				uop = UnaryOperatorType.Minus; isUOp = true; 
 			} else {
 				lexer.NextToken();
 
-#line  1792 "VBNET.ATG" 
+#line  1800 "VBNET.ATG" 
 				uop = UnaryOperatorType.Star;  isUOp = true;
 			}
 		}
 		ExponentiationExpr(
-#line  1794 "VBNET.ATG" 
+#line  1802 "VBNET.ATG" 
 out expr);
 
-#line  1796 "VBNET.ATG" 
+#line  1804 "VBNET.ATG" 
 		if (isUOp) {
 		uExpr = new UnaryOperatorExpression(expr, uop);
 		} else {
@@ -4443,107 +4471,107 @@ out expr);
 	}
 
 	void ExponentiationExpr(
-#line  1804 "VBNET.ATG" 
+#line  1812 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1805 "VBNET.ATG" 
+#line  1813 "VBNET.ATG" 
 		Expression expr; 
 		SimpleExpr(
-#line  1807 "VBNET.ATG" 
+#line  1815 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 20) {
 			lexer.NextToken();
 			SimpleExpr(
-#line  1807 "VBNET.ATG" 
+#line  1815 "VBNET.ATG" 
 out expr);
 
-#line  1807 "VBNET.ATG" 
+#line  1815 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr);  
 		}
 	}
 
 	void NormalOrReDimArgumentList(
-#line  1858 "VBNET.ATG" 
+#line  1866 "VBNET.ATG" 
 out List<Expression> arguments, out bool canBeNormal, out bool canBeRedim) {
 
-#line  1860 "VBNET.ATG" 
+#line  1868 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		canBeNormal = true; canBeRedim = !IsNamedAssign();
 		Expression expr = null;
 		
-		if (StartOf(26)) {
+		if (StartOf(27)) {
 			Argument(
-#line  1865 "VBNET.ATG" 
+#line  1873 "VBNET.ATG" 
 out expr);
 			if (la.kind == 172) {
 				lexer.NextToken();
 
-#line  1866 "VBNET.ATG" 
+#line  1874 "VBNET.ATG" 
 				EnsureIsZero(expr); canBeNormal = false; 
 				Expr(
-#line  1867 "VBNET.ATG" 
+#line  1875 "VBNET.ATG" 
 out expr);
 			}
 		}
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  1870 "VBNET.ATG" 
+#line  1878 "VBNET.ATG" 
 			if (expr == null) canBeRedim = false; 
 
-#line  1871 "VBNET.ATG" 
+#line  1879 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 
-#line  1872 "VBNET.ATG" 
+#line  1880 "VBNET.ATG" 
 			canBeRedim &= !IsNamedAssign(); 
-			if (StartOf(26)) {
+			if (StartOf(27)) {
 				Argument(
-#line  1873 "VBNET.ATG" 
+#line  1881 "VBNET.ATG" 
 out expr);
 				if (la.kind == 172) {
 					lexer.NextToken();
 
-#line  1874 "VBNET.ATG" 
+#line  1882 "VBNET.ATG" 
 					EnsureIsZero(expr); canBeNormal = false; 
 					Expr(
-#line  1875 "VBNET.ATG" 
+#line  1883 "VBNET.ATG" 
 out expr);
 				}
 			}
 
-#line  1877 "VBNET.ATG" 
+#line  1885 "VBNET.ATG" 
 			if (expr == null) { canBeRedim = false; expr = Expression.Null; } 
 		}
 
-#line  1879 "VBNET.ATG" 
+#line  1887 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); else canBeRedim = false; 
 	}
 
 	void ArrayTypeModifiers(
-#line  1966 "VBNET.ATG" 
+#line  1974 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  1968 "VBNET.ATG" 
+#line  1976 "VBNET.ATG" 
 		arrayModifiers = new ArrayList();
 		int i = 0;
 		
 		while (
-#line  1971 "VBNET.ATG" 
+#line  1979 "VBNET.ATG" 
 IsDims()) {
 			Expect(24);
 			if (la.kind == 12 || la.kind == 25) {
 				RankList(
-#line  1973 "VBNET.ATG" 
+#line  1981 "VBNET.ATG" 
 out i);
 			}
 
-#line  1975 "VBNET.ATG" 
+#line  1983 "VBNET.ATG" 
 			arrayModifiers.Add(i);
 			
 			Expect(25);
 		}
 
-#line  1980 "VBNET.ATG" 
+#line  1988 "VBNET.ATG" 
 		if(arrayModifiers.Count == 0) {
 		 arrayModifiers = null;
 		}
@@ -4551,118 +4579,118 @@ out i);
 	}
 
 	void Argument(
-#line  1883 "VBNET.ATG" 
+#line  1891 "VBNET.ATG" 
 out Expression argumentexpr) {
 
-#line  1885 "VBNET.ATG" 
+#line  1893 "VBNET.ATG" 
 		Expression expr;
 		argumentexpr = null;
 		string name;
 		
 		if (
-#line  1889 "VBNET.ATG" 
+#line  1897 "VBNET.ATG" 
 IsNamedAssign()) {
 			Identifier();
 
-#line  1889 "VBNET.ATG" 
+#line  1897 "VBNET.ATG" 
 			name = t.val;  
 			Expect(13);
 			Expect(11);
 			Expr(
-#line  1889 "VBNET.ATG" 
+#line  1897 "VBNET.ATG" 
 out expr);
 
-#line  1891 "VBNET.ATG" 
+#line  1899 "VBNET.ATG" 
 			argumentexpr = new NamedArgumentExpression(name, expr);
 			
-		} else if (StartOf(26)) {
+		} else if (StartOf(27)) {
 			Expr(
-#line  1894 "VBNET.ATG" 
+#line  1902 "VBNET.ATG" 
 out argumentexpr);
-		} else SynErr(248);
+		} else SynErr(249);
 	}
 
 	void QualIdentAndTypeArguments(
-#line  1940 "VBNET.ATG" 
+#line  1948 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  1941 "VBNET.ATG" 
+#line  1949 "VBNET.ATG" 
 		string name; typeref = null; 
 		Qualident(
-#line  1943 "VBNET.ATG" 
+#line  1951 "VBNET.ATG" 
 out name);
 
-#line  1944 "VBNET.ATG" 
+#line  1952 "VBNET.ATG" 
 		typeref = new TypeReference(name); 
 		if (
-#line  1945 "VBNET.ATG" 
+#line  1953 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			lexer.NextToken();
 			Expect(200);
 			if (
-#line  1947 "VBNET.ATG" 
+#line  1955 "VBNET.ATG" 
 canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma)) {
 
-#line  1948 "VBNET.ATG" 
+#line  1956 "VBNET.ATG" 
 				typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				while (la.kind == 12) {
 					lexer.NextToken();
 
-#line  1949 "VBNET.ATG" 
+#line  1957 "VBNET.ATG" 
 					typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				}
-			} else if (StartOf(5)) {
+			} else if (StartOf(6)) {
 				TypeArgumentList(
-#line  1950 "VBNET.ATG" 
+#line  1958 "VBNET.ATG" 
 typeref.GenericTypes);
-			} else SynErr(249);
+			} else SynErr(250);
 			Expect(25);
 		}
 	}
 
 	void TypeArgumentList(
-#line  1993 "VBNET.ATG" 
+#line  2001 "VBNET.ATG" 
 List<TypeReference> typeArguments) {
 
-#line  1995 "VBNET.ATG" 
+#line  2003 "VBNET.ATG" 
 		TypeReference typeref;
 		
 		TypeName(
-#line  1997 "VBNET.ATG" 
+#line  2005 "VBNET.ATG" 
 out typeref);
 
-#line  1997 "VBNET.ATG" 
+#line  2005 "VBNET.ATG" 
 		if (typeref != null) typeArguments.Add(typeref); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  2000 "VBNET.ATG" 
+#line  2008 "VBNET.ATG" 
 out typeref);
 
-#line  2000 "VBNET.ATG" 
+#line  2008 "VBNET.ATG" 
 			if (typeref != null) typeArguments.Add(typeref); 
 		}
 	}
 
 	void RankList(
-#line  1987 "VBNET.ATG" 
+#line  1995 "VBNET.ATG" 
 out int i) {
 
-#line  1988 "VBNET.ATG" 
+#line  1996 "VBNET.ATG" 
 		i = 0; 
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  1989 "VBNET.ATG" 
+#line  1997 "VBNET.ATG" 
 			++i; 
 		}
 	}
 
 	void Attribute(
-#line  2025 "VBNET.ATG" 
+#line  2033 "VBNET.ATG" 
 out ASTAttribute attribute) {
 
-#line  2026 "VBNET.ATG" 
+#line  2034 "VBNET.ATG" 
 		string name;
 		List<Expression> positional = new List<Expression>();
 		List<NamedArgumentExpression> named = new List<NamedArgumentExpression>();
@@ -4672,39 +4700,39 @@ out ASTAttribute attribute) {
 			Expect(10);
 		}
 		Qualident(
-#line  2031 "VBNET.ATG" 
+#line  2039 "VBNET.ATG" 
 out name);
 		if (la.kind == 24) {
 			AttributeArguments(
-#line  2032 "VBNET.ATG" 
+#line  2040 "VBNET.ATG" 
 positional, named);
 		}
 
-#line  2033 "VBNET.ATG" 
+#line  2041 "VBNET.ATG" 
 		attribute  = new ASTAttribute(name, positional, named); 
 	}
 
 	void AttributeArguments(
-#line  2037 "VBNET.ATG" 
+#line  2045 "VBNET.ATG" 
 List<Expression> positional, List<NamedArgumentExpression> named) {
 
-#line  2039 "VBNET.ATG" 
+#line  2047 "VBNET.ATG" 
 		bool nameFound = false;
 		string name = "";
 		Expression expr;
 		
 		Expect(24);
 		if (
-#line  2045 "VBNET.ATG" 
+#line  2053 "VBNET.ATG" 
 IsNotClosingParenthesis()) {
 			if (
-#line  2047 "VBNET.ATG" 
+#line  2055 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2047 "VBNET.ATG" 
+#line  2055 "VBNET.ATG" 
 				nameFound = true; 
 				IdentifierOrKeyword(
-#line  2048 "VBNET.ATG" 
+#line  2056 "VBNET.ATG" 
 out name);
 				if (la.kind == 13) {
 					lexer.NextToken();
@@ -4712,10 +4740,10 @@ out name);
 				Expect(11);
 			}
 			Expr(
-#line  2050 "VBNET.ATG" 
+#line  2058 "VBNET.ATG" 
 out expr);
 
-#line  2052 "VBNET.ATG" 
+#line  2060 "VBNET.ATG" 
 			if (expr != null) {
 			if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
 			else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
@@ -4724,28 +4752,28 @@ out expr);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				if (
-#line  2060 "VBNET.ATG" 
+#line  2068 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2060 "VBNET.ATG" 
+#line  2068 "VBNET.ATG" 
 					nameFound = true; 
 					IdentifierOrKeyword(
-#line  2061 "VBNET.ATG" 
+#line  2069 "VBNET.ATG" 
 out name);
 					if (la.kind == 13) {
 						lexer.NextToken();
 					}
 					Expect(11);
-				} else if (StartOf(26)) {
+				} else if (StartOf(27)) {
 
-#line  2063 "VBNET.ATG" 
+#line  2071 "VBNET.ATG" 
 					if (nameFound) Error("no positional argument after named argument"); 
-				} else SynErr(250);
+				} else SynErr(251);
 				Expr(
-#line  2064 "VBNET.ATG" 
+#line  2072 "VBNET.ATG" 
 out expr);
 
-#line  2064 "VBNET.ATG" 
+#line  2072 "VBNET.ATG" 
 				if (expr != null) { if(name == "") positional.Add(expr);
 				else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
 				}
@@ -4756,39 +4784,39 @@ out expr);
 	}
 
 	void FormalParameter(
-#line  2133 "VBNET.ATG" 
+#line  2141 "VBNET.ATG" 
 out ParameterDeclarationExpression p) {
 
-#line  2135 "VBNET.ATG" 
+#line  2143 "VBNET.ATG" 
 		TypeReference type = null;
 		ParamModifierList mod = new ParamModifierList(this);
 		Expression expr = null;
 		p = null;ArrayList arrayModifiers = null;
 		
-		while (StartOf(32)) {
+		while (StartOf(33)) {
 			ParameterModifier(
-#line  2140 "VBNET.ATG" 
+#line  2148 "VBNET.ATG" 
 mod);
 		}
 		Identifier();
 
-#line  2141 "VBNET.ATG" 
+#line  2149 "VBNET.ATG" 
 		string parameterName = t.val; 
 		if (
-#line  2142 "VBNET.ATG" 
+#line  2150 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  2142 "VBNET.ATG" 
+#line  2150 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 48) {
 			lexer.NextToken();
 			TypeName(
-#line  2143 "VBNET.ATG" 
+#line  2151 "VBNET.ATG" 
 out type);
 		}
 
-#line  2145 "VBNET.ATG" 
+#line  2153 "VBNET.ATG" 
 		if(type != null) {
 		if (arrayModifiers != null) {
 			if (type.RankSpecifier != null) {
@@ -4804,45 +4832,45 @@ out type);
 		if (la.kind == 11) {
 			lexer.NextToken();
 			Expr(
-#line  2157 "VBNET.ATG" 
+#line  2165 "VBNET.ATG" 
 out expr);
 		}
 
-#line  2159 "VBNET.ATG" 
+#line  2167 "VBNET.ATG" 
 		mod.Check();
 		p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
 		
 	}
 
 	void ParameterModifier(
-#line  2791 "VBNET.ATG" 
+#line  2799 "VBNET.ATG" 
 ParamModifierList m) {
 		if (la.kind == 55) {
 			lexer.NextToken();
 
-#line  2792 "VBNET.ATG" 
+#line  2800 "VBNET.ATG" 
 			m.Add(ParameterModifiers.In); 
 		} else if (la.kind == 53) {
 			lexer.NextToken();
 
-#line  2793 "VBNET.ATG" 
+#line  2801 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Ref); 
 		} else if (la.kind == 137) {
 			lexer.NextToken();
 
-#line  2794 "VBNET.ATG" 
+#line  2802 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Optional); 
 		} else if (la.kind == 143) {
 			lexer.NextToken();
 
-#line  2795 "VBNET.ATG" 
+#line  2803 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Params); 
-		} else SynErr(251);
+		} else SynErr(252);
 	}
 
 	void Statement() {
 
-#line  2186 "VBNET.ATG" 
+#line  2194 "VBNET.ATG" 
 		Statement stmt = null;
 		Location startPos = la.Location;
 		string label = String.Empty;
@@ -4850,34 +4878,34 @@ ParamModifierList m) {
 		
 		if (la.kind == 1 || la.kind == 13) {
 		} else if (
-#line  2192 "VBNET.ATG" 
+#line  2200 "VBNET.ATG" 
 IsLabel()) {
 			LabelName(
-#line  2192 "VBNET.ATG" 
+#line  2200 "VBNET.ATG" 
 out label);
 
-#line  2194 "VBNET.ATG" 
+#line  2202 "VBNET.ATG" 
 			compilationUnit.AddChild(new LabelStatement(t.val));
 			
 			Expect(13);
 			Statement();
-		} else if (StartOf(33)) {
+		} else if (StartOf(34)) {
 			EmbeddedStatement(
-#line  2197 "VBNET.ATG" 
+#line  2205 "VBNET.ATG" 
 out stmt);
 
-#line  2197 "VBNET.ATG" 
+#line  2205 "VBNET.ATG" 
 			compilationUnit.AddChild(stmt); 
-		} else if (StartOf(34)) {
+		} else if (StartOf(35)) {
 			LocalDeclarationStatement(
-#line  2198 "VBNET.ATG" 
+#line  2206 "VBNET.ATG" 
 out stmt);
 
-#line  2198 "VBNET.ATG" 
+#line  2206 "VBNET.ATG" 
 			compilationUnit.AddChild(stmt); 
-		} else SynErr(252);
+		} else SynErr(253);
 
-#line  2201 "VBNET.ATG" 
+#line  2209 "VBNET.ATG" 
 		if (stmt != null) {
 		stmt.StartLocation = startPos;
 		stmt.EndLocation = t.Location;
@@ -4886,30 +4914,30 @@ out stmt);
 	}
 
 	void LabelName(
-#line  2577 "VBNET.ATG" 
+#line  2585 "VBNET.ATG" 
 out string name) {
 
-#line  2579 "VBNET.ATG" 
+#line  2587 "VBNET.ATG" 
 		name = String.Empty;
 		
-		if (StartOf(12)) {
+		if (StartOf(13)) {
 			Identifier();
 
-#line  2581 "VBNET.ATG" 
+#line  2589 "VBNET.ATG" 
 			name = t.val; 
 		} else if (la.kind == 5) {
 			lexer.NextToken();
 
-#line  2582 "VBNET.ATG" 
+#line  2590 "VBNET.ATG" 
 			name = t.val; 
-		} else SynErr(253);
+		} else SynErr(254);
 	}
 
 	void EmbeddedStatement(
-#line  2240 "VBNET.ATG" 
+#line  2248 "VBNET.ATG" 
 out Statement statement) {
 
-#line  2242 "VBNET.ATG" 
+#line  2250 "VBNET.ATG" 
 		Statement embeddedStatement = null;
 		statement = null;
 		Expression expr = null;
@@ -4920,143 +4948,143 @@ out Statement statement) {
 		case 94: {
 			lexer.NextToken();
 
-#line  2248 "VBNET.ATG" 
+#line  2256 "VBNET.ATG" 
 			ExitType exitType = ExitType.None; 
 			switch (la.kind) {
 			case 167: {
 				lexer.NextToken();
 
-#line  2250 "VBNET.ATG" 
+#line  2258 "VBNET.ATG" 
 				exitType = ExitType.Sub; 
 				break;
 			}
 			case 100: {
 				lexer.NextToken();
 
-#line  2252 "VBNET.ATG" 
+#line  2260 "VBNET.ATG" 
 				exitType = ExitType.Function; 
 				break;
 			}
 			case 146: {
 				lexer.NextToken();
 
-#line  2254 "VBNET.ATG" 
+#line  2262 "VBNET.ATG" 
 				exitType = ExitType.Property; 
 				break;
 			}
 			case 83: {
 				lexer.NextToken();
 
-#line  2256 "VBNET.ATG" 
+#line  2264 "VBNET.ATG" 
 				exitType = ExitType.Do; 
 				break;
 			}
 			case 98: {
 				lexer.NextToken();
 
-#line  2258 "VBNET.ATG" 
+#line  2266 "VBNET.ATG" 
 				exitType = ExitType.For; 
 				break;
 			}
 			case 174: {
 				lexer.NextToken();
 
-#line  2260 "VBNET.ATG" 
+#line  2268 "VBNET.ATG" 
 				exitType = ExitType.Try; 
 				break;
 			}
 			case 181: {
 				lexer.NextToken();
 
-#line  2262 "VBNET.ATG" 
+#line  2270 "VBNET.ATG" 
 				exitType = ExitType.While; 
 				break;
 			}
 			case 155: {
 				lexer.NextToken();
 
-#line  2264 "VBNET.ATG" 
+#line  2272 "VBNET.ATG" 
 				exitType = ExitType.Select; 
 				break;
 			}
-			default: SynErr(254); break;
+			default: SynErr(255); break;
 			}
 
-#line  2266 "VBNET.ATG" 
+#line  2274 "VBNET.ATG" 
 			statement = new ExitStatement(exitType); 
 			break;
 		}
 		case 174: {
 			TryStatement(
-#line  2267 "VBNET.ATG" 
+#line  2275 "VBNET.ATG" 
 out statement);
 			break;
 		}
 		case 186: {
 			lexer.NextToken();
 
-#line  2268 "VBNET.ATG" 
+#line  2276 "VBNET.ATG" 
 			ContinueType continueType = ContinueType.None; 
 			if (la.kind == 83 || la.kind == 98 || la.kind == 181) {
 				if (la.kind == 83) {
 					lexer.NextToken();
 
-#line  2268 "VBNET.ATG" 
+#line  2276 "VBNET.ATG" 
 					continueType = ContinueType.Do; 
 				} else if (la.kind == 98) {
 					lexer.NextToken();
 
-#line  2268 "VBNET.ATG" 
+#line  2276 "VBNET.ATG" 
 					continueType = ContinueType.For; 
 				} else {
 					lexer.NextToken();
 
-#line  2268 "VBNET.ATG" 
+#line  2276 "VBNET.ATG" 
 					continueType = ContinueType.While; 
 				}
 			}
 
-#line  2268 "VBNET.ATG" 
+#line  2276 "VBNET.ATG" 
 			statement = new ContinueStatement(continueType); 
 			break;
 		}
 		case 171: {
 			lexer.NextToken();
-			if (StartOf(26)) {
+			if (StartOf(27)) {
 				Expr(
-#line  2270 "VBNET.ATG" 
+#line  2278 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2270 "VBNET.ATG" 
+#line  2278 "VBNET.ATG" 
 			statement = new ThrowStatement(expr); 
 			break;
 		}
 		case 154: {
 			lexer.NextToken();
-			if (StartOf(26)) {
+			if (StartOf(27)) {
 				Expr(
-#line  2272 "VBNET.ATG" 
+#line  2280 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2272 "VBNET.ATG" 
+#line  2280 "VBNET.ATG" 
 			statement = new ReturnStatement(expr); 
 			break;
 		}
 		case 168: {
 			lexer.NextToken();
 			Expr(
-#line  2274 "VBNET.ATG" 
+#line  2282 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  2274 "VBNET.ATG" 
+#line  2282 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(88);
 			Expect(168);
 
-#line  2275 "VBNET.ATG" 
+#line  2283 "VBNET.ATG" 
 			statement = new LockStatement(expr, embeddedStatement); 
 			break;
 		}
@@ -5064,42 +5092,42 @@ out embeddedStatement);
 			lexer.NextToken();
 			Identifier();
 
-#line  2277 "VBNET.ATG" 
+#line  2285 "VBNET.ATG" 
 			name = t.val; 
 			if (la.kind == 24) {
 				lexer.NextToken();
-				if (StartOf(29)) {
+				if (StartOf(30)) {
 					ArgumentList(
-#line  2278 "VBNET.ATG" 
+#line  2286 "VBNET.ATG" 
 out p);
 				}
 				Expect(25);
 			}
 
-#line  2279 "VBNET.ATG" 
+#line  2287 "VBNET.ATG" 
 			statement = new RaiseEventStatement(name, p); 
 			break;
 		}
 		case 182: {
 			WithStatement(
-#line  2281 "VBNET.ATG" 
+#line  2289 "VBNET.ATG" 
 out statement);
 			break;
 		}
 		case 42: {
 			lexer.NextToken();
 
-#line  2283 "VBNET.ATG" 
+#line  2291 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  2284 "VBNET.ATG" 
+#line  2292 "VBNET.ATG" 
 out expr);
 			Expect(12);
 			Expr(
-#line  2284 "VBNET.ATG" 
+#line  2292 "VBNET.ATG" 
 out handlerExpr);
 
-#line  2286 "VBNET.ATG" 
+#line  2294 "VBNET.ATG" 
 			statement = new AddHandlerStatement(expr, handlerExpr);
 			
 			break;
@@ -5107,17 +5135,17 @@ out handlerExpr);
 		case 152: {
 			lexer.NextToken();
 
-#line  2289 "VBNET.ATG" 
+#line  2297 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  2290 "VBNET.ATG" 
+#line  2298 "VBNET.ATG" 
 out expr);
 			Expect(12);
 			Expr(
-#line  2290 "VBNET.ATG" 
+#line  2298 "VBNET.ATG" 
 out handlerExpr);
 
-#line  2292 "VBNET.ATG" 
+#line  2300 "VBNET.ATG" 
 			statement = new RemoveHandlerStatement(expr, handlerExpr);
 			
 			break;
@@ -5125,16 +5153,16 @@ out handlerExpr);
 		case 181: {
 			lexer.NextToken();
 			Expr(
-#line  2295 "VBNET.ATG" 
+#line  2303 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  2296 "VBNET.ATG" 
+#line  2304 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(88);
 			Expect(181);
 
-#line  2298 "VBNET.ATG" 
+#line  2306 "VBNET.ATG" 
 			statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
 			
 			break;
@@ -5142,23 +5170,23 @@ out embeddedStatement);
 		case 83: {
 			lexer.NextToken();
 
-#line  2303 "VBNET.ATG" 
+#line  2311 "VBNET.ATG" 
 			ConditionType conditionType = ConditionType.None;
 			
 			if (la.kind == 177 || la.kind == 181) {
 				WhileOrUntil(
-#line  2306 "VBNET.ATG" 
+#line  2314 "VBNET.ATG" 
 out conditionType);
 				Expr(
-#line  2306 "VBNET.ATG" 
+#line  2314 "VBNET.ATG" 
 out expr);
 				EndOfStmt();
 				Block(
-#line  2307 "VBNET.ATG" 
+#line  2315 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(118);
 
-#line  2310 "VBNET.ATG" 
+#line  2318 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, 
 				                               embeddedStatement, 
 				                               conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, 
@@ -5167,28 +5195,28 @@ out embeddedStatement);
 			} else if (la.kind == 1 || la.kind == 13) {
 				EndOfStmt();
 				Block(
-#line  2317 "VBNET.ATG" 
+#line  2325 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(118);
 				if (la.kind == 177 || la.kind == 181) {
 					WhileOrUntil(
-#line  2318 "VBNET.ATG" 
+#line  2326 "VBNET.ATG" 
 out conditionType);
 					Expr(
-#line  2318 "VBNET.ATG" 
+#line  2326 "VBNET.ATG" 
 out expr);
 				}
 
-#line  2320 "VBNET.ATG" 
+#line  2328 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End);
 				
-			} else SynErr(255);
+			} else SynErr(256);
 			break;
 		}
 		case 98: {
 			lexer.NextToken();
 
-#line  2325 "VBNET.ATG" 
+#line  2333 "VBNET.ATG" 
 			Expression group = null;
 			TypeReference typeReference;
 			string        typeName;
@@ -5197,24 +5225,24 @@ out expr);
 			if (la.kind == 85) {
 				lexer.NextToken();
 				LoopControlVariable(
-#line  2332 "VBNET.ATG" 
+#line  2340 "VBNET.ATG" 
 out typeReference, out typeName);
 				Expect(109);
 				Expr(
-#line  2333 "VBNET.ATG" 
+#line  2341 "VBNET.ATG" 
 out group);
 				EndOfStmt();
 				Block(
-#line  2334 "VBNET.ATG" 
+#line  2342 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(128);
-				if (StartOf(26)) {
+				if (StartOf(27)) {
 					Expr(
-#line  2335 "VBNET.ATG" 
+#line  2343 "VBNET.ATG" 
 out expr);
 				}
 
-#line  2337 "VBNET.ATG" 
+#line  2345 "VBNET.ATG" 
 				statement = new ForeachStatement(typeReference, 
 				                                typeName,
 				                                group, 
@@ -5224,86 +5252,86 @@ out expr);
 				statement.EndLocation   = t.EndLocation;
 				
 				
-			} else if (StartOf(12)) {
+			} else if (StartOf(13)) {
 
-#line  2348 "VBNET.ATG" 
+#line  2356 "VBNET.ATG" 
 				Expression start = null;
 				Expression end = null;
 				Expression step = null;
 				Expression nextExpr = null;List<Expression> nextExpressions = null;
 				
 				LoopControlVariable(
-#line  2353 "VBNET.ATG" 
+#line  2361 "VBNET.ATG" 
 out typeReference, out typeName);
 				Expect(11);
 				Expr(
-#line  2354 "VBNET.ATG" 
+#line  2362 "VBNET.ATG" 
 out start);
 				Expect(172);
 				Expr(
-#line  2354 "VBNET.ATG" 
+#line  2362 "VBNET.ATG" 
 out end);
 				if (la.kind == 162) {
 					lexer.NextToken();
 					Expr(
-#line  2354 "VBNET.ATG" 
+#line  2362 "VBNET.ATG" 
 out step);
 				}
 				EndOfStmt();
 				Block(
-#line  2355 "VBNET.ATG" 
+#line  2363 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(128);
-				if (StartOf(26)) {
+				if (StartOf(27)) {
 					Expr(
-#line  2358 "VBNET.ATG" 
+#line  2366 "VBNET.ATG" 
 out nextExpr);
 
-#line  2358 "VBNET.ATG" 
+#line  2366 "VBNET.ATG" 
 					nextExpressions = new List<Expression>(); nextExpressions.Add(nextExpr); 
 					while (la.kind == 12) {
 						lexer.NextToken();
 						Expr(
-#line  2359 "VBNET.ATG" 
+#line  2367 "VBNET.ATG" 
 out nextExpr);
 
-#line  2359 "VBNET.ATG" 
+#line  2367 "VBNET.ATG" 
 						nextExpressions.Add(nextExpr); 
 					}
 				}
 
-#line  2362 "VBNET.ATG" 
+#line  2370 "VBNET.ATG" 
 				statement = new ForNextStatement(typeReference, typeName, start, end, step, embeddedStatement, nextExpressions);
 				
-			} else SynErr(256);
+			} else SynErr(257);
 			break;
 		}
 		case 92: {
 			lexer.NextToken();
 			Expr(
-#line  2366 "VBNET.ATG" 
+#line  2374 "VBNET.ATG" 
 out expr);
 
-#line  2366 "VBNET.ATG" 
+#line  2374 "VBNET.ATG" 
 			statement = new ErrorStatement(expr); 
 			break;
 		}
 		case 151: {
 			lexer.NextToken();
 
-#line  2368 "VBNET.ATG" 
+#line  2376 "VBNET.ATG" 
 			bool isPreserve = false; 
 			if (la.kind == 144) {
 				lexer.NextToken();
 
-#line  2368 "VBNET.ATG" 
+#line  2376 "VBNET.ATG" 
 				isPreserve = true; 
 			}
 			ReDimClause(
-#line  2369 "VBNET.ATG" 
+#line  2377 "VBNET.ATG" 
 out expr);
 
-#line  2371 "VBNET.ATG" 
+#line  2379 "VBNET.ATG" 
 			ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
 			statement = reDimStatement;
 			InvocationExpression redimClause = expr as InvocationExpression;
@@ -5312,13 +5340,13 @@ out expr);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				ReDimClause(
-#line  2376 "VBNET.ATG" 
+#line  2384 "VBNET.ATG" 
 out expr);
 
-#line  2377 "VBNET.ATG" 
+#line  2385 "VBNET.ATG" 
 				redimClause = expr as InvocationExpression; 
 
-#line  2378 "VBNET.ATG" 
+#line  2386 "VBNET.ATG" 
 				if (redimClause != null) { reDimStatement.ReDimClauses.Add(redimClause); } 
 			}
 			break;
@@ -5326,10 +5354,10 @@ out expr);
 		case 91: {
 			lexer.NextToken();
 			Expr(
-#line  2382 "VBNET.ATG" 
+#line  2390 "VBNET.ATG" 
 out expr);
 
-#line  2383 "VBNET.ATG" 
+#line  2391 "VBNET.ATG" 
 			List<Expression> arrays = new List<Expression>();
 			if (expr != null) { arrays.Add(expr);}
 			EraseStatement eraseStatement = new EraseStatement(arrays);
@@ -5338,53 +5366,53 @@ out expr);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				Expr(
-#line  2388 "VBNET.ATG" 
+#line  2396 "VBNET.ATG" 
 out expr);
 
-#line  2388 "VBNET.ATG" 
+#line  2396 "VBNET.ATG" 
 				if (expr != null) { arrays.Add(expr); }
 			}
 
-#line  2389 "VBNET.ATG" 
+#line  2397 "VBNET.ATG" 
 			statement = eraseStatement; 
 			break;
 		}
 		case 163: {
 			lexer.NextToken();
 
-#line  2391 "VBNET.ATG" 
+#line  2399 "VBNET.ATG" 
 			statement = new StopStatement(); 
 			break;
 		}
 		case 106: {
 			lexer.NextToken();
 			Expr(
-#line  2393 "VBNET.ATG" 
+#line  2401 "VBNET.ATG" 
 out expr);
 			if (la.kind == 170) {
 				lexer.NextToken();
 			}
 			if (
-#line  2395 "VBNET.ATG" 
+#line  2403 "VBNET.ATG" 
 IsEndStmtAhead()) {
 				Expect(88);
 
-#line  2395 "VBNET.ATG" 
+#line  2403 "VBNET.ATG" 
 				statement = new IfElseStatement(expr, new EndStatement()); 
 			} else if (la.kind == 1 || la.kind == 13) {
 				EndOfStmt();
 				Block(
-#line  2398 "VBNET.ATG" 
+#line  2406 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2400 "VBNET.ATG" 
+#line  2408 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
 				
 				while (la.kind == 87 || 
-#line  2404 "VBNET.ATG" 
+#line  2412 "VBNET.ATG" 
 IsElseIf()) {
 					if (
-#line  2404 "VBNET.ATG" 
+#line  2412 "VBNET.ATG" 
 IsElseIf()) {
 						Expect(86);
 						Expect(106);
@@ -5392,20 +5420,20 @@ IsElseIf()) {
 						lexer.NextToken();
 					}
 
-#line  2407 "VBNET.ATG" 
+#line  2415 "VBNET.ATG" 
 					Expression condition = null; Statement block = null; 
 					Expr(
-#line  2408 "VBNET.ATG" 
+#line  2416 "VBNET.ATG" 
 out condition);
 					if (la.kind == 170) {
 						lexer.NextToken();
 					}
 					EndOfStmt();
 					Block(
-#line  2409 "VBNET.ATG" 
+#line  2417 "VBNET.ATG" 
 out block);
 
-#line  2411 "VBNET.ATG" 
+#line  2419 "VBNET.ATG" 
 					ifStatement.ElseIfSections.Add(new ElseIfSection(condition, block));
 					
 				}
@@ -5413,61 +5441,61 @@ out block);
 					lexer.NextToken();
 					EndOfStmt();
 					Block(
-#line  2416 "VBNET.ATG" 
+#line  2424 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2418 "VBNET.ATG" 
+#line  2426 "VBNET.ATG" 
 					ifStatement.FalseStatement.Add(embeddedStatement);
 					
 				}
 				Expect(88);
 				Expect(106);
 
-#line  2422 "VBNET.ATG" 
+#line  2430 "VBNET.ATG" 
 				statement = ifStatement;
 				
-			} else if (StartOf(33)) {
+			} else if (StartOf(34)) {
 				EmbeddedStatement(
-#line  2425 "VBNET.ATG" 
+#line  2433 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2427 "VBNET.ATG" 
+#line  2435 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
 				
 				while (la.kind == 13) {
 					lexer.NextToken();
 					EmbeddedStatement(
-#line  2429 "VBNET.ATG" 
+#line  2437 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2429 "VBNET.ATG" 
+#line  2437 "VBNET.ATG" 
 					ifStatement.TrueStatement.Add(embeddedStatement); 
 				}
 				if (la.kind == 86) {
 					lexer.NextToken();
-					if (StartOf(33)) {
+					if (StartOf(34)) {
 						EmbeddedStatement(
-#line  2431 "VBNET.ATG" 
+#line  2439 "VBNET.ATG" 
 out embeddedStatement);
 					}
 
-#line  2433 "VBNET.ATG" 
+#line  2441 "VBNET.ATG" 
 					ifStatement.FalseStatement.Add(embeddedStatement);
 					
 					while (la.kind == 13) {
 						lexer.NextToken();
 						EmbeddedStatement(
-#line  2436 "VBNET.ATG" 
+#line  2444 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2437 "VBNET.ATG" 
+#line  2445 "VBNET.ATG" 
 						ifStatement.FalseStatement.Add(embeddedStatement); 
 					}
 				}
 
-#line  2440 "VBNET.ATG" 
+#line  2448 "VBNET.ATG" 
 				statement = ifStatement; 
-			} else SynErr(257);
+			} else SynErr(258);
 			break;
 		}
 		case 155: {
@@ -5476,43 +5504,43 @@ out embeddedStatement);
 				lexer.NextToken();
 			}
 			Expr(
-#line  2443 "VBNET.ATG" 
+#line  2451 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 
-#line  2444 "VBNET.ATG" 
+#line  2452 "VBNET.ATG" 
 			List<SwitchSection> selectSections = new List<SwitchSection>();
 			Statement block = null;
 			
 			while (la.kind == 57) {
 
-#line  2448 "VBNET.ATG" 
+#line  2456 "VBNET.ATG" 
 				List<CaseLabel> caseClauses = null; 
 				lexer.NextToken();
 				CaseClauses(
-#line  2449 "VBNET.ATG" 
+#line  2457 "VBNET.ATG" 
 out caseClauses);
 				if (
-#line  2449 "VBNET.ATG" 
+#line  2457 "VBNET.ATG" 
 IsNotStatementSeparator()) {
 					lexer.NextToken();
 				}
 				EndOfStmt();
 
-#line  2451 "VBNET.ATG" 
+#line  2459 "VBNET.ATG" 
 				SwitchSection selectSection = new SwitchSection(caseClauses);
 				
 				Block(
-#line  2453 "VBNET.ATG" 
+#line  2461 "VBNET.ATG" 
 out block);
 
-#line  2455 "VBNET.ATG" 
+#line  2463 "VBNET.ATG" 
 				selectSection.Children = block.Children;
 				selectSections.Add(selectSection);
 				
 			}
 
-#line  2459 "VBNET.ATG" 
+#line  2467 "VBNET.ATG" 
 			statement = new SwitchStatement(expr, selectSections); 
 			Expect(88);
 			Expect(155);
@@ -5520,43 +5548,43 @@ out block);
 		}
 		case 135: {
 
-#line  2461 "VBNET.ATG" 
+#line  2469 "VBNET.ATG" 
 			OnErrorStatement onErrorStatement = null; 
 			OnErrorStatement(
-#line  2462 "VBNET.ATG" 
+#line  2470 "VBNET.ATG" 
 out onErrorStatement);
 
-#line  2462 "VBNET.ATG" 
+#line  2470 "VBNET.ATG" 
 			statement = onErrorStatement; 
 			break;
 		}
 		case 104: {
 
-#line  2463 "VBNET.ATG" 
+#line  2471 "VBNET.ATG" 
 			GotoStatement goToStatement = null; 
 			GotoStatement(
-#line  2464 "VBNET.ATG" 
+#line  2472 "VBNET.ATG" 
 out goToStatement);
 
-#line  2464 "VBNET.ATG" 
+#line  2472 "VBNET.ATG" 
 			statement = goToStatement; 
 			break;
 		}
 		case 153: {
 
-#line  2465 "VBNET.ATG" 
+#line  2473 "VBNET.ATG" 
 			ResumeStatement resumeStatement = null; 
 			ResumeStatement(
-#line  2466 "VBNET.ATG" 
+#line  2474 "VBNET.ATG" 
 out resumeStatement);
 
-#line  2466 "VBNET.ATG" 
+#line  2474 "VBNET.ATG" 
 			statement = resumeStatement; 
 			break;
 		}
 		case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 24: case 43: case 47: case 49: case 50: case 51: case 52: case 54: case 59: case 60: case 61: case 62: case 63: case 64: case 65: case 66: case 68: case 69: case 70: case 72: case 73: case 74: case 75: case 76: case 77: case 82: case 84: case 96: case 102: case 111: case 117: case 119: case 124: case 125: case 127: case 130: case 133: case 144: case 159: case 160: case 165: case 169: case 173: case 175: case 176: case 177: case 190: case 191: case 192: case 193: case 194: case 195: case 196: case 197: case 198: case 199: case 204: {
 
-#line  2469 "VBNET.ATG" 
+#line  2477 "VBNET.ATG" 
 			Expression val = null;
 			AssignmentOperatorType op;
 			
@@ -5564,25 +5592,25 @@ out resumeStatement);
 			                        la.kind == Tokens.Not   || la.kind == Tokens.Times;
 			
 			SimpleExpr(
-#line  2475 "VBNET.ATG" 
+#line  2483 "VBNET.ATG" 
 out expr);
-			if (StartOf(35)) {
+			if (StartOf(36)) {
 				AssignmentOperator(
-#line  2477 "VBNET.ATG" 
+#line  2485 "VBNET.ATG" 
 out op);
 				Expr(
-#line  2477 "VBNET.ATG" 
+#line  2485 "VBNET.ATG" 
 out val);
 
-#line  2477 "VBNET.ATG" 
+#line  2485 "VBNET.ATG" 
 				expr = new AssignmentExpression(expr, op, val); 
 			} else if (la.kind == 1 || la.kind == 13 || la.kind == 86) {
 
-#line  2478 "VBNET.ATG" 
+#line  2486 "VBNET.ATG" 
 				if (mustBeAssignment) Error("error in assignment."); 
-			} else SynErr(258);
+			} else SynErr(259);
 
-#line  2481 "VBNET.ATG" 
+#line  2489 "VBNET.ATG" 
 			// a field reference expression that stands alone is a
 			// invocation expression without parantheses and arguments
 			if(expr is FieldReferenceExpression || expr is IdentifierExpression) {
@@ -5595,63 +5623,63 @@ out val);
 		case 56: {
 			lexer.NextToken();
 			SimpleExpr(
-#line  2488 "VBNET.ATG" 
+#line  2496 "VBNET.ATG" 
 out expr);
 
-#line  2488 "VBNET.ATG" 
+#line  2496 "VBNET.ATG" 
 			statement = new ExpressionStatement(expr); 
 			break;
 		}
 		case 188: {
 			lexer.NextToken();
 
-#line  2490 "VBNET.ATG" 
+#line  2498 "VBNET.ATG" 
 			Statement block;  
 			if (
-#line  2491 "VBNET.ATG" 
+#line  2499 "VBNET.ATG" 
 Peek(1).kind == Tokens.As) {
 
-#line  2492 "VBNET.ATG" 
+#line  2500 "VBNET.ATG" 
 				LocalVariableDeclaration resourceAquisition = new LocalVariableDeclaration(Modifiers.None); 
 				VariableDeclarator(
-#line  2493 "VBNET.ATG" 
+#line  2501 "VBNET.ATG" 
 resourceAquisition.Variables);
 				while (la.kind == 12) {
 					lexer.NextToken();
 					VariableDeclarator(
-#line  2495 "VBNET.ATG" 
+#line  2503 "VBNET.ATG" 
 resourceAquisition.Variables);
 				}
 				Block(
-#line  2497 "VBNET.ATG" 
+#line  2505 "VBNET.ATG" 
 out block);
 
-#line  2498 "VBNET.ATG" 
+#line  2506 "VBNET.ATG" 
 				statement = new UsingStatement(resourceAquisition, block); 
-			} else if (StartOf(26)) {
+			} else if (StartOf(27)) {
 				Expr(
-#line  2499 "VBNET.ATG" 
+#line  2507 "VBNET.ATG" 
 out expr);
 				Block(
-#line  2500 "VBNET.ATG" 
+#line  2508 "VBNET.ATG" 
 out block);
 
-#line  2501 "VBNET.ATG" 
+#line  2509 "VBNET.ATG" 
 				statement = new UsingStatement(new ExpressionStatement(expr), block); 
-			} else SynErr(259);
+			} else SynErr(260);
 			Expect(88);
 			Expect(188);
 			break;
 		}
-		default: SynErr(260); break;
+		default: SynErr(261); break;
 		}
 	}
 
 	void LocalDeclarationStatement(
-#line  2209 "VBNET.ATG" 
+#line  2217 "VBNET.ATG" 
 out Statement statement) {
 
-#line  2211 "VBNET.ATG" 
+#line  2219 "VBNET.ATG" 
 		ModifierList m = new ModifierList();
 		LocalVariableDeclaration localVariableDeclaration;
 		bool dimfound = false;
@@ -5660,22 +5688,22 @@ out Statement statement) {
 			if (la.kind == 71) {
 				lexer.NextToken();
 
-#line  2217 "VBNET.ATG" 
+#line  2225 "VBNET.ATG" 
 				m.Add(Modifiers.Const, t.Location); 
 			} else if (la.kind == 161) {
 				lexer.NextToken();
 
-#line  2218 "VBNET.ATG" 
+#line  2226 "VBNET.ATG" 
 				m.Add(Modifiers.Static, t.Location); 
 			} else {
 				lexer.NextToken();
 
-#line  2219 "VBNET.ATG" 
+#line  2227 "VBNET.ATG" 
 				dimfound = true; 
 			}
 		}
 
-#line  2222 "VBNET.ATG" 
+#line  2230 "VBNET.ATG" 
 		if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
 		Error("Dim is not allowed on constants.");
 		}
@@ -5688,135 +5716,135 @@ out Statement statement) {
 		localVariableDeclaration.StartLocation = t.Location;
 		
 		VariableDeclarator(
-#line  2233 "VBNET.ATG" 
+#line  2241 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		while (la.kind == 12) {
 			lexer.NextToken();
 			VariableDeclarator(
-#line  2234 "VBNET.ATG" 
+#line  2242 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		}
 
-#line  2236 "VBNET.ATG" 
+#line  2244 "VBNET.ATG" 
 		statement = localVariableDeclaration;
 		
 	}
 
 	void TryStatement(
-#line  2688 "VBNET.ATG" 
+#line  2696 "VBNET.ATG" 
 out Statement tryStatement) {
 
-#line  2690 "VBNET.ATG" 
+#line  2698 "VBNET.ATG" 
 		Statement blockStmt = null, finallyStmt = null;List<CatchClause> catchClauses = null;
 		
 		Expect(174);
 		EndOfStmt();
 		Block(
-#line  2693 "VBNET.ATG" 
+#line  2701 "VBNET.ATG" 
 out blockStmt);
 		if (la.kind == 58 || la.kind == 88 || la.kind == 97) {
 			CatchClauses(
-#line  2694 "VBNET.ATG" 
+#line  2702 "VBNET.ATG" 
 out catchClauses);
 		}
 		if (la.kind == 97) {
 			lexer.NextToken();
 			EndOfStmt();
 			Block(
-#line  2695 "VBNET.ATG" 
+#line  2703 "VBNET.ATG" 
 out finallyStmt);
 		}
 		Expect(88);
 		Expect(174);
 
-#line  2698 "VBNET.ATG" 
+#line  2706 "VBNET.ATG" 
 		tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
 		
 	}
 
 	void WithStatement(
-#line  2668 "VBNET.ATG" 
+#line  2676 "VBNET.ATG" 
 out Statement withStatement) {
 
-#line  2670 "VBNET.ATG" 
+#line  2678 "VBNET.ATG" 
 		Statement blockStmt = null;
 		Expression expr = null;
 		
 		Expect(182);
 
-#line  2673 "VBNET.ATG" 
+#line  2681 "VBNET.ATG" 
 		Location start = t.Location; 
 		Expr(
-#line  2674 "VBNET.ATG" 
+#line  2682 "VBNET.ATG" 
 out expr);
 		EndOfStmt();
 
-#line  2676 "VBNET.ATG" 
+#line  2684 "VBNET.ATG" 
 		withStatement = new WithStatement(expr);
 		withStatement.StartLocation = start;
 		
 		Block(
-#line  2679 "VBNET.ATG" 
+#line  2687 "VBNET.ATG" 
 out blockStmt);
 
-#line  2681 "VBNET.ATG" 
+#line  2689 "VBNET.ATG" 
 		((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
 		
 		Expect(88);
 		Expect(182);
 
-#line  2684 "VBNET.ATG" 
+#line  2692 "VBNET.ATG" 
 		withStatement.EndLocation = t.Location; 
 	}
 
 	void WhileOrUntil(
-#line  2661 "VBNET.ATG" 
+#line  2669 "VBNET.ATG" 
 out ConditionType conditionType) {
 
-#line  2662 "VBNET.ATG" 
+#line  2670 "VBNET.ATG" 
 		conditionType = ConditionType.None; 
 		if (la.kind == 181) {
 			lexer.NextToken();
 
-#line  2663 "VBNET.ATG" 
+#line  2671 "VBNET.ATG" 
 			conditionType = ConditionType.While; 
 		} else if (la.kind == 177) {
 			lexer.NextToken();
 
-#line  2664 "VBNET.ATG" 
+#line  2672 "VBNET.ATG" 
 			conditionType = ConditionType.Until; 
-		} else SynErr(261);
+		} else SynErr(262);
 	}
 
 	void LoopControlVariable(
-#line  2507 "VBNET.ATG" 
+#line  2515 "VBNET.ATG" 
 out TypeReference type, out string name) {
 
-#line  2508 "VBNET.ATG" 
+#line  2516 "VBNET.ATG" 
 		ArrayList arrayModifiers = null;
 		type = null;
 		
 		Qualident(
-#line  2512 "VBNET.ATG" 
+#line  2520 "VBNET.ATG" 
 out name);
 		if (
-#line  2513 "VBNET.ATG" 
+#line  2521 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  2513 "VBNET.ATG" 
+#line  2521 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 48) {
 			lexer.NextToken();
 			TypeName(
-#line  2514 "VBNET.ATG" 
+#line  2522 "VBNET.ATG" 
 out type);
 
-#line  2514 "VBNET.ATG" 
+#line  2522 "VBNET.ATG" 
 			if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } 
 		}
 
-#line  2516 "VBNET.ATG" 
+#line  2524 "VBNET.ATG" 
 		if (type != null) {
 		if(type.RankSpecifier != null && arrayModifiers != null) {
 			Error("array rank only allowed one time");
@@ -5828,59 +5856,59 @@ out type);
 	}
 
 	void ReDimClause(
-#line  2586 "VBNET.ATG" 
+#line  2594 "VBNET.ATG" 
 out Expression expr) {
 		SimpleNonInvocationExpression(
-#line  2588 "VBNET.ATG" 
+#line  2596 "VBNET.ATG" 
 out expr);
 		ReDimClauseInternal(
-#line  2589 "VBNET.ATG" 
+#line  2597 "VBNET.ATG" 
 ref expr);
 	}
 
 	void CaseClauses(
-#line  2621 "VBNET.ATG" 
+#line  2629 "VBNET.ATG" 
 out List<CaseLabel> caseClauses) {
 
-#line  2623 "VBNET.ATG" 
+#line  2631 "VBNET.ATG" 
 		caseClauses = new List<CaseLabel>();
 		CaseLabel caseClause = null;
 		
 		CaseClause(
-#line  2626 "VBNET.ATG" 
+#line  2634 "VBNET.ATG" 
 out caseClause);
 
-#line  2626 "VBNET.ATG" 
+#line  2634 "VBNET.ATG" 
 		if (caseClause != null) { caseClauses.Add(caseClause); } 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			CaseClause(
-#line  2627 "VBNET.ATG" 
+#line  2635 "VBNET.ATG" 
 out caseClause);
 
-#line  2627 "VBNET.ATG" 
+#line  2635 "VBNET.ATG" 
 			if (caseClause != null) { caseClauses.Add(caseClause); } 
 		}
 	}
 
 	void OnErrorStatement(
-#line  2527 "VBNET.ATG" 
+#line  2535 "VBNET.ATG" 
 out OnErrorStatement stmt) {
 
-#line  2529 "VBNET.ATG" 
+#line  2537 "VBNET.ATG" 
 		stmt = null;
 		GotoStatement goToStatement = null;
 		
 		Expect(135);
 		Expect(92);
 		if (
-#line  2535 "VBNET.ATG" 
+#line  2543 "VBNET.ATG" 
 IsNegativeLabelName()) {
 			Expect(104);
 			Expect(15);
 			Expect(5);
 
-#line  2537 "VBNET.ATG" 
+#line  2545 "VBNET.ATG" 
 			long intLabel = Int64.Parse(t.val);
 			if(intLabel != 1) {
 				Error("invalid label in on error statement.");
@@ -5889,10 +5917,10 @@ IsNegativeLabelName()) {
 			
 		} else if (la.kind == 104) {
 			GotoStatement(
-#line  2543 "VBNET.ATG" 
+#line  2551 "VBNET.ATG" 
 out goToStatement);
 
-#line  2545 "VBNET.ATG" 
+#line  2553 "VBNET.ATG" 
 			string val = goToStatement.Label;
 			
 			// if value is numeric, make sure that is 0
@@ -5909,88 +5937,88 @@ out goToStatement);
 			lexer.NextToken();
 			Expect(128);
 
-#line  2559 "VBNET.ATG" 
+#line  2567 "VBNET.ATG" 
 			stmt = new OnErrorStatement(new ResumeStatement(true));
 			
-		} else SynErr(262);
+		} else SynErr(263);
 	}
 
 	void GotoStatement(
-#line  2565 "VBNET.ATG" 
+#line  2573 "VBNET.ATG" 
 out GotoStatement goToStatement) {
 
-#line  2567 "VBNET.ATG" 
+#line  2575 "VBNET.ATG" 
 		string label = String.Empty;
 		
 		Expect(104);
 		LabelName(
-#line  2570 "VBNET.ATG" 
+#line  2578 "VBNET.ATG" 
 out label);
 
-#line  2572 "VBNET.ATG" 
+#line  2580 "VBNET.ATG" 
 		goToStatement = new GotoStatement(label);
 		
 	}
 
 	void ResumeStatement(
-#line  2610 "VBNET.ATG" 
+#line  2618 "VBNET.ATG" 
 out ResumeStatement resumeStatement) {
 
-#line  2612 "VBNET.ATG" 
+#line  2620 "VBNET.ATG" 
 		resumeStatement = null;
 		string label = String.Empty;
 		
 		if (
-#line  2615 "VBNET.ATG" 
+#line  2623 "VBNET.ATG" 
 IsResumeNext()) {
 			Expect(153);
 			Expect(128);
 
-#line  2616 "VBNET.ATG" 
+#line  2624 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(true); 
 		} else if (la.kind == 153) {
 			lexer.NextToken();
-			if (StartOf(36)) {
+			if (StartOf(37)) {
 				LabelName(
-#line  2617 "VBNET.ATG" 
+#line  2625 "VBNET.ATG" 
 out label);
 			}
 
-#line  2617 "VBNET.ATG" 
+#line  2625 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(label); 
-		} else SynErr(263);
+		} else SynErr(264);
 	}
 
 	void ReDimClauseInternal(
-#line  2592 "VBNET.ATG" 
+#line  2600 "VBNET.ATG" 
 ref Expression expr) {
 
-#line  2593 "VBNET.ATG" 
+#line  2601 "VBNET.ATG" 
 		List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; 
 		while (la.kind == 10 || 
-#line  2596 "VBNET.ATG" 
+#line  2604 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			if (la.kind == 10) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  2595 "VBNET.ATG" 
+#line  2603 "VBNET.ATG" 
 out name);
 
-#line  2595 "VBNET.ATG" 
+#line  2603 "VBNET.ATG" 
 				expr = new FieldReferenceExpression(expr, name); 
 			} else {
 				InvocationExpression(
-#line  2597 "VBNET.ATG" 
+#line  2605 "VBNET.ATG" 
 ref expr);
 			}
 		}
 		Expect(24);
 		NormalOrReDimArgumentList(
-#line  2600 "VBNET.ATG" 
+#line  2608 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeRedim);
 		Expect(25);
 
-#line  2602 "VBNET.ATG" 
+#line  2610 "VBNET.ATG" 
 		expr = new InvocationExpression(expr, arguments);
 		if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
 			ReDimClauseInternal(ref expr);
@@ -5999,10 +6027,10 @@ out arguments, out canBeNormal, out canBeRedim);
 	}
 
 	void CaseClause(
-#line  2631 "VBNET.ATG" 
+#line  2639 "VBNET.ATG" 
 out CaseLabel caseClause) {
 
-#line  2633 "VBNET.ATG" 
+#line  2641 "VBNET.ATG" 
 		Expression expr = null;
 		Expression sexpr = null;
 		BinaryOperatorType op = BinaryOperatorType.None;
@@ -6011,9 +6039,9 @@ out CaseLabel caseClause) {
 		if (la.kind == 86) {
 			lexer.NextToken();
 
-#line  2639 "VBNET.ATG" 
+#line  2647 "VBNET.ATG" 
 			caseClause = new CaseLabel(); 
-		} else if (StartOf(37)) {
+		} else if (StartOf(38)) {
 			if (la.kind == 113) {
 				lexer.NextToken();
 			}
@@ -6021,76 +6049,76 @@ out CaseLabel caseClause) {
 			case 27: {
 				lexer.NextToken();
 
-#line  2643 "VBNET.ATG" 
+#line  2651 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 26: {
 				lexer.NextToken();
 
-#line  2644 "VBNET.ATG" 
+#line  2652 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 30: {
 				lexer.NextToken();
 
-#line  2645 "VBNET.ATG" 
+#line  2653 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 29: {
 				lexer.NextToken();
 
-#line  2646 "VBNET.ATG" 
+#line  2654 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 11: {
 				lexer.NextToken();
 
-#line  2647 "VBNET.ATG" 
+#line  2655 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 28: {
 				lexer.NextToken();
 
-#line  2648 "VBNET.ATG" 
+#line  2656 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
-			default: SynErr(264); break;
+			default: SynErr(265); break;
 			}
 			Expr(
-#line  2650 "VBNET.ATG" 
+#line  2658 "VBNET.ATG" 
 out expr);
 
-#line  2652 "VBNET.ATG" 
+#line  2660 "VBNET.ATG" 
 			caseClause = new CaseLabel(op, expr);
 			
-		} else if (StartOf(26)) {
+		} else if (StartOf(27)) {
 			Expr(
-#line  2654 "VBNET.ATG" 
+#line  2662 "VBNET.ATG" 
 out expr);
 			if (la.kind == 172) {
 				lexer.NextToken();
 				Expr(
-#line  2654 "VBNET.ATG" 
+#line  2662 "VBNET.ATG" 
 out sexpr);
 			}
 
-#line  2656 "VBNET.ATG" 
+#line  2664 "VBNET.ATG" 
 			caseClause = new CaseLabel(expr, sexpr);
 			
-		} else SynErr(265);
+		} else SynErr(266);
 	}
 
 	void CatchClauses(
-#line  2703 "VBNET.ATG" 
+#line  2711 "VBNET.ATG" 
 out List<CatchClause> catchClauses) {
 
-#line  2705 "VBNET.ATG" 
+#line  2713 "VBNET.ATG" 
 		catchClauses = new List<CatchClause>();
 		TypeReference type = null;
 		Statement blockStmt = null;
@@ -6099,30 +6127,30 @@ out List<CatchClause> catchClauses) {
 		
 		while (la.kind == 58) {
 			lexer.NextToken();
-			if (StartOf(12)) {
+			if (StartOf(13)) {
 				Identifier();
 
-#line  2713 "VBNET.ATG" 
+#line  2721 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 48) {
 					lexer.NextToken();
 					TypeName(
-#line  2713 "VBNET.ATG" 
+#line  2721 "VBNET.ATG" 
 out type);
 				}
 			}
 			if (la.kind == 180) {
 				lexer.NextToken();
 				Expr(
-#line  2714 "VBNET.ATG" 
+#line  2722 "VBNET.ATG" 
 out expr);
 			}
 			EndOfStmt();
 			Block(
-#line  2716 "VBNET.ATG" 
+#line  2724 "VBNET.ATG" 
 out blockStmt);
 
-#line  2717 "VBNET.ATG" 
+#line  2725 "VBNET.ATG" 
 			catchClauses.Add(new CatchClause(type, name, blockStmt, expr)); 
 		}
 	}
@@ -6357,54 +6385,55 @@ out blockStmt);
 			case 215: s = "invalid NonModuleDeclaration"; break;
 			case 216: s = "invalid Identifier"; break;
 			case 217: s = "invalid TypeParameterConstraints"; break;
-			case 218: s = "invalid NonArrayTypeName"; break;
-			case 219: s = "invalid MemberModifier"; break;
-			case 220: s = "invalid StructureMemberDecl"; break;
+			case 218: s = "invalid TypeParameterConstraint"; break;
+			case 219: s = "invalid NonArrayTypeName"; break;
+			case 220: s = "invalid MemberModifier"; break;
 			case 221: s = "invalid StructureMemberDecl"; break;
 			case 222: s = "invalid StructureMemberDecl"; break;
 			case 223: s = "invalid StructureMemberDecl"; break;
 			case 224: s = "invalid StructureMemberDecl"; break;
 			case 225: s = "invalid StructureMemberDecl"; break;
 			case 226: s = "invalid StructureMemberDecl"; break;
-			case 227: s = "invalid InterfaceMemberDecl"; break;
+			case 227: s = "invalid StructureMemberDecl"; break;
 			case 228: s = "invalid InterfaceMemberDecl"; break;
-			case 229: s = "invalid Charset"; break;
-			case 230: s = "invalid IdentifierForFieldDeclaration"; break;
-			case 231: s = "invalid VariableDeclaratorPartAfterIdentifier"; break;
-			case 232: s = "invalid AccessorDecls"; break;
-			case 233: s = "invalid EventAccessorDeclaration"; break;
-			case 234: s = "invalid OverloadableOperator"; break;
-			case 235: s = "invalid VariableInitializer"; break;
-			case 236: s = "invalid EventMemberSpecifier"; break;
+			case 229: s = "invalid InterfaceMemberDecl"; break;
+			case 230: s = "invalid Charset"; break;
+			case 231: s = "invalid IdentifierForFieldDeclaration"; break;
+			case 232: s = "invalid VariableDeclaratorPartAfterIdentifier"; break;
+			case 233: s = "invalid AccessorDecls"; break;
+			case 234: s = "invalid EventAccessorDeclaration"; break;
+			case 235: s = "invalid OverloadableOperator"; break;
+			case 236: s = "invalid VariableInitializer"; break;
 			case 237: s = "invalid EventMemberSpecifier"; break;
-			case 238: s = "invalid AssignmentOperator"; break;
-			case 239: s = "invalid SimpleNonInvocationExpression"; break;
+			case 238: s = "invalid EventMemberSpecifier"; break;
+			case 239: s = "invalid AssignmentOperator"; break;
 			case 240: s = "invalid SimpleNonInvocationExpression"; break;
 			case 241: s = "invalid SimpleNonInvocationExpression"; break;
 			case 242: s = "invalid SimpleNonInvocationExpression"; break;
-			case 243: s = "invalid InvocationExpression"; break;
+			case 243: s = "invalid SimpleNonInvocationExpression"; break;
 			case 244: s = "invalid InvocationExpression"; break;
-			case 245: s = "invalid PrimitiveTypeName"; break;
-			case 246: s = "invalid CastTarget"; break;
-			case 247: s = "invalid ComparisonExpr"; break;
-			case 248: s = "invalid Argument"; break;
-			case 249: s = "invalid QualIdentAndTypeArguments"; break;
-			case 250: s = "invalid AttributeArguments"; break;
-			case 251: s = "invalid ParameterModifier"; break;
-			case 252: s = "invalid Statement"; break;
-			case 253: s = "invalid LabelName"; break;
-			case 254: s = "invalid EmbeddedStatement"; break;
+			case 245: s = "invalid InvocationExpression"; break;
+			case 246: s = "invalid PrimitiveTypeName"; break;
+			case 247: s = "invalid CastTarget"; break;
+			case 248: s = "invalid ComparisonExpr"; break;
+			case 249: s = "invalid Argument"; break;
+			case 250: s = "invalid QualIdentAndTypeArguments"; break;
+			case 251: s = "invalid AttributeArguments"; break;
+			case 252: s = "invalid ParameterModifier"; break;
+			case 253: s = "invalid Statement"; break;
+			case 254: s = "invalid LabelName"; break;
 			case 255: s = "invalid EmbeddedStatement"; break;
 			case 256: s = "invalid EmbeddedStatement"; break;
 			case 257: s = "invalid EmbeddedStatement"; break;
 			case 258: s = "invalid EmbeddedStatement"; break;
 			case 259: s = "invalid EmbeddedStatement"; break;
 			case 260: s = "invalid EmbeddedStatement"; break;
-			case 261: s = "invalid WhileOrUntil"; break;
-			case 262: s = "invalid OnErrorStatement"; break;
-			case 263: s = "invalid ResumeStatement"; break;
-			case 264: s = "invalid CaseClause"; break;
+			case 261: s = "invalid EmbeddedStatement"; break;
+			case 262: s = "invalid WhileOrUntil"; break;
+			case 263: s = "invalid OnErrorStatement"; break;
+			case 264: s = "invalid ResumeStatement"; break;
 			case 265: s = "invalid CaseClause"; break;
+			case 266: s = "invalid CaseClause"; break;
 
 			default: s = "error " + errorNumber; break;
 		}
@@ -6422,6 +6451,7 @@ out blockStmt);
 	{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,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,x, T,x,x,x, x,x,x,x, x,x,T,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,T,T,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, T,x,x,x, x,x,x,x, x,T,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,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,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,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,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, 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,x,x,x, x,x,x,x, x,x,x,x, x,x,x,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,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,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,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,T,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, T,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,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, 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,T, x,x,x,x, x,T,x,x, x,x,x,x, x,x,x,T, 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,T, T,x,x,x, x,T,T,x, x,T,x,x, x,x,x,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, x,x,T,x, x,x,x,x, T,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,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, 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,T, x,x,x,x, x,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, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,T,x,x, x,T,x,x, x,x,x,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, x,x,T,x, x,x,x,x, T,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,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,T,T, T,T,x,x, x,x,x,x, x,x,T,x, x,T,x,x, x,x,x,T, T,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,T,T,T, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,T,T,x, T,T,T,T, T,x,T,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, T,T,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, x,T,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, 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,T,T, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,T,T,x, x,T,x,T, T,x,T,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,T, T,x,x,x, x,x,x,x, x,x,x,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 21571b2515..fd5b139992 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
@@ -382,16 +382,24 @@ TypeParameterConstraints<TemplateDefinition template>
 	"As"
 	(
 		"{"
-		TypeName<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
+		TypeParameterConstraint<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
 		{
 			","
-			TypeName<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
+			TypeParameterConstraint<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
 		}
 		"}"
-		| TypeName<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
+		| TypeParameterConstraint<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
 	)
 .
 
+TypeParameterConstraint<out TypeReference constraint>
+(. constraint = null; .)
+=	"Class"		(. constraint = TypeReference.ClassConstraint; .)
+|	"Structure"	(. constraint = TypeReference.StructConstraint; .)
+|	"New"		(. constraint = TypeReference.NewConstraint; .)
+|	TypeName<out constraint>
+.
+
 /* 6.4.2 */
 NonModuleDeclaration<ModifierList m, List<AttributeSection> attributes>
 			(.
diff --git a/src/Libraries/NRefactory/Project/Src/PrettyPrinter/CSharp/CSharpOutputVisitor.cs b/src/Libraries/NRefactory/Project/Src/PrettyPrinter/CSharp/CSharpOutputVisitor.cs
index 01e6e7e43b..9cee189c04 100644
--- a/src/Libraries/NRefactory/Project/Src/PrettyPrinter/CSharp/CSharpOutputVisitor.cs
+++ b/src/Libraries/NRefactory/Project/Src/PrettyPrinter/CSharp/CSharpOutputVisitor.cs
@@ -128,9 +128,19 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
 		
 		public object VisitTypeReference(TypeReference typeReference, object data)
 		{
-			PrintTypeReferenceWithoutArray(typeReference);
-			if (typeReference.IsArrayType) {
-				PrintArrayRank(typeReference.RankSpecifier, 0);
+			if (typeReference == TypeReference.ClassConstraint) {
+				outputFormatter.PrintToken(Tokens.Class);
+			} else if (typeReference == TypeReference.StructConstraint) {
+				outputFormatter.PrintToken(Tokens.Struct);
+			} else if (typeReference == TypeReference.NewConstraint) {
+				outputFormatter.PrintToken(Tokens.New);
+				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+			} else {
+				PrintTypeReferenceWithoutArray(typeReference);
+				if (typeReference.IsArrayType) {
+					PrintArrayRank(typeReference.RankSpecifier, 0);
+				}
 			}
 			return null;
 		}
diff --git a/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs b/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
index b7f461d56e..a73b787456 100644
--- a/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
+++ b/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
@@ -129,9 +129,17 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
 
 		public object VisitTypeReference(TypeReference typeReference, object data)
 		{
-			PrintTypeReferenceWithoutArray(typeReference);
-			if (typeReference.IsArrayType) {
-				PrintArrayRank(typeReference.RankSpecifier, 0);
+			if (typeReference == TypeReference.ClassConstraint) {
+				outputFormatter.PrintToken(Tokens.Class);
+			} else if (typeReference == TypeReference.StructConstraint) {
+				outputFormatter.PrintToken(Tokens.Structure);
+			} else if (typeReference == TypeReference.NewConstraint) {
+				outputFormatter.PrintToken(Tokens.New);
+			} else {
+				PrintTypeReferenceWithoutArray(typeReference);
+				if (typeReference.IsArrayType) {
+					PrintArrayRank(typeReference.RankSpecifier, 0);
+				}
 			}
 			return null;
 		}
diff --git a/src/Libraries/NRefactory/Test/Output/CSharp/CSharpOutputTest.cs b/src/Libraries/NRefactory/Test/Output/CSharp/CSharpOutputTest.cs
index 21b48588de..76cdfd3a30 100644
--- a/src/Libraries/NRefactory/Test/Output/CSharp/CSharpOutputTest.cs
+++ b/src/Libraries/NRefactory/Test/Output/CSharp/CSharpOutputTest.cs
@@ -376,5 +376,23 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 		{
 			TestStatement("using (obj) {\n}");
 		}
+		
+		[Test]
+		public void NewConstraint()
+		{
+			TestProgram("public struct Rational<T, O> where O : IRationalMath<T>, new()\n{\n}");
+		}
+		
+		[Test]
+		public void StructConstraint()
+		{
+			TestProgram("public struct Rational<T, O> where O : struct\n{\n}");
+		}
+		
+		[Test]
+		public void ClassConstraint()
+		{
+			TestProgram("public struct Rational<T, O> where O : class\n{\n}");
+		}
 	}
 }
diff --git a/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs b/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs
index 4833f0f7ae..c8ffdfd152 100644
--- a/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs
+++ b/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs
@@ -373,5 +373,23 @@ End Using");
 			              "\t.AddLine(New Point(Me.ClientSize.Width / 2, 0), (New Point(Me.ClientSize.Width / 2, Me.ClientSize.Height)))\n" +
 			              "End With");
 		}
+		
+		[Test]
+		public void NewConstraint()
+		{
+			TestProgram("Public Class Rational(Of T, O As {IRationalMath(Of T), New})\nEnd Class");
+		}
+		
+		[Test]
+		public void StructConstraint()
+		{
+			TestProgram("Public Class Rational(Of T, O As {IRationalMath(Of T), Structure})\nEnd Class");
+		}
+		
+		[Test]
+		public void ClassConstraint()
+		{
+			TestProgram("Public Class Rational(Of T, O As {IRationalMath(Of T), Class})\nEnd Class");
+		}
 	}
 }