diff --git a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
index 482732510d..86aca2f292 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
@@ -2223,7 +2223,8 @@ out getRegion, out setRegion);
 
 #line  1074 "cs.ATG" 
 		TypeReference type;
-			AttributeSection section;
+		
+		AttributeSection section;
 		Modifiers mod = Modifiers.None;
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
index f8e3b7b69f..c8199fabb5 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
@@ -180,7 +180,7 @@ out u);
 	void GlobalAttributeSection() {
 		Expect(28);
 
-#line  2567 "VBNET.ATG" 
+#line  2562 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (la.kind == 52) {
 			lexer.NextToken();
@@ -188,20 +188,20 @@ out u);
 			lexer.NextToken();
 		} else SynErr(226);
 
-#line  2569 "VBNET.ATG" 
+#line  2564 "VBNET.ATG" 
 		string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
 		List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		Expect(11);
 		Attribute(
-#line  2573 "VBNET.ATG" 
+#line  2568 "VBNET.ATG" 
 out attribute);
 
-#line  2573 "VBNET.ATG" 
+#line  2568 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2574 "VBNET.ATG" 
+#line  2569 "VBNET.ATG" 
 NotFinalComma()) {
 			if (la.kind == 12) {
 				lexer.NextToken();
@@ -213,10 +213,10 @@ NotFinalComma()) {
 				Expect(11);
 			}
 			Attribute(
-#line  2574 "VBNET.ATG" 
+#line  2569 "VBNET.ATG" 
 out attribute);
 
-#line  2574 "VBNET.ATG" 
+#line  2569 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 12) {
@@ -225,7 +225,7 @@ out attribute);
 		Expect(27);
 		EndOfStmt();
 
-#line  2579 "VBNET.ATG" 
+#line  2574 "VBNET.ATG" 
 		AttributeSection section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -334,47 +334,47 @@ out aliasedType);
 	}
 
 	void Qualident(
-#line  3325 "VBNET.ATG" 
+#line  3320 "VBNET.ATG" 
 out string qualident) {
 
-#line  3327 "VBNET.ATG" 
+#line  3322 "VBNET.ATG" 
 		string name;
 		qualidentBuilder.Length = 0; 
 		
 		Identifier();
 
-#line  3331 "VBNET.ATG" 
+#line  3326 "VBNET.ATG" 
 		qualidentBuilder.Append(t.val); 
 		while (
-#line  3332 "VBNET.ATG" 
+#line  3327 "VBNET.ATG" 
 DotAndIdentOrKw()) {
 			Expect(16);
 			IdentifierOrKeyword(
-#line  3332 "VBNET.ATG" 
+#line  3327 "VBNET.ATG" 
 out name);
 
-#line  3332 "VBNET.ATG" 
+#line  3327 "VBNET.ATG" 
 			qualidentBuilder.Append('.'); qualidentBuilder.Append(name); 
 		}
 
-#line  3334 "VBNET.ATG" 
+#line  3329 "VBNET.ATG" 
 		qualident = qualidentBuilder.ToString(); 
 	}
 
 	void TypeName(
-#line  2440 "VBNET.ATG" 
+#line  2435 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  2441 "VBNET.ATG" 
+#line  2436 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  2443 "VBNET.ATG" 
+#line  2438 "VBNET.ATG" 
 out typeref, false);
 		ArrayTypeModifiers(
-#line  2447 "VBNET.ATG" 
+#line  2442 "VBNET.ATG" 
 out rank);
 
-#line  2448 "VBNET.ATG" 
+#line  2443 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -397,35 +397,35 @@ out rank);
 	}
 
 	void AttributeSection(
-#line  2642 "VBNET.ATG" 
+#line  2637 "VBNET.ATG" 
 out AttributeSection section) {
 
-#line  2644 "VBNET.ATG" 
+#line  2639 "VBNET.ATG" 
 		string attributeTarget = "";List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		
 		Expect(28);
 
-#line  2648 "VBNET.ATG" 
+#line  2643 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (
-#line  2649 "VBNET.ATG" 
+#line  2644 "VBNET.ATG" 
 IsLocalAttrTarget()) {
 			if (la.kind == 106) {
 				lexer.NextToken();
 
-#line  2650 "VBNET.ATG" 
+#line  2645 "VBNET.ATG" 
 				attributeTarget = "event";
 			} else if (la.kind == 180) {
 				lexer.NextToken();
 
-#line  2651 "VBNET.ATG" 
+#line  2646 "VBNET.ATG" 
 				attributeTarget = "return";
 			} else {
 				Identifier();
 
-#line  2654 "VBNET.ATG" 
+#line  2649 "VBNET.ATG" 
 				string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
 				if (val != "field"	|| val != "method" ||
 					val != "module" || val != "param"  ||
@@ -438,20 +438,20 @@ IsLocalAttrTarget()) {
 			Expect(11);
 		}
 		Attribute(
-#line  2664 "VBNET.ATG" 
+#line  2659 "VBNET.ATG" 
 out attribute);
 
-#line  2664 "VBNET.ATG" 
+#line  2659 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2665 "VBNET.ATG" 
+#line  2660 "VBNET.ATG" 
 NotFinalComma()) {
 			Expect(12);
 			Attribute(
-#line  2665 "VBNET.ATG" 
+#line  2660 "VBNET.ATG" 
 out attribute);
 
-#line  2665 "VBNET.ATG" 
+#line  2660 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 12) {
@@ -459,7 +459,7 @@ out attribute);
 		}
 		Expect(27);
 
-#line  2669 "VBNET.ATG" 
+#line  2664 "VBNET.ATG" 
 		section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -470,69 +470,69 @@ out attribute);
 	}
 
 	void TypeModifier(
-#line  3408 "VBNET.ATG" 
+#line  3403 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 173: {
 			lexer.NextToken();
 
-#line  3409 "VBNET.ATG" 
+#line  3404 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location); 
 			break;
 		}
 		case 172: {
 			lexer.NextToken();
 
-#line  3410 "VBNET.ATG" 
+#line  3405 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location); 
 			break;
 		}
 		case 112: {
 			lexer.NextToken();
 
-#line  3411 "VBNET.ATG" 
+#line  3406 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location); 
 			break;
 		}
 		case 170: {
 			lexer.NextToken();
 
-#line  3412 "VBNET.ATG" 
+#line  3407 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location); 
 			break;
 		}
 		case 185: {
 			lexer.NextToken();
 
-#line  3413 "VBNET.ATG" 
+#line  3408 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location); 
 			break;
 		}
 		case 184: {
 			lexer.NextToken();
 
-#line  3414 "VBNET.ATG" 
+#line  3409 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location); 
 			break;
 		}
 		case 142: {
 			lexer.NextToken();
 
-#line  3415 "VBNET.ATG" 
+#line  3410 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location); 
 			break;
 		}
 		case 152: {
 			lexer.NextToken();
 
-#line  3416 "VBNET.ATG" 
+#line  3411 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location); 
 			break;
 		}
 		case 168: {
 			lexer.NextToken();
 
-#line  3417 "VBNET.ATG" 
+#line  3412 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location); 
 			break;
 		}
@@ -962,28 +962,28 @@ out typeRef);
 	}
 
 	void TypeImplementsClause(
-#line  1596 "VBNET.ATG" 
+#line  1591 "VBNET.ATG" 
 out List<TypeReference> baseInterfaces) {
 
-#line  1598 "VBNET.ATG" 
+#line  1593 "VBNET.ATG" 
 		baseInterfaces = new List<TypeReference>();
 		TypeReference type = null;
 		
 		Expect(123);
 		TypeName(
-#line  1601 "VBNET.ATG" 
+#line  1596 "VBNET.ATG" 
 out type);
 
-#line  1603 "VBNET.ATG" 
+#line  1598 "VBNET.ATG" 
 		if (type != null) baseInterfaces.Add(type);
 		
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  1606 "VBNET.ATG" 
+#line  1601 "VBNET.ATG" 
 out type);
 
-#line  1607 "VBNET.ATG" 
+#line  1602 "VBNET.ATG" 
 			if (type != null) baseInterfaces.Add(type); 
 		}
 		EndOfStmt();
@@ -1113,10 +1113,10 @@ m, attributes);
 	}
 
 	void NonArrayTypeName(
-#line  2466 "VBNET.ATG" 
+#line  2461 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  2468 "VBNET.ATG" 
+#line  2463 "VBNET.ATG" 
 		string name;
 		typeref = null;
 		bool isGlobal = false;
@@ -1126,36 +1126,36 @@ out TypeReference typeref, bool canBeUnbound) {
 				lexer.NextToken();
 				Expect(16);
 
-#line  2473 "VBNET.ATG" 
+#line  2468 "VBNET.ATG" 
 				isGlobal = true; 
 			}
 			QualIdentAndTypeArguments(
-#line  2474 "VBNET.ATG" 
+#line  2469 "VBNET.ATG" 
 out typeref, canBeUnbound);
 
-#line  2475 "VBNET.ATG" 
+#line  2470 "VBNET.ATG" 
 			typeref.IsGlobal = isGlobal; 
 			while (la.kind == 16) {
 				lexer.NextToken();
 
-#line  2476 "VBNET.ATG" 
+#line  2471 "VBNET.ATG" 
 				TypeReference nestedTypeRef; 
 				QualIdentAndTypeArguments(
-#line  2477 "VBNET.ATG" 
+#line  2472 "VBNET.ATG" 
 out nestedTypeRef, canBeUnbound);
 
-#line  2478 "VBNET.ATG" 
+#line  2473 "VBNET.ATG" 
 				typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes); 
 			}
 		} else if (la.kind == 154) {
 			lexer.NextToken();
 
-#line  2481 "VBNET.ATG" 
+#line  2476 "VBNET.ATG" 
 			typeref = new TypeReference("System.Object", true); 
 			if (la.kind == 21) {
 				lexer.NextToken();
 
-#line  2485 "VBNET.ATG" 
+#line  2480 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
@@ -1163,15 +1163,15 @@ out nestedTypeRef, canBeUnbound);
 			}
 		} else if (StartOf(11)) {
 			PrimitiveTypeName(
-#line  2491 "VBNET.ATG" 
+#line  2486 "VBNET.ATG" 
 out name);
 
-#line  2491 "VBNET.ATG" 
+#line  2486 "VBNET.ATG" 
 			typeref = new TypeReference(name, true); 
 			if (la.kind == 21) {
 				lexer.NextToken();
 
-#line  2495 "VBNET.ATG" 
+#line  2490 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
@@ -1210,27 +1210,27 @@ out f);
 	}
 
 	void InterfaceBase(
-#line  1581 "VBNET.ATG" 
+#line  1576 "VBNET.ATG" 
 out List<TypeReference> bases) {
 
-#line  1583 "VBNET.ATG" 
+#line  1578 "VBNET.ATG" 
 		TypeReference type;
 		bases = new List<TypeReference>();
 		
 		Expect(127);
 		TypeName(
-#line  1587 "VBNET.ATG" 
+#line  1582 "VBNET.ATG" 
 out type);
 
-#line  1587 "VBNET.ATG" 
+#line  1582 "VBNET.ATG" 
 		if (type != null) bases.Add(type); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  1590 "VBNET.ATG" 
+#line  1585 "VBNET.ATG" 
 out type);
 
-#line  1590 "VBNET.ATG" 
+#line  1585 "VBNET.ATG" 
 			if (type != null) bases.Add(type); 
 		}
 		EndOfStmt();
@@ -1257,162 +1257,162 @@ TypeDeclaration newType) {
 	}
 
 	void FormalParameterList(
-#line  2679 "VBNET.ATG" 
+#line  2674 "VBNET.ATG" 
 List<ParameterDeclarationExpression> parameter) {
 
-#line  2680 "VBNET.ATG" 
+#line  2675 "VBNET.ATG" 
 		ParameterDeclarationExpression p; 
 		FormalParameter(
-#line  2682 "VBNET.ATG" 
+#line  2677 "VBNET.ATG" 
 out p);
 
-#line  2682 "VBNET.ATG" 
+#line  2677 "VBNET.ATG" 
 		if (p != null) parameter.Add(p); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			FormalParameter(
-#line  2684 "VBNET.ATG" 
+#line  2679 "VBNET.ATG" 
 out p);
 
-#line  2684 "VBNET.ATG" 
+#line  2679 "VBNET.ATG" 
 			if (p != null) parameter.Add(p); 
 		}
 	}
 
 	void MemberModifier(
-#line  3420 "VBNET.ATG" 
+#line  3415 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 142: {
 			lexer.NextToken();
 
-#line  3421 "VBNET.ATG" 
+#line  3416 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 89: {
 			lexer.NextToken();
 
-#line  3422 "VBNET.ATG" 
+#line  3417 "VBNET.ATG" 
 			m.Add(Modifiers.Default, t.Location);
 			break;
 		}
 		case 112: {
 			lexer.NextToken();
 
-#line  3423 "VBNET.ATG" 
+#line  3418 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location);
 			break;
 		}
 		case 184: {
 			lexer.NextToken();
 
-#line  3424 "VBNET.ATG" 
+#line  3419 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location);
 			break;
 		}
 		case 166: {
 			lexer.NextToken();
 
-#line  3425 "VBNET.ATG" 
+#line  3420 "VBNET.ATG" 
 			m.Add(Modifiers.Override, t.Location);
 			break;
 		}
 		case 143: {
 			lexer.NextToken();
 
-#line  3426 "VBNET.ATG" 
+#line  3421 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 170: {
 			lexer.NextToken();
 
-#line  3427 "VBNET.ATG" 
+#line  3422 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location);
 			break;
 		}
 		case 172: {
 			lexer.NextToken();
 
-#line  3428 "VBNET.ATG" 
+#line  3423 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location);
 			break;
 		}
 		case 173: {
 			lexer.NextToken();
 
-#line  3429 "VBNET.ATG" 
+#line  3424 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location);
 			break;
 		}
 		case 152: {
 			lexer.NextToken();
 
-#line  3430 "VBNET.ATG" 
+#line  3425 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 153: {
 			lexer.NextToken();
 
-#line  3431 "VBNET.ATG" 
+#line  3426 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 185: {
 			lexer.NextToken();
 
-#line  3432 "VBNET.ATG" 
+#line  3427 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location);
 			break;
 		}
 		case 165: {
 			lexer.NextToken();
 
-#line  3433 "VBNET.ATG" 
+#line  3428 "VBNET.ATG" 
 			m.Add(Modifiers.Virtual, t.Location);
 			break;
 		}
 		case 164: {
 			lexer.NextToken();
 
-#line  3434 "VBNET.ATG" 
+#line  3429 "VBNET.ATG" 
 			m.Add(Modifiers.Overloads, t.Location);
 			break;
 		}
 		case 175: {
 			lexer.NextToken();
 
-#line  3435 "VBNET.ATG" 
+#line  3430 "VBNET.ATG" 
 			m.Add(Modifiers.ReadOnly, t.Location);
 			break;
 		}
 		case 220: {
 			lexer.NextToken();
 
-#line  3436 "VBNET.ATG" 
+#line  3431 "VBNET.ATG" 
 			m.Add(Modifiers.WriteOnly, t.Location);
 			break;
 		}
 		case 219: {
 			lexer.NextToken();
 
-#line  3437 "VBNET.ATG" 
+#line  3432 "VBNET.ATG" 
 			m.Add(Modifiers.WithEvents, t.Location);
 			break;
 		}
 		case 92: {
 			lexer.NextToken();
 
-#line  3438 "VBNET.ATG" 
+#line  3433 "VBNET.ATG" 
 			m.Add(Modifiers.Dim, t.Location);
 			break;
 		}
 		case 168: {
 			lexer.NextToken();
 
-#line  3439 "VBNET.ATG" 
+#line  3434 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location);
 			break;
 		}
@@ -1979,29 +1979,23 @@ out initializer);
 out type);
 				} else SynErr(243);
 			}
-
-#line  1098 "VBNET.ATG" 
-			if(type == null) {
-			type = new TypeReference("System.Object", true);
-			}
-			
 			if (la.kind == 10) {
 				lexer.NextToken();
 				VariableInitializer(
-#line  1102 "VBNET.ATG" 
+#line  1097 "VBNET.ATG" 
 out initializer);
 			}
 			if (la.kind == 123) {
 				ImplementsClause(
-#line  1103 "VBNET.ATG" 
+#line  1098 "VBNET.ATG" 
 out implementsClause);
 			}
 			EndOfStmt();
 			if (
-#line  1107 "VBNET.ATG" 
+#line  1102 "VBNET.ATG" 
 IsMustOverride(m) || IsAutomaticProperty()) {
 
-#line  1109 "VBNET.ATG" 
+#line  1104 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -2014,7 +2008,7 @@ IsMustOverride(m) || IsAutomaticProperty()) {
 				
 			} else if (StartOf(17)) {
 
-#line  1121 "VBNET.ATG" 
+#line  1116 "VBNET.ATG" 
 				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
 				pDecl.StartLocation = m.GetDeclarationLocation(startPos);
 				pDecl.EndLocation   = t.Location;
@@ -2026,13 +2020,13 @@ IsMustOverride(m) || IsAutomaticProperty()) {
 				PropertySetRegion setRegion;
 				
 				AccessorDecls(
-#line  1131 "VBNET.ATG" 
+#line  1126 "VBNET.ATG" 
 out getRegion, out setRegion);
 				Expect(100);
 				Expect(171);
 				EndOfStmt();
 
-#line  1135 "VBNET.ATG" 
+#line  1130 "VBNET.ATG" 
 				pDecl.GetRegion = getRegion;
 				pDecl.SetRegion = setRegion;
 				pDecl.BodyEnd = t.Location; // t = EndOfStmt; not "Property"
@@ -2044,11 +2038,11 @@ out getRegion, out setRegion);
 		case 85: {
 			lexer.NextToken();
 
-#line  1142 "VBNET.ATG" 
+#line  1137 "VBNET.ATG" 
 			Location startPos = t.Location; 
 			Expect(106);
 
-#line  1144 "VBNET.ATG" 
+#line  1139 "VBNET.ATG" 
 			m.Check(Modifiers.VBCustomEvents);
 			EventAddRemoveRegion eventAccessorDeclaration;
 			EventAddRegion addHandlerAccessorDeclaration = null;
@@ -2058,24 +2052,24 @@ out getRegion, out setRegion);
 			
 			Identifier();
 
-#line  1151 "VBNET.ATG" 
+#line  1146 "VBNET.ATG" 
 			string customEventName = t.val; 
 			Expect(50);
 			TypeName(
-#line  1152 "VBNET.ATG" 
+#line  1147 "VBNET.ATG" 
 out type);
 			if (la.kind == 123) {
 				ImplementsClause(
-#line  1153 "VBNET.ATG" 
+#line  1148 "VBNET.ATG" 
 out implementsClause);
 			}
 			EndOfStmt();
 			while (StartOf(18)) {
 				EventAccessorDeclaration(
-#line  1156 "VBNET.ATG" 
+#line  1151 "VBNET.ATG" 
 out eventAccessorDeclaration);
 
-#line  1158 "VBNET.ATG" 
+#line  1153 "VBNET.ATG" 
 				if(eventAccessorDeclaration is EventAddRegion)
 				{
 					addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
@@ -2094,7 +2088,7 @@ out eventAccessorDeclaration);
 			Expect(106);
 			EndOfStmt();
 
-#line  1174 "VBNET.ATG" 
+#line  1169 "VBNET.ATG" 
 			if(addHandlerAccessorDeclaration == null)
 			{
 				Error("Need to provide AddHandler accessor.");
@@ -2125,24 +2119,24 @@ out eventAccessorDeclaration);
 		}
 		case 147: case 158: case 217: {
 
-#line  1200 "VBNET.ATG" 
+#line  1195 "VBNET.ATG" 
 			ConversionType opConversionType = ConversionType.None; 
 			if (la.kind == 147 || la.kind == 217) {
 				if (la.kind == 217) {
 					lexer.NextToken();
 
-#line  1201 "VBNET.ATG" 
+#line  1196 "VBNET.ATG" 
 					opConversionType = ConversionType.Implicit; 
 				} else {
 					lexer.NextToken();
 
-#line  1202 "VBNET.ATG" 
+#line  1197 "VBNET.ATG" 
 					opConversionType = ConversionType.Explicit;
 				}
 			}
 			Expect(158);
 
-#line  1205 "VBNET.ATG" 
+#line  1200 "VBNET.ATG" 
 			m.Check(Modifiers.VBOperators);
 			Location startPos = t.Location;
 			TypeReference returnType = NullTypeReference.Instance;
@@ -2153,7 +2147,7 @@ out eventAccessorDeclaration);
 			List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
 			
 			OverloadableOperator(
-#line  1214 "VBNET.ATG" 
+#line  1209 "VBNET.ATG" 
 out operatorType);
 			Expect(25);
 			if (la.kind == 59) {
@@ -2161,16 +2155,16 @@ out operatorType);
 			}
 			Identifier();
 
-#line  1215 "VBNET.ATG" 
+#line  1210 "VBNET.ATG" 
 			operandName = t.val; 
 			if (la.kind == 50) {
 				lexer.NextToken();
 				TypeName(
-#line  1216 "VBNET.ATG" 
+#line  1211 "VBNET.ATG" 
 out operandType);
 			}
 
-#line  1217 "VBNET.ATG" 
+#line  1212 "VBNET.ATG" 
 			parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In)); 
 			while (la.kind == 12) {
 				lexer.NextToken();
@@ -2179,51 +2173,51 @@ out operandType);
 				}
 				Identifier();
 
-#line  1221 "VBNET.ATG" 
+#line  1216 "VBNET.ATG" 
 				operandName = t.val; 
 				if (la.kind == 50) {
 					lexer.NextToken();
 					TypeName(
-#line  1222 "VBNET.ATG" 
+#line  1217 "VBNET.ATG" 
 out operandType);
 				}
 
-#line  1223 "VBNET.ATG" 
+#line  1218 "VBNET.ATG" 
 				parameters.Add(new ParameterDeclarationExpression(operandType, operandName, ParameterModifiers.In)); 
 			}
 			Expect(26);
 
-#line  1226 "VBNET.ATG" 
+#line  1221 "VBNET.ATG" 
 			Location endPos = t.EndLocation; 
 			if (la.kind == 50) {
 				lexer.NextToken();
 				while (la.kind == 28) {
 					AttributeSection(
-#line  1227 "VBNET.ATG" 
+#line  1222 "VBNET.ATG" 
 out section);
 
-#line  1228 "VBNET.ATG" 
+#line  1223 "VBNET.ATG" 
 					if (section != null) {
 					section.AttributeTarget = "return";
 					attributes.Add(section);
 					} 
 				}
 				TypeName(
-#line  1232 "VBNET.ATG" 
+#line  1227 "VBNET.ATG" 
 out returnType);
 
-#line  1232 "VBNET.ATG" 
+#line  1227 "VBNET.ATG" 
 				endPos = t.EndLocation; 
 			}
 			Expect(1);
 			Block(
-#line  1234 "VBNET.ATG" 
+#line  1229 "VBNET.ATG" 
 out stmt);
 			Expect(100);
 			Expect(158);
 			EndOfStmt();
 
-#line  1236 "VBNET.ATG" 
+#line  1231 "VBNET.ATG" 
 			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
 			Modifier = m.Modifier,
 			Attributes = attributes,
@@ -2484,107 +2478,107 @@ mod, attributes);
 	}
 
 	void Expr(
-#line  1640 "VBNET.ATG" 
+#line  1635 "VBNET.ATG" 
 out Expression expr) {
 
-#line  1641 "VBNET.ATG" 
+#line  1636 "VBNET.ATG" 
 		expr = null; 
 		if (
-#line  1642 "VBNET.ATG" 
+#line  1637 "VBNET.ATG" 
 IsQueryExpression() ) {
 			QueryExpr(
-#line  1643 "VBNET.ATG" 
+#line  1638 "VBNET.ATG" 
 out expr);
 		} else if (la.kind == 114) {
 			LambdaExpr(
-#line  1644 "VBNET.ATG" 
+#line  1639 "VBNET.ATG" 
 out expr);
 		} else if (StartOf(21)) {
 			DisjunctionExpr(
-#line  1645 "VBNET.ATG" 
+#line  1640 "VBNET.ATG" 
 out expr);
 		} else SynErr(248);
 	}
 
 	void ImplementsClause(
-#line  1613 "VBNET.ATG" 
+#line  1608 "VBNET.ATG" 
 out List<InterfaceImplementation> baseInterfaces) {
 
-#line  1615 "VBNET.ATG" 
+#line  1610 "VBNET.ATG" 
 		baseInterfaces = new List<InterfaceImplementation>();
 		TypeReference type = null;
 		string memberName = null;
 		
 		Expect(123);
 		NonArrayTypeName(
-#line  1620 "VBNET.ATG" 
+#line  1615 "VBNET.ATG" 
 out type, false);
 
-#line  1621 "VBNET.ATG" 
+#line  1616 "VBNET.ATG" 
 		if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-#line  1622 "VBNET.ATG" 
+#line  1617 "VBNET.ATG" 
 		baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			NonArrayTypeName(
-#line  1624 "VBNET.ATG" 
+#line  1619 "VBNET.ATG" 
 out type, false);
 
-#line  1625 "VBNET.ATG" 
+#line  1620 "VBNET.ATG" 
 			if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); 
 
-#line  1626 "VBNET.ATG" 
+#line  1621 "VBNET.ATG" 
 			baseInterfaces.Add(new InterfaceImplementation(type, memberName)); 
 		}
 	}
 
 	void HandlesClause(
-#line  1571 "VBNET.ATG" 
+#line  1566 "VBNET.ATG" 
 out List<string> handlesClause) {
 
-#line  1573 "VBNET.ATG" 
+#line  1568 "VBNET.ATG" 
 		handlesClause = new List<string>();
 		string name;
 		
 		Expect(121);
 		EventMemberSpecifier(
-#line  1576 "VBNET.ATG" 
+#line  1571 "VBNET.ATG" 
 out name);
 
-#line  1576 "VBNET.ATG" 
+#line  1571 "VBNET.ATG" 
 		if (name != null) handlesClause.Add(name); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			EventMemberSpecifier(
-#line  1577 "VBNET.ATG" 
+#line  1572 "VBNET.ATG" 
 out name);
 
-#line  1577 "VBNET.ATG" 
+#line  1572 "VBNET.ATG" 
 			if (name != null) handlesClause.Add(name); 
 		}
 	}
 
 	void Block(
-#line  2726 "VBNET.ATG" 
+#line  2721 "VBNET.ATG" 
 out Statement stmt) {
 
-#line  2729 "VBNET.ATG" 
+#line  2724 "VBNET.ATG" 
 		BlockStatement blockStmt = new BlockStatement();
 		/* in snippet parsing mode, t might be null */
 		if (t != null) blockStmt.StartLocation = t.EndLocation;
 		compilationUnit.BlockStart(blockStmt);
 		
 		while (StartOf(22) || 
-#line  2735 "VBNET.ATG" 
+#line  2730 "VBNET.ATG" 
 IsEndStmtAhead()) {
 			if (
-#line  2735 "VBNET.ATG" 
+#line  2730 "VBNET.ATG" 
 IsEndStmtAhead()) {
 				Expect(100);
 				EndOfStmt();
 
-#line  2735 "VBNET.ATG" 
+#line  2730 "VBNET.ATG" 
 				compilationUnit.AddChild(new EndStatement()); 
 			} else {
 				Statement();
@@ -2592,7 +2586,7 @@ IsEndStmtAhead()) {
 			}
 		}
 
-#line  2740 "VBNET.ATG" 
+#line  2735 "VBNET.ATG" 
 		stmt = blockStmt;
 		if (t != null) blockStmt.EndLocation = t.EndLocation;
 		compilationUnit.BlockEnd();
@@ -2600,26 +2594,26 @@ IsEndStmtAhead()) {
 	}
 
 	void Charset(
-#line  1563 "VBNET.ATG" 
+#line  1558 "VBNET.ATG" 
 out CharsetModifier charsetModifier) {
 
-#line  1564 "VBNET.ATG" 
+#line  1559 "VBNET.ATG" 
 		charsetModifier = CharsetModifier.None; 
 		if (la.kind == 114 || la.kind == 195) {
 		} else if (la.kind == 49) {
 			lexer.NextToken();
 
-#line  1565 "VBNET.ATG" 
+#line  1560 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Ansi; 
 		} else if (la.kind == 53) {
 			lexer.NextToken();
 
-#line  1566 "VBNET.ATG" 
+#line  1561 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Auto; 
 		} else if (la.kind == 208) {
 			lexer.NextToken();
 
-#line  1567 "VBNET.ATG" 
+#line  1562 "VBNET.ATG" 
 			charsetModifier = CharsetModifier.Unicode; 
 		} else SynErr(249);
 	}
@@ -2739,10 +2733,10 @@ out CharsetModifier charsetModifier) {
 	}
 
 	void VariableDeclaratorPartAfterIdentifier(
-#line  1439 "VBNET.ATG" 
+#line  1434 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration, string name) {
 
-#line  1441 "VBNET.ATG" 
+#line  1436 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		ArrayList rank = null;
@@ -2750,28 +2744,28 @@ List<VariableDeclaration> fieldDeclaration, string name) {
 		Location startLocation = t.Location;
 		
 		if (
-#line  1447 "VBNET.ATG" 
+#line  1442 "VBNET.ATG" 
 IsSize() && !IsDims()) {
 			ArrayInitializationModifier(
-#line  1447 "VBNET.ATG" 
+#line  1442 "VBNET.ATG" 
 out dimension);
 		}
 		if (
-#line  1448 "VBNET.ATG" 
+#line  1443 "VBNET.ATG" 
 IsDims()) {
 			ArrayNameModifier(
-#line  1448 "VBNET.ATG" 
+#line  1443 "VBNET.ATG" 
 out rank);
 		}
 		if (
-#line  1450 "VBNET.ATG" 
+#line  1445 "VBNET.ATG" 
 IsObjectCreation()) {
 			Expect(50);
 			ObjectCreateExpression(
-#line  1450 "VBNET.ATG" 
+#line  1445 "VBNET.ATG" 
 out expr);
 
-#line  1452 "VBNET.ATG" 
+#line  1447 "VBNET.ATG" 
 			if (expr is ObjectCreateExpression) {
 			type = ((ObjectCreateExpression)expr).CreateType.Clone();
 			} else {
@@ -2782,10 +2776,10 @@ out expr);
 			if (la.kind == 50) {
 				lexer.NextToken();
 				TypeName(
-#line  1459 "VBNET.ATG" 
+#line  1454 "VBNET.ATG" 
 out type);
 
-#line  1461 "VBNET.ATG" 
+#line  1456 "VBNET.ATG" 
 				if (type != null) {
 				for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
 					VariableDeclaration vd = fieldDeclaration[i];
@@ -2798,7 +2792,7 @@ out type);
 				 
 			}
 
-#line  1473 "VBNET.ATG" 
+#line  1468 "VBNET.ATG" 
 			if (type == null && (dimension != null || rank != null)) {
 			type = new TypeReference("");
 			}
@@ -2825,12 +2819,12 @@ out type);
 			if (la.kind == 10) {
 				lexer.NextToken();
 				VariableInitializer(
-#line  1496 "VBNET.ATG" 
+#line  1491 "VBNET.ATG" 
 out expr);
 			}
 		} else SynErr(251);
 
-#line  1499 "VBNET.ATG" 
+#line  1494 "VBNET.ATG" 
 		VariableDeclaration varDecl = new VariableDeclaration(name, expr, type);
 		varDecl.StartLocation = startLocation;
 		varDecl.EndLocation = t.Location;
@@ -2839,22 +2833,22 @@ out expr);
 	}
 
 	void VariableDeclarator(
-#line  1433 "VBNET.ATG" 
+#line  1428 "VBNET.ATG" 
 List<VariableDeclaration> fieldDeclaration) {
 		Identifier();
 
-#line  1435 "VBNET.ATG" 
+#line  1430 "VBNET.ATG" 
 		string name = t.val; 
 		VariableDeclaratorPartAfterIdentifier(
-#line  1436 "VBNET.ATG" 
+#line  1431 "VBNET.ATG" 
 fieldDeclaration, name);
 	}
 
 	void ConstantDeclarator(
-#line  1414 "VBNET.ATG" 
+#line  1409 "VBNET.ATG" 
 List<VariableDeclaration> constantDeclaration) {
 
-#line  1416 "VBNET.ATG" 
+#line  1411 "VBNET.ATG" 
 		Expression expr = null;
 		TypeReference type = null;
 		string name = String.Empty;
@@ -2862,20 +2856,20 @@ List<VariableDeclaration> constantDeclaration) {
 		
 		Identifier();
 
-#line  1421 "VBNET.ATG" 
+#line  1416 "VBNET.ATG" 
 		name = t.val; location = t.Location; 
 		if (la.kind == 50) {
 			lexer.NextToken();
 			TypeName(
-#line  1422 "VBNET.ATG" 
+#line  1417 "VBNET.ATG" 
 out type);
 		}
 		Expect(10);
 		Expr(
-#line  1423 "VBNET.ATG" 
+#line  1418 "VBNET.ATG" 
 out expr);
 
-#line  1425 "VBNET.ATG" 
+#line  1420 "VBNET.ATG" 
 		VariableDeclaration f = new VariableDeclaration(name, expr);
 		f.TypeReference = type;
 		f.StartLocation = location;
@@ -2884,10 +2878,10 @@ out expr);
 	}
 
 	void ObjectCreateExpression(
-#line  1968 "VBNET.ATG" 
+#line  1963 "VBNET.ATG" 
 out Expression oce) {
 
-#line  1970 "VBNET.ATG" 
+#line  1965 "VBNET.ATG" 
 		TypeReference type = null;
 		Expression initializer = null;
 		List<Expression> arguments = null;
@@ -2898,39 +2892,39 @@ out Expression oce) {
 		Expect(148);
 		if (StartOf(7)) {
 			NonArrayTypeName(
-#line  1978 "VBNET.ATG" 
+#line  1973 "VBNET.ATG" 
 out type, false);
 			if (la.kind == 25) {
 				lexer.NextToken();
 				NormalOrReDimArgumentList(
-#line  1979 "VBNET.ATG" 
+#line  1974 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeReDim);
 				Expect(26);
 				if (la.kind == 23 || 
-#line  1980 "VBNET.ATG" 
+#line  1975 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 					if (
-#line  1980 "VBNET.ATG" 
+#line  1975 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 						ArrayTypeModifiers(
-#line  1981 "VBNET.ATG" 
+#line  1976 "VBNET.ATG" 
 out dimensions);
 						CollectionInitializer(
-#line  1982 "VBNET.ATG" 
+#line  1977 "VBNET.ATG" 
 out initializer);
 					} else {
 						CollectionInitializer(
-#line  1983 "VBNET.ATG" 
+#line  1978 "VBNET.ATG" 
 out initializer);
 					}
 				}
 
-#line  1985 "VBNET.ATG" 
+#line  1980 "VBNET.ATG" 
 				if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); 
 			}
 		}
 
-#line  1989 "VBNET.ATG" 
+#line  1984 "VBNET.ATG" 
 		if (initializer == null) {
 		oce = new ObjectCreateExpression(type, arguments);
 		} else {
@@ -2944,34 +2938,34 @@ out initializer);
 		
 		if (la.kind == 218) {
 
-#line  2003 "VBNET.ATG" 
+#line  1998 "VBNET.ATG" 
 			NamedArgumentExpression memberInitializer = null;
 			
 			lexer.NextToken();
 
-#line  2007 "VBNET.ATG" 
+#line  2002 "VBNET.ATG" 
 			CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
 			memberInitializers.StartLocation = la.Location;
 			
 			Expect(23);
 			MemberInitializer(
-#line  2011 "VBNET.ATG" 
+#line  2006 "VBNET.ATG" 
 out memberInitializer);
 
-#line  2012 "VBNET.ATG" 
+#line  2007 "VBNET.ATG" 
 			memberInitializers.CreateExpressions.Add(memberInitializer); 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				MemberInitializer(
-#line  2014 "VBNET.ATG" 
+#line  2009 "VBNET.ATG" 
 out memberInitializer);
 
-#line  2015 "VBNET.ATG" 
+#line  2010 "VBNET.ATG" 
 				memberInitializers.CreateExpressions.Add(memberInitializer); 
 			}
 			Expect(24);
 
-#line  2019 "VBNET.ATG" 
+#line  2014 "VBNET.ATG" 
 			memberInitializers.EndLocation = t.Location;
 			if(oce is ObjectCreateExpression)
 			{
@@ -2982,28 +2976,28 @@ out memberInitializer);
 	}
 
 	void VariableInitializer(
-#line  1535 "VBNET.ATG" 
+#line  1530 "VBNET.ATG" 
 out Expression initializerExpression) {
 
-#line  1537 "VBNET.ATG" 
+#line  1532 "VBNET.ATG" 
 		initializerExpression = null;
 		
 		if (StartOf(24)) {
 			Expr(
-#line  1539 "VBNET.ATG" 
+#line  1534 "VBNET.ATG" 
 out initializerExpression);
 		} else if (la.kind == 23) {
 			CollectionInitializer(
-#line  1540 "VBNET.ATG" 
+#line  1535 "VBNET.ATG" 
 out initializerExpression);
 		} else SynErr(252);
 	}
 
 	void AccessorDecls(
-#line  1348 "VBNET.ATG" 
+#line  1343 "VBNET.ATG" 
 out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 
-#line  1350 "VBNET.ATG" 
+#line  1345 "VBNET.ATG" 
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		AttributeSection section;
 		getBlock = null;
@@ -3011,60 +3005,60 @@ out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 		
 		while (la.kind == 28) {
 			AttributeSection(
-#line  1355 "VBNET.ATG" 
+#line  1350 "VBNET.ATG" 
 out section);
 
-#line  1355 "VBNET.ATG" 
+#line  1350 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		if (StartOf(25)) {
 			GetAccessorDecl(
-#line  1357 "VBNET.ATG" 
+#line  1352 "VBNET.ATG" 
 out getBlock, attributes);
 			if (StartOf(26)) {
 
-#line  1359 "VBNET.ATG" 
+#line  1354 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 28) {
 					AttributeSection(
-#line  1360 "VBNET.ATG" 
+#line  1355 "VBNET.ATG" 
 out section);
 
-#line  1360 "VBNET.ATG" 
+#line  1355 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				SetAccessorDecl(
-#line  1361 "VBNET.ATG" 
+#line  1356 "VBNET.ATG" 
 out setBlock, attributes);
 			}
 		} else if (StartOf(27)) {
 			SetAccessorDecl(
-#line  1364 "VBNET.ATG" 
+#line  1359 "VBNET.ATG" 
 out setBlock, attributes);
 			if (StartOf(28)) {
 
-#line  1366 "VBNET.ATG" 
+#line  1361 "VBNET.ATG" 
 				attributes = new List<AttributeSection>(); 
 				while (la.kind == 28) {
 					AttributeSection(
-#line  1367 "VBNET.ATG" 
+#line  1362 "VBNET.ATG" 
 out section);
 
-#line  1367 "VBNET.ATG" 
+#line  1362 "VBNET.ATG" 
 					attributes.Add(section); 
 				}
 				GetAccessorDecl(
-#line  1368 "VBNET.ATG" 
+#line  1363 "VBNET.ATG" 
 out getBlock, attributes);
 			}
 		} else SynErr(253);
 	}
 
 	void EventAccessorDeclaration(
-#line  1311 "VBNET.ATG" 
+#line  1306 "VBNET.ATG" 
 out EventAddRemoveRegion eventAccessorDeclaration) {
 
-#line  1313 "VBNET.ATG" 
+#line  1308 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		AttributeSection section;
@@ -3073,10 +3067,10 @@ out EventAddRemoveRegion eventAccessorDeclaration) {
 		
 		while (la.kind == 28) {
 			AttributeSection(
-#line  1319 "VBNET.ATG" 
+#line  1314 "VBNET.ATG" 
 out section);
 
-#line  1319 "VBNET.ATG" 
+#line  1314 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		if (la.kind == 43) {
@@ -3085,20 +3079,20 @@ out section);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1321 "VBNET.ATG" 
+#line  1316 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
 			}
 			Expect(1);
 			Block(
-#line  1322 "VBNET.ATG" 
+#line  1317 "VBNET.ATG" 
 out stmt);
 			Expect(100);
 			Expect(43);
 			EndOfStmt();
 
-#line  1324 "VBNET.ATG" 
+#line  1319 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventAddRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -3109,20 +3103,20 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1329 "VBNET.ATG" 
+#line  1324 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
 			}
 			Expect(1);
 			Block(
-#line  1330 "VBNET.ATG" 
+#line  1325 "VBNET.ATG" 
 out stmt);
 			Expect(100);
 			Expect(178);
 			EndOfStmt();
 
-#line  1332 "VBNET.ATG" 
+#line  1327 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRemoveRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -3133,20 +3127,20 @@ out stmt);
 				lexer.NextToken();
 				if (StartOf(4)) {
 					FormalParameterList(
-#line  1337 "VBNET.ATG" 
+#line  1332 "VBNET.ATG" 
 p);
 				}
 				Expect(26);
 			}
 			Expect(1);
 			Block(
-#line  1338 "VBNET.ATG" 
+#line  1333 "VBNET.ATG" 
 out stmt);
 			Expect(100);
 			Expect(174);
 			EndOfStmt();
 
-#line  1340 "VBNET.ATG" 
+#line  1335 "VBNET.ATG" 
 			eventAccessorDeclaration = new EventRaiseRegion(attributes);
 			eventAccessorDeclaration.Block = (BlockStatement)stmt;
 			eventAccessorDeclaration.Parameters = p;
@@ -3155,163 +3149,163 @@ out stmt);
 	}
 
 	void OverloadableOperator(
-#line  1253 "VBNET.ATG" 
+#line  1248 "VBNET.ATG" 
 out OverloadableOperatorType operatorType) {
 
-#line  1254 "VBNET.ATG" 
+#line  1249 "VBNET.ATG" 
 		operatorType = OverloadableOperatorType.None; 
 		switch (la.kind) {
 		case 19: {
 			lexer.NextToken();
 
-#line  1256 "VBNET.ATG" 
+#line  1251 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Add; 
 			break;
 		}
 		case 18: {
 			lexer.NextToken();
 
-#line  1258 "VBNET.ATG" 
+#line  1253 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Subtract; 
 			break;
 		}
 		case 22: {
 			lexer.NextToken();
 
-#line  1260 "VBNET.ATG" 
+#line  1255 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Multiply; 
 			break;
 		}
 		case 14: {
 			lexer.NextToken();
 
-#line  1262 "VBNET.ATG" 
+#line  1257 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Divide; 
 			break;
 		}
 		case 15: {
 			lexer.NextToken();
 
-#line  1264 "VBNET.ATG" 
+#line  1259 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.DivideInteger; 
 			break;
 		}
 		case 13: {
 			lexer.NextToken();
 
-#line  1266 "VBNET.ATG" 
+#line  1261 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Concat; 
 			break;
 		}
 		case 136: {
 			lexer.NextToken();
 
-#line  1268 "VBNET.ATG" 
+#line  1263 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Like; 
 			break;
 		}
 		case 140: {
 			lexer.NextToken();
 
-#line  1270 "VBNET.ATG" 
+#line  1265 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Modulus; 
 			break;
 		}
 		case 47: {
 			lexer.NextToken();
 
-#line  1272 "VBNET.ATG" 
+#line  1267 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseAnd; 
 			break;
 		}
 		case 161: {
 			lexer.NextToken();
 
-#line  1274 "VBNET.ATG" 
+#line  1269 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.BitwiseOr; 
 			break;
 		}
 		case 221: {
 			lexer.NextToken();
 
-#line  1276 "VBNET.ATG" 
+#line  1271 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ExclusiveOr; 
 			break;
 		}
 		case 20: {
 			lexer.NextToken();
 
-#line  1278 "VBNET.ATG" 
+#line  1273 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Power; 
 			break;
 		}
 		case 32: {
 			lexer.NextToken();
 
-#line  1280 "VBNET.ATG" 
+#line  1275 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftLeft; 
 			break;
 		}
 		case 33: {
 			lexer.NextToken();
 
-#line  1282 "VBNET.ATG" 
+#line  1277 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.ShiftRight; 
 			break;
 		}
 		case 10: {
 			lexer.NextToken();
 
-#line  1284 "VBNET.ATG" 
+#line  1279 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.Equality; 
 			break;
 		}
 		case 29: {
 			lexer.NextToken();
 
-#line  1286 "VBNET.ATG" 
+#line  1281 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.InEquality; 
 			break;
 		}
 		case 28: {
 			lexer.NextToken();
 
-#line  1288 "VBNET.ATG" 
+#line  1283 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThan; 
 			break;
 		}
 		case 31: {
 			lexer.NextToken();
 
-#line  1290 "VBNET.ATG" 
+#line  1285 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.LessThanOrEqual; 
 			break;
 		}
 		case 27: {
 			lexer.NextToken();
 
-#line  1292 "VBNET.ATG" 
+#line  1287 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThan; 
 			break;
 		}
 		case 30: {
 			lexer.NextToken();
 
-#line  1294 "VBNET.ATG" 
+#line  1289 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.GreaterThanOrEqual; 
 			break;
 		}
 		case 81: {
 			lexer.NextToken();
 
-#line  1296 "VBNET.ATG" 
+#line  1291 "VBNET.ATG" 
 			operatorType = OverloadableOperatorType.CType; 
 			break;
 		}
 		case 2: case 45: case 49: case 51: case 52: case 53: case 54: case 57: case 74: case 85: case 91: case 94: case 103: case 108: case 113: case 120: case 126: case 130: case 133: case 156: case 162: case 169: case 188: case 197: case 198: case 208: case 209: case 215: {
 			Identifier();
 
-#line  1300 "VBNET.ATG" 
+#line  1295 "VBNET.ATG" 
 			string opName = t.val; 
 			if (string.Equals(opName, "istrue", StringComparison.InvariantCultureIgnoreCase)) {
 				operatorType = OverloadableOperatorType.IsTrue;
@@ -3328,67 +3322,67 @@ out OverloadableOperatorType operatorType) {
 	}
 
 	void GetAccessorDecl(
-#line  1374 "VBNET.ATG" 
+#line  1369 "VBNET.ATG" 
 out PropertyGetRegion getBlock, List<AttributeSection> attributes) {
 
-#line  1375 "VBNET.ATG" 
+#line  1370 "VBNET.ATG" 
 		Statement stmt = null; Modifiers m; 
 		PropertyAccessorAccessModifier(
-#line  1377 "VBNET.ATG" 
+#line  1372 "VBNET.ATG" 
 out m);
 		Expect(115);
 
-#line  1379 "VBNET.ATG" 
+#line  1374 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		Expect(1);
 		Block(
-#line  1381 "VBNET.ATG" 
+#line  1376 "VBNET.ATG" 
 out stmt);
 
-#line  1382 "VBNET.ATG" 
+#line  1377 "VBNET.ATG" 
 		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); 
 		Expect(100);
 		Expect(115);
 
-#line  1384 "VBNET.ATG" 
+#line  1379 "VBNET.ATG" 
 		getBlock.Modifier = m; 
 
-#line  1385 "VBNET.ATG" 
+#line  1380 "VBNET.ATG" 
 		getBlock.StartLocation = startLocation; getBlock.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void SetAccessorDecl(
-#line  1390 "VBNET.ATG" 
+#line  1385 "VBNET.ATG" 
 out PropertySetRegion setBlock, List<AttributeSection> attributes) {
 
-#line  1392 "VBNET.ATG" 
+#line  1387 "VBNET.ATG" 
 		Statement stmt = null;
 		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
 		Modifiers m;
 		
 		PropertyAccessorAccessModifier(
-#line  1397 "VBNET.ATG" 
+#line  1392 "VBNET.ATG" 
 out m);
 		Expect(183);
 
-#line  1399 "VBNET.ATG" 
+#line  1394 "VBNET.ATG" 
 		Location startLocation = t.Location; 
 		if (la.kind == 25) {
 			lexer.NextToken();
 			if (StartOf(4)) {
 				FormalParameterList(
-#line  1400 "VBNET.ATG" 
+#line  1395 "VBNET.ATG" 
 p);
 			}
 			Expect(26);
 		}
 		Expect(1);
 		Block(
-#line  1402 "VBNET.ATG" 
+#line  1397 "VBNET.ATG" 
 out stmt);
 
-#line  1404 "VBNET.ATG" 
+#line  1399 "VBNET.ATG" 
 		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
 		setBlock.Modifier = m;
 		setBlock.Parameters = p;
@@ -3396,151 +3390,151 @@ out stmt);
 		Expect(100);
 		Expect(183);
 
-#line  1409 "VBNET.ATG" 
+#line  1404 "VBNET.ATG" 
 		setBlock.StartLocation = startLocation; setBlock.EndLocation = t.EndLocation; 
 		EndOfStmt();
 	}
 
 	void PropertyAccessorAccessModifier(
-#line  3442 "VBNET.ATG" 
+#line  3437 "VBNET.ATG" 
 out Modifiers m) {
 
-#line  3443 "VBNET.ATG" 
+#line  3438 "VBNET.ATG" 
 		m = Modifiers.None; 
 		while (StartOf(29)) {
 			if (la.kind == 173) {
 				lexer.NextToken();
 
-#line  3445 "VBNET.ATG" 
+#line  3440 "VBNET.ATG" 
 				m |= Modifiers.Public; 
 			} else if (la.kind == 172) {
 				lexer.NextToken();
 
-#line  3446 "VBNET.ATG" 
+#line  3441 "VBNET.ATG" 
 				m |= Modifiers.Protected; 
 			} else if (la.kind == 112) {
 				lexer.NextToken();
 
-#line  3447 "VBNET.ATG" 
+#line  3442 "VBNET.ATG" 
 				m |= Modifiers.Internal; 
 			} else {
 				lexer.NextToken();
 
-#line  3448 "VBNET.ATG" 
+#line  3443 "VBNET.ATG" 
 				m |= Modifiers.Private; 
 			}
 		}
 	}
 
 	void ArrayInitializationModifier(
-#line  1507 "VBNET.ATG" 
+#line  1502 "VBNET.ATG" 
 out List<Expression> arrayModifiers) {
 
-#line  1509 "VBNET.ATG" 
+#line  1504 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		Expect(25);
 		InitializationRankList(
-#line  1511 "VBNET.ATG" 
+#line  1506 "VBNET.ATG" 
 out arrayModifiers);
 		Expect(26);
 	}
 
 	void ArrayNameModifier(
-#line  2519 "VBNET.ATG" 
+#line  2514 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  2521 "VBNET.ATG" 
+#line  2516 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		ArrayTypeModifiers(
-#line  2523 "VBNET.ATG" 
+#line  2518 "VBNET.ATG" 
 out arrayModifiers);
 	}
 
 	void InitializationRankList(
-#line  1515 "VBNET.ATG" 
+#line  1510 "VBNET.ATG" 
 out List<Expression> rank) {
 
-#line  1517 "VBNET.ATG" 
+#line  1512 "VBNET.ATG" 
 		rank = new List<Expression>();
 		Expression expr = null;
 		
 		Expr(
-#line  1520 "VBNET.ATG" 
+#line  1515 "VBNET.ATG" 
 out expr);
 		if (la.kind == 201) {
 			lexer.NextToken();
 
-#line  1521 "VBNET.ATG" 
+#line  1516 "VBNET.ATG" 
 			EnsureIsZero(expr); 
 			Expr(
-#line  1522 "VBNET.ATG" 
+#line  1517 "VBNET.ATG" 
 out expr);
 		}
 
-#line  1524 "VBNET.ATG" 
+#line  1519 "VBNET.ATG" 
 		if (expr != null) { rank.Add(expr); } 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			Expr(
-#line  1526 "VBNET.ATG" 
+#line  1521 "VBNET.ATG" 
 out expr);
 			if (la.kind == 201) {
 				lexer.NextToken();
 
-#line  1527 "VBNET.ATG" 
+#line  1522 "VBNET.ATG" 
 				EnsureIsZero(expr); 
 				Expr(
-#line  1528 "VBNET.ATG" 
+#line  1523 "VBNET.ATG" 
 out expr);
 			}
 
-#line  1530 "VBNET.ATG" 
+#line  1525 "VBNET.ATG" 
 			if (expr != null) { rank.Add(expr); } 
 		}
 	}
 
 	void CollectionInitializer(
-#line  1544 "VBNET.ATG" 
+#line  1539 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1546 "VBNET.ATG" 
+#line  1541 "VBNET.ATG" 
 		Expression expr = null;
 		CollectionInitializerExpression initializer = new CollectionInitializerExpression();
 		
 		Expect(23);
 		if (StartOf(30)) {
 			VariableInitializer(
-#line  1551 "VBNET.ATG" 
+#line  1546 "VBNET.ATG" 
 out expr);
 
-#line  1553 "VBNET.ATG" 
+#line  1548 "VBNET.ATG" 
 			if (expr != null) { initializer.CreateExpressions.Add(expr); }
 			
 			while (
-#line  1556 "VBNET.ATG" 
+#line  1551 "VBNET.ATG" 
 NotFinalComma()) {
 				Expect(12);
 				VariableInitializer(
-#line  1556 "VBNET.ATG" 
+#line  1551 "VBNET.ATG" 
 out expr);
 
-#line  1557 "VBNET.ATG" 
+#line  1552 "VBNET.ATG" 
 				if (expr != null) { initializer.CreateExpressions.Add(expr); } 
 			}
 		}
 		Expect(24);
 
-#line  1560 "VBNET.ATG" 
+#line  1555 "VBNET.ATG" 
 		outExpr = initializer; 
 	}
 
 	void EventMemberSpecifier(
-#line  1630 "VBNET.ATG" 
+#line  1625 "VBNET.ATG" 
 out string name) {
 
-#line  1631 "VBNET.ATG" 
+#line  1626 "VBNET.ATG" 
 		string eventName; 
 		if (StartOf(14)) {
 			Identifier();
@@ -3550,53 +3544,53 @@ out string name) {
 			lexer.NextToken();
 		} else SynErr(256);
 
-#line  1634 "VBNET.ATG" 
+#line  1629 "VBNET.ATG" 
 		name = t.val; 
 		Expect(16);
 		IdentifierOrKeyword(
-#line  1636 "VBNET.ATG" 
+#line  1631 "VBNET.ATG" 
 out eventName);
 
-#line  1637 "VBNET.ATG" 
+#line  1632 "VBNET.ATG" 
 		name = name + "." + eventName; 
 	}
 
 	void IdentifierOrKeyword(
-#line  3375 "VBNET.ATG" 
+#line  3370 "VBNET.ATG" 
 out string name) {
 
-#line  3377 "VBNET.ATG" 
+#line  3372 "VBNET.ATG" 
 		lexer.NextToken(); name = t.val;  
 	}
 
 	void QueryExpr(
-#line  2046 "VBNET.ATG" 
+#line  2041 "VBNET.ATG" 
 out Expression expr) {
 
-#line  2048 "VBNET.ATG" 
+#line  2043 "VBNET.ATG" 
 		QueryExpressionVB qexpr = new QueryExpressionVB();
 		qexpr.StartLocation = la.Location;
 		expr = qexpr;
 		
 		FromOrAggregateQueryOperator(
-#line  2052 "VBNET.ATG" 
+#line  2047 "VBNET.ATG" 
 qexpr.Clauses);
 		while (StartOf(31)) {
 			QueryOperator(
-#line  2053 "VBNET.ATG" 
+#line  2048 "VBNET.ATG" 
 qexpr.Clauses);
 		}
 
-#line  2055 "VBNET.ATG" 
+#line  2050 "VBNET.ATG" 
 		qexpr.EndLocation = t.EndLocation;
 		
 	}
 
 	void LambdaExpr(
-#line  2028 "VBNET.ATG" 
+#line  2023 "VBNET.ATG" 
 out Expression expr) {
 
-#line  2030 "VBNET.ATG" 
+#line  2025 "VBNET.ATG" 
 		Expression inner = null;
 		LambdaExpression lambda = new LambdaExpression();
 		lambda.StartLocation = la.Location;
@@ -3606,16 +3600,16 @@ out Expression expr) {
 			lexer.NextToken();
 			if (StartOf(4)) {
 				FormalParameterList(
-#line  2036 "VBNET.ATG" 
+#line  2031 "VBNET.ATG" 
 lambda.Parameters);
 			}
 			Expect(26);
 		}
 		Expr(
-#line  2037 "VBNET.ATG" 
+#line  2032 "VBNET.ATG" 
 out inner);
 
-#line  2039 "VBNET.ATG" 
+#line  2034 "VBNET.ATG" 
 		lambda.ExpressionBody = inner;
 		lambda.EndLocation = t.EndLocation; // la.Location?
 		
@@ -3624,116 +3618,116 @@ out inner);
 	}
 
 	void DisjunctionExpr(
-#line  1812 "VBNET.ATG" 
+#line  1807 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1814 "VBNET.ATG" 
+#line  1809 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ConjunctionExpr(
-#line  1817 "VBNET.ATG" 
+#line  1812 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 161 || la.kind == 163 || la.kind == 221) {
 			if (la.kind == 161) {
 				lexer.NextToken();
 
-#line  1820 "VBNET.ATG" 
+#line  1815 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseOr; 
 			} else if (la.kind == 163) {
 				lexer.NextToken();
 
-#line  1821 "VBNET.ATG" 
+#line  1816 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalOr; 
 			} else {
 				lexer.NextToken();
 
-#line  1822 "VBNET.ATG" 
+#line  1817 "VBNET.ATG" 
 				op = BinaryOperatorType.ExclusiveOr; 
 			}
 			ConjunctionExpr(
-#line  1824 "VBNET.ATG" 
+#line  1819 "VBNET.ATG" 
 out expr);
 
-#line  1824 "VBNET.ATG" 
+#line  1819 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void AssignmentOperator(
-#line  1648 "VBNET.ATG" 
+#line  1643 "VBNET.ATG" 
 out AssignmentOperatorType op) {
 
-#line  1649 "VBNET.ATG" 
+#line  1644 "VBNET.ATG" 
 		op = AssignmentOperatorType.None; 
 		switch (la.kind) {
 		case 10: {
 			lexer.NextToken();
 
-#line  1650 "VBNET.ATG" 
+#line  1645 "VBNET.ATG" 
 			op = AssignmentOperatorType.Assign; 
 			break;
 		}
 		case 42: {
 			lexer.NextToken();
 
-#line  1651 "VBNET.ATG" 
+#line  1646 "VBNET.ATG" 
 			op = AssignmentOperatorType.ConcatString; 
 			break;
 		}
 		case 34: {
 			lexer.NextToken();
 
-#line  1652 "VBNET.ATG" 
+#line  1647 "VBNET.ATG" 
 			op = AssignmentOperatorType.Add; 
 			break;
 		}
 		case 36: {
 			lexer.NextToken();
 
-#line  1653 "VBNET.ATG" 
+#line  1648 "VBNET.ATG" 
 			op = AssignmentOperatorType.Subtract; 
 			break;
 		}
 		case 37: {
 			lexer.NextToken();
 
-#line  1654 "VBNET.ATG" 
+#line  1649 "VBNET.ATG" 
 			op = AssignmentOperatorType.Multiply; 
 			break;
 		}
 		case 38: {
 			lexer.NextToken();
 
-#line  1655 "VBNET.ATG" 
+#line  1650 "VBNET.ATG" 
 			op = AssignmentOperatorType.Divide; 
 			break;
 		}
 		case 39: {
 			lexer.NextToken();
 
-#line  1656 "VBNET.ATG" 
+#line  1651 "VBNET.ATG" 
 			op = AssignmentOperatorType.DivideInteger; 
 			break;
 		}
 		case 35: {
 			lexer.NextToken();
 
-#line  1657 "VBNET.ATG" 
+#line  1652 "VBNET.ATG" 
 			op = AssignmentOperatorType.Power; 
 			break;
 		}
 		case 40: {
 			lexer.NextToken();
 
-#line  1658 "VBNET.ATG" 
+#line  1653 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftLeft; 
 			break;
 		}
 		case 41: {
 			lexer.NextToken();
 
-#line  1659 "VBNET.ATG" 
+#line  1654 "VBNET.ATG" 
 			op = AssignmentOperatorType.ShiftRight; 
 			break;
 		}
@@ -3742,54 +3736,54 @@ out AssignmentOperatorType op) {
 	}
 
 	void SimpleExpr(
-#line  1663 "VBNET.ATG" 
+#line  1658 "VBNET.ATG" 
 out Expression pexpr) {
 
-#line  1664 "VBNET.ATG" 
+#line  1659 "VBNET.ATG" 
 		string name; 
 		SimpleNonInvocationExpression(
-#line  1666 "VBNET.ATG" 
+#line  1661 "VBNET.ATG" 
 out pexpr);
 		while (la.kind == 16 || la.kind == 17 || la.kind == 25) {
 			if (la.kind == 16) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  1668 "VBNET.ATG" 
+#line  1663 "VBNET.ATG" 
 out name);
 
-#line  1669 "VBNET.ATG" 
+#line  1664 "VBNET.ATG" 
 				pexpr = new MemberReferenceExpression(pexpr, name); 
 				if (
-#line  1670 "VBNET.ATG" 
+#line  1665 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 					lexer.NextToken();
 					Expect(155);
 					TypeArgumentList(
-#line  1671 "VBNET.ATG" 
+#line  1666 "VBNET.ATG" 
 ((MemberReferenceExpression)pexpr).TypeArguments);
 					Expect(26);
 				}
 			} else if (la.kind == 17) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  1673 "VBNET.ATG" 
+#line  1668 "VBNET.ATG" 
 out name);
 
-#line  1673 "VBNET.ATG" 
+#line  1668 "VBNET.ATG" 
 				pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name)); 
 			} else {
 				InvocationExpression(
-#line  1674 "VBNET.ATG" 
+#line  1669 "VBNET.ATG" 
 ref pexpr);
 			}
 		}
 	}
 
 	void SimpleNonInvocationExpression(
-#line  1678 "VBNET.ATG" 
+#line  1673 "VBNET.ATG" 
 out Expression pexpr) {
 
-#line  1680 "VBNET.ATG" 
+#line  1675 "VBNET.ATG" 
 		Expression expr;
 		TypeReference type = null;
 		string name = String.Empty;
@@ -3800,98 +3794,98 @@ out Expression pexpr) {
 			case 3: {
 				lexer.NextToken();
 
-#line  1688 "VBNET.ATG" 
+#line  1683 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 4: {
 				lexer.NextToken();
 
-#line  1689 "VBNET.ATG" 
+#line  1684 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 7: {
 				lexer.NextToken();
 
-#line  1690 "VBNET.ATG" 
+#line  1685 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 6: {
 				lexer.NextToken();
 
-#line  1691 "VBNET.ATG" 
+#line  1686 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 5: {
 				lexer.NextToken();
 
-#line  1692 "VBNET.ATG" 
+#line  1687 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 9: {
 				lexer.NextToken();
 
-#line  1693 "VBNET.ATG" 
+#line  1688 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 8: {
 				lexer.NextToken();
 
-#line  1694 "VBNET.ATG" 
+#line  1689 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  
 				break;
 			}
 			case 202: {
 				lexer.NextToken();
 
-#line  1696 "VBNET.ATG" 
+#line  1691 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(true, "true");  
 				break;
 			}
 			case 109: {
 				lexer.NextToken();
 
-#line  1697 "VBNET.ATG" 
+#line  1692 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(false, "false"); 
 				break;
 			}
 			case 151: {
 				lexer.NextToken();
 
-#line  1698 "VBNET.ATG" 
+#line  1693 "VBNET.ATG" 
 				pexpr = new PrimitiveExpression(null, "null");  
 				break;
 			}
 			case 25: {
 				lexer.NextToken();
 				Expr(
-#line  1699 "VBNET.ATG" 
+#line  1694 "VBNET.ATG" 
 out expr);
 				Expect(26);
 
-#line  1699 "VBNET.ATG" 
+#line  1694 "VBNET.ATG" 
 				pexpr = new ParenthesizedExpression(expr); 
 				break;
 			}
 			case 2: case 45: case 49: case 51: case 52: case 53: case 54: case 57: case 74: case 85: case 91: case 94: case 103: case 108: case 113: case 120: case 126: case 130: case 133: case 156: case 162: case 169: case 188: case 197: case 198: case 208: case 209: case 215: {
 				Identifier();
 
-#line  1701 "VBNET.ATG" 
+#line  1696 "VBNET.ATG" 
 				pexpr = new IdentifierExpression(t.val);
 				pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
 				
 				if (
-#line  1704 "VBNET.ATG" 
+#line  1699 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 					lexer.NextToken();
 					Expect(155);
 					TypeArgumentList(
-#line  1705 "VBNET.ATG" 
+#line  1700 "VBNET.ATG" 
 ((IdentifierExpression)pexpr).TypeArguments);
 					Expect(26);
 				}
@@ -3899,51 +3893,51 @@ la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			}
 			case 55: case 58: case 69: case 86: case 87: case 96: case 128: case 137: case 154: case 181: case 186: case 187: case 193: case 206: case 207: case 210: {
 
-#line  1707 "VBNET.ATG" 
+#line  1702 "VBNET.ATG" 
 				string val = String.Empty; 
 				if (StartOf(11)) {
 					PrimitiveTypeName(
-#line  1708 "VBNET.ATG" 
+#line  1703 "VBNET.ATG" 
 out val);
 				} else if (la.kind == 154) {
 					lexer.NextToken();
 
-#line  1708 "VBNET.ATG" 
+#line  1703 "VBNET.ATG" 
 					val = "System.Object"; 
 				} else SynErr(258);
 
-#line  1709 "VBNET.ATG" 
+#line  1704 "VBNET.ATG" 
 				pexpr = new TypeReferenceExpression(new TypeReference(val, true)); 
 				break;
 			}
 			case 139: {
 				lexer.NextToken();
 
-#line  1710 "VBNET.ATG" 
+#line  1705 "VBNET.ATG" 
 				pexpr = new ThisReferenceExpression(); 
 				break;
 			}
 			case 144: case 145: {
 
-#line  1711 "VBNET.ATG" 
+#line  1706 "VBNET.ATG" 
 				Expression retExpr = null; 
 				if (la.kind == 144) {
 					lexer.NextToken();
 
-#line  1712 "VBNET.ATG" 
+#line  1707 "VBNET.ATG" 
 					retExpr = new BaseReferenceExpression(); 
 				} else if (la.kind == 145) {
 					lexer.NextToken();
 
-#line  1713 "VBNET.ATG" 
+#line  1708 "VBNET.ATG" 
 					retExpr = new ClassReferenceExpression(); 
 				} else SynErr(259);
 				Expect(16);
 				IdentifierOrKeyword(
-#line  1715 "VBNET.ATG" 
+#line  1710 "VBNET.ATG" 
 out name);
 
-#line  1715 "VBNET.ATG" 
+#line  1710 "VBNET.ATG" 
 				pexpr = new MemberReferenceExpression(retExpr, name); 
 				break;
 			}
@@ -3952,77 +3946,77 @@ out name);
 				Expect(16);
 				Identifier();
 
-#line  1717 "VBNET.ATG" 
+#line  1712 "VBNET.ATG" 
 				type = new TypeReference(t.val ?? ""); 
 
-#line  1719 "VBNET.ATG" 
+#line  1714 "VBNET.ATG" 
 				type.IsGlobal = true; 
 
-#line  1720 "VBNET.ATG" 
+#line  1715 "VBNET.ATG" 
 				pexpr = new TypeReferenceExpression(type); 
 				break;
 			}
 			case 148: {
 				ObjectCreateExpression(
-#line  1721 "VBNET.ATG" 
+#line  1716 "VBNET.ATG" 
 out expr);
 
-#line  1721 "VBNET.ATG" 
+#line  1716 "VBNET.ATG" 
 				pexpr = expr; 
 				break;
 			}
 			case 81: case 93: case 204: {
 
-#line  1723 "VBNET.ATG" 
+#line  1718 "VBNET.ATG" 
 				CastType castType = CastType.Cast; 
 				if (la.kind == 93) {
 					lexer.NextToken();
 				} else if (la.kind == 81) {
 					lexer.NextToken();
 
-#line  1725 "VBNET.ATG" 
+#line  1720 "VBNET.ATG" 
 					castType = CastType.Conversion; 
 				} else if (la.kind == 204) {
 					lexer.NextToken();
 
-#line  1726 "VBNET.ATG" 
+#line  1721 "VBNET.ATG" 
 					castType = CastType.TryCast; 
 				} else SynErr(260);
 				Expect(25);
 				Expr(
-#line  1728 "VBNET.ATG" 
+#line  1723 "VBNET.ATG" 
 out expr);
 				Expect(12);
 				TypeName(
-#line  1728 "VBNET.ATG" 
+#line  1723 "VBNET.ATG" 
 out type);
 				Expect(26);
 
-#line  1729 "VBNET.ATG" 
+#line  1724 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, castType); 
 				break;
 			}
 			case 63: case 64: case 65: case 66: case 67: case 68: case 70: case 72: case 73: case 77: case 78: case 79: case 80: case 82: case 83: case 84: {
 				CastTarget(
-#line  1730 "VBNET.ATG" 
+#line  1725 "VBNET.ATG" 
 out type);
 				Expect(25);
 				Expr(
-#line  1730 "VBNET.ATG" 
+#line  1725 "VBNET.ATG" 
 out expr);
 				Expect(26);
 
-#line  1730 "VBNET.ATG" 
+#line  1725 "VBNET.ATG" 
 				pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); 
 				break;
 			}
 			case 44: {
 				lexer.NextToken();
 				Expr(
-#line  1731 "VBNET.ATG" 
+#line  1726 "VBNET.ATG" 
 out expr);
 
-#line  1731 "VBNET.ATG" 
+#line  1726 "VBNET.ATG" 
 				pexpr = new AddressOfExpression(expr); 
 				break;
 			}
@@ -4030,31 +4024,31 @@ out expr);
 				lexer.NextToken();
 				Expect(25);
 				GetTypeTypeName(
-#line  1732 "VBNET.ATG" 
+#line  1727 "VBNET.ATG" 
 out type);
 				Expect(26);
 
-#line  1732 "VBNET.ATG" 
+#line  1727 "VBNET.ATG" 
 				pexpr = new TypeOfExpression(type); 
 				break;
 			}
 			case 205: {
 				lexer.NextToken();
 				SimpleExpr(
-#line  1733 "VBNET.ATG" 
+#line  1728 "VBNET.ATG" 
 out expr);
 				Expect(131);
 				TypeName(
-#line  1733 "VBNET.ATG" 
+#line  1728 "VBNET.ATG" 
 out type);
 
-#line  1733 "VBNET.ATG" 
+#line  1728 "VBNET.ATG" 
 				pexpr = new TypeOfIsExpression(expr, type); 
 				break;
 			}
 			case 122: {
 				ConditionalExpression(
-#line  1734 "VBNET.ATG" 
+#line  1729 "VBNET.ATG" 
 out pexpr);
 				break;
 			}
@@ -4062,170 +4056,170 @@ out pexpr);
 		} else if (la.kind == 16) {
 			lexer.NextToken();
 			IdentifierOrKeyword(
-#line  1738 "VBNET.ATG" 
+#line  1733 "VBNET.ATG" 
 out name);
 
-#line  1738 "VBNET.ATG" 
+#line  1733 "VBNET.ATG" 
 			pexpr = new MemberReferenceExpression(null, name);
 		} else SynErr(261);
 	}
 
 	void TypeArgumentList(
-#line  2555 "VBNET.ATG" 
+#line  2550 "VBNET.ATG" 
 List<TypeReference> typeArguments) {
 
-#line  2557 "VBNET.ATG" 
+#line  2552 "VBNET.ATG" 
 		TypeReference typeref;
 		
 		TypeName(
-#line  2559 "VBNET.ATG" 
+#line  2554 "VBNET.ATG" 
 out typeref);
 
-#line  2559 "VBNET.ATG" 
+#line  2554 "VBNET.ATG" 
 		if (typeref != null) typeArguments.Add(typeref); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			TypeName(
-#line  2562 "VBNET.ATG" 
+#line  2557 "VBNET.ATG" 
 out typeref);
 
-#line  2562 "VBNET.ATG" 
+#line  2557 "VBNET.ATG" 
 			if (typeref != null) typeArguments.Add(typeref); 
 		}
 	}
 
 	void InvocationExpression(
-#line  1776 "VBNET.ATG" 
+#line  1771 "VBNET.ATG" 
 ref Expression pexpr) {
 
-#line  1777 "VBNET.ATG" 
+#line  1772 "VBNET.ATG" 
 		List<Expression> parameters = null; 
 		Expect(25);
 
-#line  1779 "VBNET.ATG" 
+#line  1774 "VBNET.ATG" 
 		Location start = t.Location; 
 		ArgumentList(
-#line  1780 "VBNET.ATG" 
+#line  1775 "VBNET.ATG" 
 out parameters);
 		Expect(26);
 
-#line  1783 "VBNET.ATG" 
+#line  1778 "VBNET.ATG" 
 		pexpr = new InvocationExpression(pexpr, parameters);
 		
 
-#line  1785 "VBNET.ATG" 
+#line  1780 "VBNET.ATG" 
 		pexpr.StartLocation = start; pexpr.EndLocation = t.Location; 
 	}
 
 	void PrimitiveTypeName(
-#line  3382 "VBNET.ATG" 
+#line  3377 "VBNET.ATG" 
 out string type) {
 
-#line  3383 "VBNET.ATG" 
+#line  3378 "VBNET.ATG" 
 		type = String.Empty; 
 		switch (la.kind) {
 		case 55: {
 			lexer.NextToken();
 
-#line  3384 "VBNET.ATG" 
+#line  3379 "VBNET.ATG" 
 			type = "System.Boolean"; 
 			break;
 		}
 		case 86: {
 			lexer.NextToken();
 
-#line  3385 "VBNET.ATG" 
+#line  3380 "VBNET.ATG" 
 			type = "System.DateTime"; 
 			break;
 		}
 		case 69: {
 			lexer.NextToken();
 
-#line  3386 "VBNET.ATG" 
+#line  3381 "VBNET.ATG" 
 			type = "System.Char"; 
 			break;
 		}
 		case 193: {
 			lexer.NextToken();
 
-#line  3387 "VBNET.ATG" 
+#line  3382 "VBNET.ATG" 
 			type = "System.String"; 
 			break;
 		}
 		case 87: {
 			lexer.NextToken();
 
-#line  3388 "VBNET.ATG" 
+#line  3383 "VBNET.ATG" 
 			type = "System.Decimal"; 
 			break;
 		}
 		case 58: {
 			lexer.NextToken();
 
-#line  3389 "VBNET.ATG" 
+#line  3384 "VBNET.ATG" 
 			type = "System.Byte"; 
 			break;
 		}
 		case 186: {
 			lexer.NextToken();
 
-#line  3390 "VBNET.ATG" 
+#line  3385 "VBNET.ATG" 
 			type = "System.Int16"; 
 			break;
 		}
 		case 128: {
 			lexer.NextToken();
 
-#line  3391 "VBNET.ATG" 
+#line  3386 "VBNET.ATG" 
 			type = "System.Int32"; 
 			break;
 		}
 		case 137: {
 			lexer.NextToken();
 
-#line  3392 "VBNET.ATG" 
+#line  3387 "VBNET.ATG" 
 			type = "System.Int64"; 
 			break;
 		}
 		case 187: {
 			lexer.NextToken();
 
-#line  3393 "VBNET.ATG" 
+#line  3388 "VBNET.ATG" 
 			type = "System.Single"; 
 			break;
 		}
 		case 96: {
 			lexer.NextToken();
 
-#line  3394 "VBNET.ATG" 
+#line  3389 "VBNET.ATG" 
 			type = "System.Double"; 
 			break;
 		}
 		case 206: {
 			lexer.NextToken();
 
-#line  3395 "VBNET.ATG" 
+#line  3390 "VBNET.ATG" 
 			type = "System.UInt32"; 
 			break;
 		}
 		case 207: {
 			lexer.NextToken();
 
-#line  3396 "VBNET.ATG" 
+#line  3391 "VBNET.ATG" 
 			type = "System.UInt64"; 
 			break;
 		}
 		case 210: {
 			lexer.NextToken();
 
-#line  3397 "VBNET.ATG" 
+#line  3392 "VBNET.ATG" 
 			type = "System.UInt16"; 
 			break;
 		}
 		case 181: {
 			lexer.NextToken();
 
-#line  3398 "VBNET.ATG" 
+#line  3393 "VBNET.ATG" 
 			type = "System.SByte"; 
 			break;
 		}
@@ -4234,122 +4228,122 @@ out string type) {
 	}
 
 	void CastTarget(
-#line  1790 "VBNET.ATG" 
+#line  1785 "VBNET.ATG" 
 out TypeReference type) {
 
-#line  1792 "VBNET.ATG" 
+#line  1787 "VBNET.ATG" 
 		type = null;
 		
 		switch (la.kind) {
 		case 63: {
 			lexer.NextToken();
 
-#line  1794 "VBNET.ATG" 
+#line  1789 "VBNET.ATG" 
 			type = new TypeReference("System.Boolean", true); 
 			break;
 		}
 		case 64: {
 			lexer.NextToken();
 
-#line  1795 "VBNET.ATG" 
+#line  1790 "VBNET.ATG" 
 			type = new TypeReference("System.Byte", true); 
 			break;
 		}
 		case 77: {
 			lexer.NextToken();
 
-#line  1796 "VBNET.ATG" 
+#line  1791 "VBNET.ATG" 
 			type = new TypeReference("System.SByte", true); 
 			break;
 		}
 		case 65: {
 			lexer.NextToken();
 
-#line  1797 "VBNET.ATG" 
+#line  1792 "VBNET.ATG" 
 			type = new TypeReference("System.Char", true); 
 			break;
 		}
 		case 66: {
 			lexer.NextToken();
 
-#line  1798 "VBNET.ATG" 
+#line  1793 "VBNET.ATG" 
 			type = new TypeReference("System.DateTime", true); 
 			break;
 		}
 		case 68: {
 			lexer.NextToken();
 
-#line  1799 "VBNET.ATG" 
+#line  1794 "VBNET.ATG" 
 			type = new TypeReference("System.Decimal", true); 
 			break;
 		}
 		case 67: {
 			lexer.NextToken();
 
-#line  1800 "VBNET.ATG" 
+#line  1795 "VBNET.ATG" 
 			type = new TypeReference("System.Double", true); 
 			break;
 		}
 		case 78: {
 			lexer.NextToken();
 
-#line  1801 "VBNET.ATG" 
+#line  1796 "VBNET.ATG" 
 			type = new TypeReference("System.Int16", true); 
 			break;
 		}
 		case 70: {
 			lexer.NextToken();
 
-#line  1802 "VBNET.ATG" 
+#line  1797 "VBNET.ATG" 
 			type = new TypeReference("System.Int32", true); 
 			break;
 		}
 		case 72: {
 			lexer.NextToken();
 
-#line  1803 "VBNET.ATG" 
+#line  1798 "VBNET.ATG" 
 			type = new TypeReference("System.Int64", true); 
 			break;
 		}
 		case 84: {
 			lexer.NextToken();
 
-#line  1804 "VBNET.ATG" 
+#line  1799 "VBNET.ATG" 
 			type = new TypeReference("System.UInt16", true); 
 			break;
 		}
 		case 82: {
 			lexer.NextToken();
 
-#line  1805 "VBNET.ATG" 
+#line  1800 "VBNET.ATG" 
 			type = new TypeReference("System.UInt32", true); 
 			break;
 		}
 		case 83: {
 			lexer.NextToken();
 
-#line  1806 "VBNET.ATG" 
+#line  1801 "VBNET.ATG" 
 			type = new TypeReference("System.UInt64", true); 
 			break;
 		}
 		case 73: {
 			lexer.NextToken();
 
-#line  1807 "VBNET.ATG" 
+#line  1802 "VBNET.ATG" 
 			type = new TypeReference("System.Object", true); 
 			break;
 		}
 		case 79: {
 			lexer.NextToken();
 
-#line  1808 "VBNET.ATG" 
+#line  1803 "VBNET.ATG" 
 			type = new TypeReference("System.Single", true); 
 			break;
 		}
 		case 80: {
 			lexer.NextToken();
 
-#line  1809 "VBNET.ATG" 
+#line  1804 "VBNET.ATG" 
 			type = new TypeReference("System.String", true); 
 			break;
 		}
@@ -4358,19 +4352,19 @@ out TypeReference type) {
 	}
 
 	void GetTypeTypeName(
-#line  2454 "VBNET.ATG" 
+#line  2449 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  2455 "VBNET.ATG" 
+#line  2450 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  2457 "VBNET.ATG" 
+#line  2452 "VBNET.ATG" 
 out typeref, true);
 		ArrayTypeModifiers(
-#line  2458 "VBNET.ATG" 
+#line  2453 "VBNET.ATG" 
 out rank);
 
-#line  2459 "VBNET.ATG" 
+#line  2454 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -4378,10 +4372,10 @@ out rank);
 	}
 
 	void ConditionalExpression(
-#line  1742 "VBNET.ATG" 
+#line  1737 "VBNET.ATG" 
 out Expression expr) {
 
-#line  1744 "VBNET.ATG" 
+#line  1739 "VBNET.ATG" 
 		ConditionalExpression conditionalExpression = new ConditionalExpression();
 		BinaryOperatorExpression binaryOperatorExpression = new BinaryOperatorExpression();
 		conditionalExpression.StartLocation = binaryOperatorExpression.StartLocation = la.Location;
@@ -4393,21 +4387,21 @@ out Expression expr) {
 		Expect(122);
 		Expect(25);
 		Expr(
-#line  1753 "VBNET.ATG" 
+#line  1748 "VBNET.ATG" 
 out condition);
 		Expect(12);
 		Expr(
-#line  1753 "VBNET.ATG" 
+#line  1748 "VBNET.ATG" 
 out trueExpr);
 		if (la.kind == 12) {
 			lexer.NextToken();
 			Expr(
-#line  1753 "VBNET.ATG" 
+#line  1748 "VBNET.ATG" 
 out falseExpr);
 		}
 		Expect(26);
 
-#line  1755 "VBNET.ATG" 
+#line  1750 "VBNET.ATG" 
 		if(falseExpr != null)
 		{
 			conditionalExpression.Condition = condition;
@@ -4430,348 +4424,348 @@ out falseExpr);
 	}
 
 	void ArgumentList(
-#line  2386 "VBNET.ATG" 
+#line  2381 "VBNET.ATG" 
 out List<Expression> arguments) {
 
-#line  2388 "VBNET.ATG" 
+#line  2383 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		Expression expr = null;
 		
 		if (StartOf(24)) {
 			Argument(
-#line  2391 "VBNET.ATG" 
+#line  2386 "VBNET.ATG" 
 out expr);
 		}
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  2392 "VBNET.ATG" 
+#line  2387 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 			if (StartOf(24)) {
 				Argument(
-#line  2393 "VBNET.ATG" 
+#line  2388 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2394 "VBNET.ATG" 
+#line  2389 "VBNET.ATG" 
 			if (expr == null) expr = Expression.Null; 
 		}
 
-#line  2396 "VBNET.ATG" 
+#line  2391 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); 
 	}
 
 	void ConjunctionExpr(
-#line  1828 "VBNET.ATG" 
+#line  1823 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1830 "VBNET.ATG" 
+#line  1825 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		NotExpr(
-#line  1833 "VBNET.ATG" 
+#line  1828 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 47 || la.kind == 48) {
 			if (la.kind == 47) {
 				lexer.NextToken();
 
-#line  1836 "VBNET.ATG" 
+#line  1831 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseAnd; 
 			} else {
 				lexer.NextToken();
 
-#line  1837 "VBNET.ATG" 
+#line  1832 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalAnd; 
 			}
 			NotExpr(
-#line  1839 "VBNET.ATG" 
+#line  1834 "VBNET.ATG" 
 out expr);
 
-#line  1839 "VBNET.ATG" 
+#line  1834 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void NotExpr(
-#line  1843 "VBNET.ATG" 
+#line  1838 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1844 "VBNET.ATG" 
+#line  1839 "VBNET.ATG" 
 		UnaryOperatorType uop = UnaryOperatorType.None; 
 		while (la.kind == 150) {
 			lexer.NextToken();
 
-#line  1845 "VBNET.ATG" 
+#line  1840 "VBNET.ATG" 
 			uop = UnaryOperatorType.Not; 
 		}
 		ComparisonExpr(
-#line  1846 "VBNET.ATG" 
+#line  1841 "VBNET.ATG" 
 out outExpr);
 
-#line  1847 "VBNET.ATG" 
+#line  1842 "VBNET.ATG" 
 		if (uop != UnaryOperatorType.None)
 		outExpr = new UnaryOperatorExpression(outExpr, uop);
 		
 	}
 
 	void ComparisonExpr(
-#line  1852 "VBNET.ATG" 
+#line  1847 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1854 "VBNET.ATG" 
+#line  1849 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ShiftExpr(
-#line  1857 "VBNET.ATG" 
+#line  1852 "VBNET.ATG" 
 out outExpr);
 		while (StartOf(33)) {
 			switch (la.kind) {
 			case 28: {
 				lexer.NextToken();
 
-#line  1860 "VBNET.ATG" 
+#line  1855 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 27: {
 				lexer.NextToken();
 
-#line  1861 "VBNET.ATG" 
+#line  1856 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 31: {
 				lexer.NextToken();
 
-#line  1862 "VBNET.ATG" 
+#line  1857 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 30: {
 				lexer.NextToken();
 
-#line  1863 "VBNET.ATG" 
+#line  1858 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 29: {
 				lexer.NextToken();
 
-#line  1864 "VBNET.ATG" 
+#line  1859 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			case 10: {
 				lexer.NextToken();
 
-#line  1865 "VBNET.ATG" 
+#line  1860 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 136: {
 				lexer.NextToken();
 
-#line  1866 "VBNET.ATG" 
+#line  1861 "VBNET.ATG" 
 				op = BinaryOperatorType.Like; 
 				break;
 			}
 			case 131: {
 				lexer.NextToken();
 
-#line  1867 "VBNET.ATG" 
+#line  1862 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceEquality; 
 				break;
 			}
 			case 132: {
 				lexer.NextToken();
 
-#line  1868 "VBNET.ATG" 
+#line  1863 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceInequality; 
 				break;
 			}
 			}
 			if (StartOf(34)) {
 				ShiftExpr(
-#line  1871 "VBNET.ATG" 
+#line  1866 "VBNET.ATG" 
 out expr);
 
-#line  1871 "VBNET.ATG" 
+#line  1866 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 			} else if (la.kind == 150) {
 				lexer.NextToken();
 				ShiftExpr(
-#line  1874 "VBNET.ATG" 
+#line  1869 "VBNET.ATG" 
 out expr);
 
-#line  1874 "VBNET.ATG" 
+#line  1869 "VBNET.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not));  
 			} else SynErr(264);
 		}
 	}
 
 	void ShiftExpr(
-#line  1879 "VBNET.ATG" 
+#line  1874 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1881 "VBNET.ATG" 
+#line  1876 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ConcatenationExpr(
-#line  1884 "VBNET.ATG" 
+#line  1879 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 32 || la.kind == 33) {
 			if (la.kind == 32) {
 				lexer.NextToken();
 
-#line  1887 "VBNET.ATG" 
+#line  1882 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftLeft; 
 			} else {
 				lexer.NextToken();
 
-#line  1888 "VBNET.ATG" 
+#line  1883 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftRight; 
 			}
 			ConcatenationExpr(
-#line  1890 "VBNET.ATG" 
+#line  1885 "VBNET.ATG" 
 out expr);
 
-#line  1890 "VBNET.ATG" 
+#line  1885 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void ConcatenationExpr(
-#line  1894 "VBNET.ATG" 
+#line  1889 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1895 "VBNET.ATG" 
+#line  1890 "VBNET.ATG" 
 		Expression expr; 
 		AdditiveExpr(
-#line  1897 "VBNET.ATG" 
+#line  1892 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 13) {
 			lexer.NextToken();
 			AdditiveExpr(
-#line  1897 "VBNET.ATG" 
+#line  1892 "VBNET.ATG" 
 out expr);
 
-#line  1897 "VBNET.ATG" 
+#line  1892 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr);  
 		}
 	}
 
 	void AdditiveExpr(
-#line  1900 "VBNET.ATG" 
+#line  1895 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1902 "VBNET.ATG" 
+#line  1897 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ModuloExpr(
-#line  1905 "VBNET.ATG" 
+#line  1900 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 18 || la.kind == 19) {
 			if (la.kind == 19) {
 				lexer.NextToken();
 
-#line  1908 "VBNET.ATG" 
+#line  1903 "VBNET.ATG" 
 				op = BinaryOperatorType.Add; 
 			} else {
 				lexer.NextToken();
 
-#line  1909 "VBNET.ATG" 
+#line  1904 "VBNET.ATG" 
 				op = BinaryOperatorType.Subtract; 
 			}
 			ModuloExpr(
-#line  1911 "VBNET.ATG" 
+#line  1906 "VBNET.ATG" 
 out expr);
 
-#line  1911 "VBNET.ATG" 
+#line  1906 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void ModuloExpr(
-#line  1915 "VBNET.ATG" 
+#line  1910 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1916 "VBNET.ATG" 
+#line  1911 "VBNET.ATG" 
 		Expression expr; 
 		IntegerDivisionExpr(
-#line  1918 "VBNET.ATG" 
+#line  1913 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 140) {
 			lexer.NextToken();
 			IntegerDivisionExpr(
-#line  1918 "VBNET.ATG" 
+#line  1913 "VBNET.ATG" 
 out expr);
 
-#line  1918 "VBNET.ATG" 
+#line  1913 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr);  
 		}
 	}
 
 	void IntegerDivisionExpr(
-#line  1921 "VBNET.ATG" 
+#line  1916 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1922 "VBNET.ATG" 
+#line  1917 "VBNET.ATG" 
 		Expression expr; 
 		MultiplicativeExpr(
-#line  1924 "VBNET.ATG" 
+#line  1919 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 15) {
 			lexer.NextToken();
 			MultiplicativeExpr(
-#line  1924 "VBNET.ATG" 
+#line  1919 "VBNET.ATG" 
 out expr);
 
-#line  1924 "VBNET.ATG" 
+#line  1919 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr);  
 		}
 	}
 
 	void MultiplicativeExpr(
-#line  1927 "VBNET.ATG" 
+#line  1922 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1929 "VBNET.ATG" 
+#line  1924 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		UnaryExpr(
-#line  1932 "VBNET.ATG" 
+#line  1927 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 14 || la.kind == 22) {
 			if (la.kind == 22) {
 				lexer.NextToken();
 
-#line  1935 "VBNET.ATG" 
+#line  1930 "VBNET.ATG" 
 				op = BinaryOperatorType.Multiply; 
 			} else {
 				lexer.NextToken();
 
-#line  1936 "VBNET.ATG" 
+#line  1931 "VBNET.ATG" 
 				op = BinaryOperatorType.Divide; 
 			}
 			UnaryExpr(
-#line  1938 "VBNET.ATG" 
+#line  1933 "VBNET.ATG" 
 out expr);
 
-#line  1938 "VBNET.ATG" 
+#line  1933 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr); 
 		}
 	}
 
 	void UnaryExpr(
-#line  1942 "VBNET.ATG" 
+#line  1937 "VBNET.ATG" 
 out Expression uExpr) {
 
-#line  1944 "VBNET.ATG" 
+#line  1939 "VBNET.ATG" 
 		Expression expr;
 		UnaryOperatorType uop = UnaryOperatorType.None;
 		bool isUOp = false;
@@ -4780,25 +4774,25 @@ out Expression uExpr) {
 			if (la.kind == 19) {
 				lexer.NextToken();
 
-#line  1948 "VBNET.ATG" 
+#line  1943 "VBNET.ATG" 
 				uop = UnaryOperatorType.Plus; isUOp = true; 
 			} else if (la.kind == 18) {
 				lexer.NextToken();
 
-#line  1949 "VBNET.ATG" 
+#line  1944 "VBNET.ATG" 
 				uop = UnaryOperatorType.Minus; isUOp = true; 
 			} else {
 				lexer.NextToken();
 
-#line  1950 "VBNET.ATG" 
+#line  1945 "VBNET.ATG" 
 				uop = UnaryOperatorType.Dereference;  isUOp = true;
 			}
 		}
 		ExponentiationExpr(
-#line  1952 "VBNET.ATG" 
+#line  1947 "VBNET.ATG" 
 out expr);
 
-#line  1954 "VBNET.ATG" 
+#line  1949 "VBNET.ATG" 
 		if (isUOp) {
 		uExpr = new UnaryOperatorExpression(expr, uop);
 		} else {
@@ -4808,107 +4802,107 @@ out expr);
 	}
 
 	void ExponentiationExpr(
-#line  1962 "VBNET.ATG" 
+#line  1957 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1963 "VBNET.ATG" 
+#line  1958 "VBNET.ATG" 
 		Expression expr; 
 		SimpleExpr(
-#line  1965 "VBNET.ATG" 
+#line  1960 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 20) {
 			lexer.NextToken();
 			SimpleExpr(
-#line  1965 "VBNET.ATG" 
+#line  1960 "VBNET.ATG" 
 out expr);
 
-#line  1965 "VBNET.ATG" 
+#line  1960 "VBNET.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr);  
 		}
 	}
 
 	void NormalOrReDimArgumentList(
-#line  2400 "VBNET.ATG" 
+#line  2395 "VBNET.ATG" 
 out List<Expression> arguments, out bool canBeNormal, out bool canBeRedim) {
 
-#line  2402 "VBNET.ATG" 
+#line  2397 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		canBeNormal = true; canBeRedim = !IsNamedAssign();
 		Expression expr = null;
 		
 		if (StartOf(24)) {
 			Argument(
-#line  2407 "VBNET.ATG" 
+#line  2402 "VBNET.ATG" 
 out expr);
 			if (la.kind == 201) {
 				lexer.NextToken();
 
-#line  2408 "VBNET.ATG" 
+#line  2403 "VBNET.ATG" 
 				EnsureIsZero(expr); canBeNormal = false; 
 				Expr(
-#line  2409 "VBNET.ATG" 
+#line  2404 "VBNET.ATG" 
 out expr);
 			}
 		}
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  2412 "VBNET.ATG" 
+#line  2407 "VBNET.ATG" 
 			if (expr == null) canBeRedim = false; 
 
-#line  2413 "VBNET.ATG" 
+#line  2408 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 
-#line  2414 "VBNET.ATG" 
+#line  2409 "VBNET.ATG" 
 			canBeRedim &= !IsNamedAssign(); 
 			if (StartOf(24)) {
 				Argument(
-#line  2415 "VBNET.ATG" 
+#line  2410 "VBNET.ATG" 
 out expr);
 				if (la.kind == 201) {
 					lexer.NextToken();
 
-#line  2416 "VBNET.ATG" 
+#line  2411 "VBNET.ATG" 
 					EnsureIsZero(expr); canBeNormal = false; 
 					Expr(
-#line  2417 "VBNET.ATG" 
+#line  2412 "VBNET.ATG" 
 out expr);
 				}
 			}
 
-#line  2419 "VBNET.ATG" 
+#line  2414 "VBNET.ATG" 
 			if (expr == null) { canBeRedim = false; expr = Expression.Null; } 
 		}
 
-#line  2421 "VBNET.ATG" 
+#line  2416 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); else canBeRedim = false; 
 	}
 
 	void ArrayTypeModifiers(
-#line  2528 "VBNET.ATG" 
+#line  2523 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  2530 "VBNET.ATG" 
+#line  2525 "VBNET.ATG" 
 		arrayModifiers = new ArrayList();
 		int i = 0;
 		
 		while (
-#line  2533 "VBNET.ATG" 
+#line  2528 "VBNET.ATG" 
 IsDims()) {
 			Expect(25);
 			if (la.kind == 12 || la.kind == 26) {
 				RankList(
-#line  2535 "VBNET.ATG" 
+#line  2530 "VBNET.ATG" 
 out i);
 			}
 
-#line  2537 "VBNET.ATG" 
+#line  2532 "VBNET.ATG" 
 			arrayModifiers.Add(i);
 			
 			Expect(26);
 		}
 
-#line  2542 "VBNET.ATG" 
+#line  2537 "VBNET.ATG" 
 		if(arrayModifiers.Count == 0) {
 		 arrayModifiers = null;
 		}
@@ -4916,10 +4910,10 @@ out i);
 	}
 
 	void MemberInitializer(
-#line  2370 "VBNET.ATG" 
+#line  2365 "VBNET.ATG" 
 out NamedArgumentExpression memberInitializer) {
 
-#line  2372 "VBNET.ATG" 
+#line  2367 "VBNET.ATG" 
 		memberInitializer = new NamedArgumentExpression();
 		memberInitializer.StartLocation = la.Location;
 		Expression initExpr = null;
@@ -4927,14 +4921,14 @@ out NamedArgumentExpression memberInitializer) {
 		
 		Expect(16);
 		IdentifierOrKeyword(
-#line  2377 "VBNET.ATG" 
+#line  2372 "VBNET.ATG" 
 out name);
 		Expect(10);
 		Expr(
-#line  2377 "VBNET.ATG" 
+#line  2372 "VBNET.ATG" 
 out initExpr);
 
-#line  2379 "VBNET.ATG" 
+#line  2374 "VBNET.ATG" 
 		memberInitializer.Name = name;
 		memberInitializer.Expression = initExpr;
 		memberInitializer.EndLocation = t.EndLocation;
@@ -4942,35 +4936,35 @@ out initExpr);
 	}
 
 	void FromOrAggregateQueryOperator(
-#line  2059 "VBNET.ATG" 
+#line  2054 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2061 "VBNET.ATG" 
+#line  2056 "VBNET.ATG" 
 		QueryExpressionFromClause fromClause = null;
 		QueryExpressionAggregateClause aggregateClause = null;
 		
 		if (la.kind == 113) {
 			FromQueryOperator(
-#line  2064 "VBNET.ATG" 
+#line  2059 "VBNET.ATG" 
 out fromClause);
 
-#line  2065 "VBNET.ATG" 
+#line  2060 "VBNET.ATG" 
 			middleClauses.Add(fromClause); 
 		} else if (la.kind == 45) {
 			AggregateQueryOperator(
-#line  2066 "VBNET.ATG" 
+#line  2061 "VBNET.ATG" 
 out aggregateClause);
 
-#line  2067 "VBNET.ATG" 
+#line  2062 "VBNET.ATG" 
 			middleClauses.Add(aggregateClause); 
 		} else SynErr(265);
 	}
 
 	void QueryOperator(
-#line  2070 "VBNET.ATG" 
+#line  2065 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2072 "VBNET.ATG" 
+#line  2067 "VBNET.ATG" 
 		QueryExpressionJoinVBClause joinClause = null;
 		QueryExpressionGroupVBClause groupByClause = null;
 		QueryExpressionPartitionVBClause partitionClause = null;
@@ -4980,94 +4974,94 @@ List<QueryExpressionClause> middleClauses) {
 		
 		if (la.kind == 113) {
 			FromQueryOperator(
-#line  2079 "VBNET.ATG" 
+#line  2074 "VBNET.ATG" 
 out fromClause);
 
-#line  2080 "VBNET.ATG" 
+#line  2075 "VBNET.ATG" 
 			middleClauses.Add(fromClause); 
 		} else if (la.kind == 45) {
 			AggregateQueryOperator(
-#line  2081 "VBNET.ATG" 
+#line  2076 "VBNET.ATG" 
 out aggregateClause);
 
-#line  2082 "VBNET.ATG" 
+#line  2077 "VBNET.ATG" 
 			middleClauses.Add(aggregateClause); 
 		} else if (la.kind == 182) {
 			SelectQueryOperator(
-#line  2083 "VBNET.ATG" 
+#line  2078 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 94) {
 			DistinctQueryOperator(
-#line  2084 "VBNET.ATG" 
+#line  2079 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 215) {
 			WhereQueryOperator(
-#line  2085 "VBNET.ATG" 
+#line  2080 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 162) {
 			OrderByQueryOperator(
-#line  2086 "VBNET.ATG" 
+#line  2081 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 188 || la.kind == 197) {
 			PartitionQueryOperator(
-#line  2087 "VBNET.ATG" 
+#line  2082 "VBNET.ATG" 
 out partitionClause);
 
-#line  2088 "VBNET.ATG" 
+#line  2083 "VBNET.ATG" 
 			middleClauses.Add(partitionClause); 
 		} else if (la.kind == 134) {
 			LetQueryOperator(
-#line  2089 "VBNET.ATG" 
+#line  2084 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 133) {
 			JoinQueryOperator(
-#line  2090 "VBNET.ATG" 
+#line  2085 "VBNET.ATG" 
 out joinClause);
 
-#line  2091 "VBNET.ATG" 
+#line  2086 "VBNET.ATG" 
 			middleClauses.Add(joinClause); 
 		} else if (
-#line  2092 "VBNET.ATG" 
+#line  2087 "VBNET.ATG" 
 la.kind == Tokens.Group && Peek(1).kind == Tokens.Join) {
 			GroupJoinQueryOperator(
-#line  2092 "VBNET.ATG" 
+#line  2087 "VBNET.ATG" 
 out groupJoinClause);
 
-#line  2093 "VBNET.ATG" 
+#line  2088 "VBNET.ATG" 
 			middleClauses.Add(groupJoinClause); 
 		} else if (la.kind == 120) {
 			GroupByQueryOperator(
-#line  2094 "VBNET.ATG" 
+#line  2089 "VBNET.ATG" 
 out groupByClause);
 
-#line  2095 "VBNET.ATG" 
+#line  2090 "VBNET.ATG" 
 			middleClauses.Add(groupByClause); 
 		} else SynErr(266);
 	}
 
 	void FromQueryOperator(
-#line  2170 "VBNET.ATG" 
+#line  2165 "VBNET.ATG" 
 out QueryExpressionFromClause fromClause) {
 
-#line  2172 "VBNET.ATG" 
+#line  2167 "VBNET.ATG" 
 		fromClause = new QueryExpressionFromClause();
 		fromClause.StartLocation = la.Location;
 		
 		Expect(113);
 		CollectionRangeVariableDeclarationList(
-#line  2175 "VBNET.ATG" 
+#line  2170 "VBNET.ATG" 
 fromClause.Sources);
 
-#line  2177 "VBNET.ATG" 
+#line  2172 "VBNET.ATG" 
 		fromClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void AggregateQueryOperator(
-#line  2239 "VBNET.ATG" 
+#line  2234 "VBNET.ATG" 
 out QueryExpressionAggregateClause aggregateClause) {
 
-#line  2241 "VBNET.ATG" 
+#line  2236 "VBNET.ATG" 
 		aggregateClause = new QueryExpressionAggregateClause();
 		aggregateClause.IntoVariables = new List<ExpressionRangeVariable>();
 		aggregateClause.StartLocation = la.Location;
@@ -5075,77 +5069,77 @@ out QueryExpressionAggregateClause aggregateClause) {
 		
 		Expect(45);
 		CollectionRangeVariableDeclaration(
-#line  2246 "VBNET.ATG" 
+#line  2241 "VBNET.ATG" 
 out source);
 
-#line  2248 "VBNET.ATG" 
+#line  2243 "VBNET.ATG" 
 		aggregateClause.Source = source;
 		
 		while (StartOf(31)) {
 			QueryOperator(
-#line  2251 "VBNET.ATG" 
+#line  2246 "VBNET.ATG" 
 aggregateClause.MiddleClauses);
 		}
 		Expect(130);
 		ExpressionRangeVariableDeclarationList(
-#line  2253 "VBNET.ATG" 
+#line  2248 "VBNET.ATG" 
 aggregateClause.IntoVariables);
 
-#line  2255 "VBNET.ATG" 
+#line  2250 "VBNET.ATG" 
 		aggregateClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void SelectQueryOperator(
-#line  2181 "VBNET.ATG" 
+#line  2176 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2183 "VBNET.ATG" 
+#line  2178 "VBNET.ATG" 
 		QueryExpressionSelectVBClause selectClause = new QueryExpressionSelectVBClause();
 		selectClause.StartLocation = la.Location;
 		
 		Expect(182);
 		ExpressionRangeVariableDeclarationList(
-#line  2186 "VBNET.ATG" 
+#line  2181 "VBNET.ATG" 
 selectClause.Variables);
 
-#line  2188 "VBNET.ATG" 
+#line  2183 "VBNET.ATG" 
 		selectClause.EndLocation = t.Location;
 		middleClauses.Add(selectClause);
 		
 	}
 
 	void DistinctQueryOperator(
-#line  2193 "VBNET.ATG" 
+#line  2188 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2195 "VBNET.ATG" 
+#line  2190 "VBNET.ATG" 
 		QueryExpressionDistinctClause distinctClause = new QueryExpressionDistinctClause();
 		distinctClause.StartLocation = la.Location;
 		
 		Expect(94);
 
-#line  2200 "VBNET.ATG" 
+#line  2195 "VBNET.ATG" 
 		distinctClause.EndLocation = t.EndLocation;
 		middleClauses.Add(distinctClause);
 		
 	}
 
 	void WhereQueryOperator(
-#line  2205 "VBNET.ATG" 
+#line  2200 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2207 "VBNET.ATG" 
+#line  2202 "VBNET.ATG" 
 		QueryExpressionWhereClause whereClause = new QueryExpressionWhereClause();
 		whereClause.StartLocation = la.Location;
 		Expression operand = null;
 		
 		Expect(215);
 		Expr(
-#line  2211 "VBNET.ATG" 
+#line  2206 "VBNET.ATG" 
 out operand);
 
-#line  2213 "VBNET.ATG" 
+#line  2208 "VBNET.ATG" 
 		whereClause.Condition = operand;
 		whereClause.EndLocation = t.EndLocation;
 		
@@ -5154,10 +5148,10 @@ out operand);
 	}
 
 	void OrderByQueryOperator(
-#line  2098 "VBNET.ATG" 
+#line  2093 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2100 "VBNET.ATG" 
+#line  2095 "VBNET.ATG" 
 		QueryExpressionOrderClause orderClause = new QueryExpressionOrderClause();
 		orderClause.StartLocation = la.Location;
 		List<QueryExpressionOrdering> orderings = null;
@@ -5165,10 +5159,10 @@ List<QueryExpressionClause> middleClauses) {
 		Expect(162);
 		Expect(57);
 		OrderExpressionList(
-#line  2104 "VBNET.ATG" 
+#line  2099 "VBNET.ATG" 
 out orderings);
 
-#line  2106 "VBNET.ATG" 
+#line  2101 "VBNET.ATG" 
 		orderClause.Orderings = orderings;
 		orderClause.EndLocation = t.EndLocation;
 		middleClauses.Add(orderClause);
@@ -5176,10 +5170,10 @@ out orderings);
 	}
 
 	void PartitionQueryOperator(
-#line  2220 "VBNET.ATG" 
+#line  2215 "VBNET.ATG" 
 out QueryExpressionPartitionVBClause partitionClause) {
 
-#line  2222 "VBNET.ATG" 
+#line  2217 "VBNET.ATG" 
 		partitionClause = new QueryExpressionPartitionVBClause();
 		partitionClause.StartLocation = la.Location;
 		Expression expr = null;
@@ -5187,60 +5181,60 @@ out QueryExpressionPartitionVBClause partitionClause) {
 		if (la.kind == 197) {
 			lexer.NextToken();
 
-#line  2227 "VBNET.ATG" 
+#line  2222 "VBNET.ATG" 
 			partitionClause.PartitionType = QueryExpressionPartitionType.Take; 
 			if (la.kind == 216) {
 				lexer.NextToken();
 
-#line  2228 "VBNET.ATG" 
+#line  2223 "VBNET.ATG" 
 				partitionClause.PartitionType = QueryExpressionPartitionType.TakeWhile; 
 			}
 		} else if (la.kind == 188) {
 			lexer.NextToken();
 
-#line  2229 "VBNET.ATG" 
+#line  2224 "VBNET.ATG" 
 			partitionClause.PartitionType = QueryExpressionPartitionType.Skip; 
 			if (la.kind == 216) {
 				lexer.NextToken();
 
-#line  2230 "VBNET.ATG" 
+#line  2225 "VBNET.ATG" 
 				partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile; 
 			}
 		} else SynErr(267);
 		Expr(
-#line  2232 "VBNET.ATG" 
+#line  2227 "VBNET.ATG" 
 out expr);
 
-#line  2234 "VBNET.ATG" 
+#line  2229 "VBNET.ATG" 
 		partitionClause.Expression = expr;
 		partitionClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void LetQueryOperator(
-#line  2259 "VBNET.ATG" 
+#line  2254 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2261 "VBNET.ATG" 
+#line  2256 "VBNET.ATG" 
 		QueryExpressionLetVBClause letClause = new QueryExpressionLetVBClause();
 		letClause.StartLocation = la.Location;
 		
 		Expect(134);
 		ExpressionRangeVariableDeclarationList(
-#line  2264 "VBNET.ATG" 
+#line  2259 "VBNET.ATG" 
 letClause.Variables);
 
-#line  2266 "VBNET.ATG" 
+#line  2261 "VBNET.ATG" 
 		letClause.EndLocation = t.EndLocation;
 		middleClauses.Add(letClause);
 		
 	}
 
 	void JoinQueryOperator(
-#line  2303 "VBNET.ATG" 
+#line  2298 "VBNET.ATG" 
 out QueryExpressionJoinVBClause joinClause) {
 
-#line  2305 "VBNET.ATG" 
+#line  2300 "VBNET.ATG" 
 		joinClause = new QueryExpressionJoinVBClause();
 		joinClause.StartLocation = la.Location;
 		CollectionRangeVariable joinVariable = null;
@@ -5250,203 +5244,203 @@ out QueryExpressionJoinVBClause joinClause) {
 		
 		Expect(133);
 		CollectionRangeVariableDeclaration(
-#line  2312 "VBNET.ATG" 
+#line  2307 "VBNET.ATG" 
 out joinVariable);
 
-#line  2313 "VBNET.ATG" 
+#line  2308 "VBNET.ATG" 
 		joinClause.JoinVariable = joinVariable; 
 		if (la.kind == 133) {
 			JoinQueryOperator(
-#line  2315 "VBNET.ATG" 
+#line  2310 "VBNET.ATG" 
 out subJoin);
 
-#line  2316 "VBNET.ATG" 
+#line  2311 "VBNET.ATG" 
 			joinClause.SubJoin = subJoin; 
 		}
 		Expect(157);
 		JoinCondition(
-#line  2319 "VBNET.ATG" 
+#line  2314 "VBNET.ATG" 
 out condition);
 
-#line  2320 "VBNET.ATG" 
+#line  2315 "VBNET.ATG" 
 		SafeAdd(joinClause, joinClause.Conditions, condition); 
 		while (la.kind == 47) {
 			lexer.NextToken();
 			JoinCondition(
-#line  2322 "VBNET.ATG" 
+#line  2317 "VBNET.ATG" 
 out condition);
 
-#line  2323 "VBNET.ATG" 
+#line  2318 "VBNET.ATG" 
 			SafeAdd(joinClause, joinClause.Conditions, condition); 
 		}
 
-#line  2326 "VBNET.ATG" 
+#line  2321 "VBNET.ATG" 
 		joinClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void GroupJoinQueryOperator(
-#line  2156 "VBNET.ATG" 
+#line  2151 "VBNET.ATG" 
 out QueryExpressionGroupJoinVBClause groupJoinClause) {
 
-#line  2158 "VBNET.ATG" 
+#line  2153 "VBNET.ATG" 
 		groupJoinClause = new QueryExpressionGroupJoinVBClause();
 		groupJoinClause.StartLocation = la.Location;
 		QueryExpressionJoinVBClause joinClause = null;
 		
 		Expect(120);
 		JoinQueryOperator(
-#line  2162 "VBNET.ATG" 
+#line  2157 "VBNET.ATG" 
 out joinClause);
 		Expect(130);
 		ExpressionRangeVariableDeclarationList(
-#line  2163 "VBNET.ATG" 
+#line  2158 "VBNET.ATG" 
 groupJoinClause.IntoVariables);
 
-#line  2165 "VBNET.ATG" 
+#line  2160 "VBNET.ATG" 
 		groupJoinClause.JoinClause = joinClause;
 		groupJoinClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void GroupByQueryOperator(
-#line  2143 "VBNET.ATG" 
+#line  2138 "VBNET.ATG" 
 out QueryExpressionGroupVBClause groupByClause) {
 
-#line  2145 "VBNET.ATG" 
+#line  2140 "VBNET.ATG" 
 		groupByClause = new QueryExpressionGroupVBClause();
 		groupByClause.StartLocation = la.Location;
 		
 		Expect(120);
 		ExpressionRangeVariableDeclarationList(
-#line  2148 "VBNET.ATG" 
+#line  2143 "VBNET.ATG" 
 groupByClause.GroupVariables);
 		Expect(57);
 		ExpressionRangeVariableDeclarationList(
-#line  2149 "VBNET.ATG" 
+#line  2144 "VBNET.ATG" 
 groupByClause.ByVariables);
 		Expect(130);
 		ExpressionRangeVariableDeclarationList(
-#line  2150 "VBNET.ATG" 
+#line  2145 "VBNET.ATG" 
 groupByClause.IntoVariables);
 
-#line  2152 "VBNET.ATG" 
+#line  2147 "VBNET.ATG" 
 		groupByClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void OrderExpressionList(
-#line  2112 "VBNET.ATG" 
+#line  2107 "VBNET.ATG" 
 out List<QueryExpressionOrdering> orderings) {
 
-#line  2114 "VBNET.ATG" 
+#line  2109 "VBNET.ATG" 
 		orderings = new List<QueryExpressionOrdering>();
 		QueryExpressionOrdering ordering = null;
 		
 		OrderExpression(
-#line  2117 "VBNET.ATG" 
+#line  2112 "VBNET.ATG" 
 out ordering);
 
-#line  2118 "VBNET.ATG" 
+#line  2113 "VBNET.ATG" 
 		orderings.Add(ordering); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			OrderExpression(
-#line  2120 "VBNET.ATG" 
+#line  2115 "VBNET.ATG" 
 out ordering);
 
-#line  2121 "VBNET.ATG" 
+#line  2116 "VBNET.ATG" 
 			orderings.Add(ordering); 
 		}
 	}
 
 	void OrderExpression(
-#line  2125 "VBNET.ATG" 
+#line  2120 "VBNET.ATG" 
 out QueryExpressionOrdering ordering) {
 
-#line  2127 "VBNET.ATG" 
+#line  2122 "VBNET.ATG" 
 		ordering = new QueryExpressionOrdering();
 		ordering.StartLocation = la.Location;
 		ordering.Direction = QueryExpressionOrderingDirection.None;
 		Expression orderExpr = null;
 		
 		Expr(
-#line  2132 "VBNET.ATG" 
+#line  2127 "VBNET.ATG" 
 out orderExpr);
 
-#line  2134 "VBNET.ATG" 
+#line  2129 "VBNET.ATG" 
 		ordering.Criteria = orderExpr;
 		
 		if (la.kind == 51 || la.kind == 91) {
 			if (la.kind == 51) {
 				lexer.NextToken();
 
-#line  2137 "VBNET.ATG" 
+#line  2132 "VBNET.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Ascending; 
 			} else {
 				lexer.NextToken();
 
-#line  2138 "VBNET.ATG" 
+#line  2133 "VBNET.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Descending; 
 			}
 		}
 
-#line  2140 "VBNET.ATG" 
+#line  2135 "VBNET.ATG" 
 		ordering.EndLocation = t.EndLocation; 
 	}
 
 	void ExpressionRangeVariableDeclarationList(
-#line  2271 "VBNET.ATG" 
+#line  2266 "VBNET.ATG" 
 List<ExpressionRangeVariable> variables) {
 
-#line  2273 "VBNET.ATG" 
+#line  2268 "VBNET.ATG" 
 		ExpressionRangeVariable variable = null;
 		
 		ExpressionRangeVariableDeclaration(
-#line  2275 "VBNET.ATG" 
+#line  2270 "VBNET.ATG" 
 out variable);
 
-#line  2276 "VBNET.ATG" 
+#line  2271 "VBNET.ATG" 
 		variables.Add(variable); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			ExpressionRangeVariableDeclaration(
-#line  2277 "VBNET.ATG" 
+#line  2272 "VBNET.ATG" 
 out variable);
 
-#line  2277 "VBNET.ATG" 
+#line  2272 "VBNET.ATG" 
 			variables.Add(variable); 
 		}
 	}
 
 	void CollectionRangeVariableDeclarationList(
-#line  2330 "VBNET.ATG" 
+#line  2325 "VBNET.ATG" 
 List<CollectionRangeVariable> rangeVariables) {
 
-#line  2331 "VBNET.ATG" 
+#line  2326 "VBNET.ATG" 
 		CollectionRangeVariable variableDeclaration; 
 		CollectionRangeVariableDeclaration(
-#line  2333 "VBNET.ATG" 
+#line  2328 "VBNET.ATG" 
 out variableDeclaration);
 
-#line  2334 "VBNET.ATG" 
+#line  2329 "VBNET.ATG" 
 		rangeVariables.Add(variableDeclaration); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			CollectionRangeVariableDeclaration(
-#line  2335 "VBNET.ATG" 
+#line  2330 "VBNET.ATG" 
 out variableDeclaration);
 
-#line  2335 "VBNET.ATG" 
+#line  2330 "VBNET.ATG" 
 			rangeVariables.Add(variableDeclaration); 
 		}
 	}
 
 	void CollectionRangeVariableDeclaration(
-#line  2338 "VBNET.ATG" 
+#line  2333 "VBNET.ATG" 
 out CollectionRangeVariable rangeVariable) {
 
-#line  2340 "VBNET.ATG" 
+#line  2335 "VBNET.ATG" 
 		rangeVariable = new CollectionRangeVariable();
 		rangeVariable.StartLocation = la.Location;
 		TypeReference typeName = null;
@@ -5454,71 +5448,71 @@ out CollectionRangeVariable rangeVariable) {
 		
 		Identifier();
 
-#line  2345 "VBNET.ATG" 
+#line  2340 "VBNET.ATG" 
 		rangeVariable.Identifier = t.val; 
 		if (la.kind == 50) {
 			lexer.NextToken();
 			TypeName(
-#line  2346 "VBNET.ATG" 
+#line  2341 "VBNET.ATG" 
 out typeName);
 
-#line  2346 "VBNET.ATG" 
+#line  2341 "VBNET.ATG" 
 			rangeVariable.Type = typeName; 
 		}
 		Expect(125);
 		Expr(
-#line  2347 "VBNET.ATG" 
+#line  2342 "VBNET.ATG" 
 out inExpr);
 
-#line  2349 "VBNET.ATG" 
+#line  2344 "VBNET.ATG" 
 		rangeVariable.Expression = inExpr;
 		rangeVariable.EndLocation = t.EndLocation;
 		
 	}
 
 	void ExpressionRangeVariableDeclaration(
-#line  2280 "VBNET.ATG" 
+#line  2275 "VBNET.ATG" 
 out ExpressionRangeVariable variable) {
 
-#line  2282 "VBNET.ATG" 
+#line  2277 "VBNET.ATG" 
 		variable = new ExpressionRangeVariable();
 		variable.StartLocation = la.Location;
 		Expression rhs = null;
 		TypeReference typeName = null;
 		
 		if (
-#line  2288 "VBNET.ATG" 
+#line  2283 "VBNET.ATG" 
 IsIdentifiedExpressionRange()) {
 			Identifier();
 
-#line  2289 "VBNET.ATG" 
+#line  2284 "VBNET.ATG" 
 			variable.Identifier = t.val; 
 			if (la.kind == 50) {
 				lexer.NextToken();
 				TypeName(
-#line  2291 "VBNET.ATG" 
+#line  2286 "VBNET.ATG" 
 out typeName);
 
-#line  2292 "VBNET.ATG" 
+#line  2287 "VBNET.ATG" 
 				variable.Type = typeName; 
 			}
 			Expect(10);
 		}
 		Expr(
-#line  2296 "VBNET.ATG" 
+#line  2291 "VBNET.ATG" 
 out rhs);
 
-#line  2298 "VBNET.ATG" 
+#line  2293 "VBNET.ATG" 
 		variable.Expression = rhs;
 		variable.EndLocation = t.EndLocation;
 		
 	}
 
 	void JoinCondition(
-#line  2354 "VBNET.ATG" 
+#line  2349 "VBNET.ATG" 
 out QueryExpressionJoinConditionVB condition) {
 
-#line  2356 "VBNET.ATG" 
+#line  2351 "VBNET.ATG" 
 		condition = new QueryExpressionJoinConditionVB();
 		condition.StartLocation = la.Location;
 		
@@ -5526,14 +5520,14 @@ out QueryExpressionJoinConditionVB condition) {
 		Expression rhs = null;
 		
 		Expr(
-#line  2362 "VBNET.ATG" 
+#line  2357 "VBNET.ATG" 
 out lhs);
 		Expect(103);
 		Expr(
-#line  2362 "VBNET.ATG" 
+#line  2357 "VBNET.ATG" 
 out rhs);
 
-#line  2364 "VBNET.ATG" 
+#line  2359 "VBNET.ATG" 
 		condition.LeftSide = lhs;
 		condition.RightSide = rhs;
 		condition.EndLocation = t.EndLocation;
@@ -5541,69 +5535,69 @@ out rhs);
 	}
 
 	void Argument(
-#line  2425 "VBNET.ATG" 
+#line  2420 "VBNET.ATG" 
 out Expression argumentexpr) {
 
-#line  2427 "VBNET.ATG" 
+#line  2422 "VBNET.ATG" 
 		Expression expr;
 		argumentexpr = null;
 		string name;
 		
 		if (
-#line  2431 "VBNET.ATG" 
+#line  2426 "VBNET.ATG" 
 IsNamedAssign()) {
 			Identifier();
 
-#line  2431 "VBNET.ATG" 
+#line  2426 "VBNET.ATG" 
 			name = t.val;  
 			Expect(11);
 			Expect(10);
 			Expr(
-#line  2431 "VBNET.ATG" 
+#line  2426 "VBNET.ATG" 
 out expr);
 
-#line  2433 "VBNET.ATG" 
+#line  2428 "VBNET.ATG" 
 			argumentexpr = new NamedArgumentExpression(name, expr);
 			
 		} else if (StartOf(24)) {
 			Expr(
-#line  2436 "VBNET.ATG" 
+#line  2431 "VBNET.ATG" 
 out argumentexpr);
 		} else SynErr(268);
 	}
 
 	void QualIdentAndTypeArguments(
-#line  2502 "VBNET.ATG" 
+#line  2497 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  2503 "VBNET.ATG" 
+#line  2498 "VBNET.ATG" 
 		string name; typeref = null; 
 		Qualident(
-#line  2505 "VBNET.ATG" 
+#line  2500 "VBNET.ATG" 
 out name);
 
-#line  2506 "VBNET.ATG" 
+#line  2501 "VBNET.ATG" 
 		typeref = new TypeReference(name); 
 		if (
-#line  2507 "VBNET.ATG" 
+#line  2502 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			lexer.NextToken();
 			Expect(155);
 			if (
-#line  2509 "VBNET.ATG" 
+#line  2504 "VBNET.ATG" 
 canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma)) {
 
-#line  2510 "VBNET.ATG" 
+#line  2505 "VBNET.ATG" 
 				typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				while (la.kind == 12) {
 					lexer.NextToken();
 
-#line  2511 "VBNET.ATG" 
+#line  2506 "VBNET.ATG" 
 					typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				}
 			} else if (StartOf(7)) {
 				TypeArgumentList(
-#line  2512 "VBNET.ATG" 
+#line  2507 "VBNET.ATG" 
 typeref.GenericTypes);
 			} else SynErr(269);
 			Expect(26);
@@ -5611,24 +5605,24 @@ typeref.GenericTypes);
 	}
 
 	void RankList(
-#line  2549 "VBNET.ATG" 
+#line  2544 "VBNET.ATG" 
 out int i) {
 
-#line  2550 "VBNET.ATG" 
+#line  2545 "VBNET.ATG" 
 		i = 0; 
 		while (la.kind == 12) {
 			lexer.NextToken();
 
-#line  2551 "VBNET.ATG" 
+#line  2546 "VBNET.ATG" 
 			++i; 
 		}
 	}
 
 	void Attribute(
-#line  2590 "VBNET.ATG" 
+#line  2585 "VBNET.ATG" 
 out ASTAttribute attribute) {
 
-#line  2591 "VBNET.ATG" 
+#line  2586 "VBNET.ATG" 
 		string name;
 		List<Expression> positional = new List<Expression>();
 		List<NamedArgumentExpression> named = new List<NamedArgumentExpression>();
@@ -5638,40 +5632,40 @@ out ASTAttribute attribute) {
 			Expect(16);
 		}
 		Qualident(
-#line  2596 "VBNET.ATG" 
+#line  2591 "VBNET.ATG" 
 out name);
 		if (la.kind == 25) {
 			AttributeArguments(
-#line  2597 "VBNET.ATG" 
+#line  2592 "VBNET.ATG" 
 positional, named);
 		}
 
-#line  2599 "VBNET.ATG" 
+#line  2594 "VBNET.ATG" 
 		attribute  = new ASTAttribute(name, positional, named);
 		
 	}
 
 	void AttributeArguments(
-#line  2604 "VBNET.ATG" 
+#line  2599 "VBNET.ATG" 
 List<Expression> positional, List<NamedArgumentExpression> named) {
 
-#line  2606 "VBNET.ATG" 
+#line  2601 "VBNET.ATG" 
 		bool nameFound = false;
 		string name = "";
 		Expression expr;
 		
 		Expect(25);
 		if (
-#line  2612 "VBNET.ATG" 
+#line  2607 "VBNET.ATG" 
 IsNotClosingParenthesis()) {
 			if (
-#line  2614 "VBNET.ATG" 
+#line  2609 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2614 "VBNET.ATG" 
+#line  2609 "VBNET.ATG" 
 				nameFound = true; 
 				IdentifierOrKeyword(
-#line  2615 "VBNET.ATG" 
+#line  2610 "VBNET.ATG" 
 out name);
 				if (la.kind == 11) {
 					lexer.NextToken();
@@ -5679,10 +5673,10 @@ out name);
 				Expect(10);
 			}
 			Expr(
-#line  2617 "VBNET.ATG" 
+#line  2612 "VBNET.ATG" 
 out expr);
 
-#line  2619 "VBNET.ATG" 
+#line  2614 "VBNET.ATG" 
 			if (expr != null) {
 			if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
 			else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
@@ -5691,13 +5685,13 @@ out expr);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				if (
-#line  2627 "VBNET.ATG" 
+#line  2622 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2627 "VBNET.ATG" 
+#line  2622 "VBNET.ATG" 
 					nameFound = true; 
 					IdentifierOrKeyword(
-#line  2628 "VBNET.ATG" 
+#line  2623 "VBNET.ATG" 
 out name);
 					if (la.kind == 11) {
 						lexer.NextToken();
@@ -5705,14 +5699,14 @@ out name);
 					Expect(10);
 				} else if (StartOf(24)) {
 
-#line  2630 "VBNET.ATG" 
+#line  2625 "VBNET.ATG" 
 					if (nameFound) Error("no positional argument after named argument"); 
 				} else SynErr(270);
 				Expr(
-#line  2631 "VBNET.ATG" 
+#line  2626 "VBNET.ATG" 
 out expr);
 
-#line  2631 "VBNET.ATG" 
+#line  2626 "VBNET.ATG" 
 				if (expr != null) { if(name == "") positional.Add(expr);
 				else { named.Add(new NamedArgumentExpression(name, expr)); name = ""; }
 				}
@@ -5723,10 +5717,10 @@ out expr);
 	}
 
 	void FormalParameter(
-#line  2688 "VBNET.ATG" 
+#line  2683 "VBNET.ATG" 
 out ParameterDeclarationExpression p) {
 
-#line  2690 "VBNET.ATG" 
+#line  2685 "VBNET.ATG" 
 		AttributeSection section;
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		TypeReference type = null;
@@ -5737,36 +5731,36 @@ out ParameterDeclarationExpression p) {
 		
 		while (la.kind == 28) {
 			AttributeSection(
-#line  2699 "VBNET.ATG" 
+#line  2694 "VBNET.ATG" 
 out section);
 
-#line  2699 "VBNET.ATG" 
+#line  2694 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		while (StartOf(35)) {
 			ParameterModifier(
-#line  2700 "VBNET.ATG" 
+#line  2695 "VBNET.ATG" 
 mod);
 		}
 		Identifier();
 
-#line  2701 "VBNET.ATG" 
+#line  2696 "VBNET.ATG" 
 		string parameterName = t.val; 
 		if (
-#line  2702 "VBNET.ATG" 
+#line  2697 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  2702 "VBNET.ATG" 
+#line  2697 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 50) {
 			lexer.NextToken();
 			TypeName(
-#line  2703 "VBNET.ATG" 
+#line  2698 "VBNET.ATG" 
 out type);
 		}
 
-#line  2705 "VBNET.ATG" 
+#line  2700 "VBNET.ATG" 
 		if(type != null) {
 		if (arrayModifiers != null) {
 			if (type.RankSpecifier != null) {
@@ -5782,11 +5776,11 @@ out type);
 		if (la.kind == 10) {
 			lexer.NextToken();
 			Expr(
-#line  2717 "VBNET.ATG" 
+#line  2712 "VBNET.ATG" 
 out expr);
 		}
 
-#line  2719 "VBNET.ATG" 
+#line  2714 "VBNET.ATG" 
 		mod.Check();
 		p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
 		p.Attributes = attributes;
@@ -5794,34 +5788,34 @@ out expr);
 	}
 
 	void ParameterModifier(
-#line  3401 "VBNET.ATG" 
+#line  3396 "VBNET.ATG" 
 ParamModifierList m) {
 		if (la.kind == 59) {
 			lexer.NextToken();
 
-#line  3402 "VBNET.ATG" 
+#line  3397 "VBNET.ATG" 
 			m.Add(ParameterModifiers.In); 
 		} else if (la.kind == 56) {
 			lexer.NextToken();
 
-#line  3403 "VBNET.ATG" 
+#line  3398 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Ref); 
 		} else if (la.kind == 160) {
 			lexer.NextToken();
 
-#line  3404 "VBNET.ATG" 
+#line  3399 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Optional); 
 		} else if (la.kind == 167) {
 			lexer.NextToken();
 
-#line  3405 "VBNET.ATG" 
+#line  3400 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Params); 
 		} else SynErr(271);
 	}
 
 	void Statement() {
 
-#line  2748 "VBNET.ATG" 
+#line  2743 "VBNET.ATG" 
 		Statement stmt = null;
 		Location startPos = la.Location;
 		string label = String.Empty;
@@ -5829,27 +5823,27 @@ ParamModifierList m) {
 		
 		if (la.kind == 1 || la.kind == 11) {
 		} else if (
-#line  2754 "VBNET.ATG" 
+#line  2749 "VBNET.ATG" 
 IsLabel()) {
 			LabelName(
-#line  2754 "VBNET.ATG" 
+#line  2749 "VBNET.ATG" 
 out label);
 
-#line  2756 "VBNET.ATG" 
+#line  2751 "VBNET.ATG" 
 			compilationUnit.AddChild(new LabelStatement(t.val));
 			
 			Expect(11);
 			Statement();
 		} else if (StartOf(36)) {
 			EmbeddedStatement(
-#line  2759 "VBNET.ATG" 
+#line  2754 "VBNET.ATG" 
 out stmt);
 
-#line  2759 "VBNET.ATG" 
+#line  2754 "VBNET.ATG" 
 			compilationUnit.AddChild(stmt); 
 		} else SynErr(272);
 
-#line  2762 "VBNET.ATG" 
+#line  2757 "VBNET.ATG" 
 		if (stmt != null) {
 		stmt.StartLocation = startPos;
 		stmt.EndLocation = t.Location;
@@ -5858,30 +5852,30 @@ out stmt);
 	}
 
 	void LabelName(
-#line  3177 "VBNET.ATG" 
+#line  3172 "VBNET.ATG" 
 out string name) {
 
-#line  3179 "VBNET.ATG" 
+#line  3174 "VBNET.ATG" 
 		name = String.Empty;
 		
 		if (StartOf(14)) {
 			Identifier();
 
-#line  3181 "VBNET.ATG" 
+#line  3176 "VBNET.ATG" 
 			name = t.val; 
 		} else if (la.kind == 5) {
 			lexer.NextToken();
 
-#line  3182 "VBNET.ATG" 
+#line  3177 "VBNET.ATG" 
 			name = t.val; 
 		} else SynErr(273);
 	}
 
 	void EmbeddedStatement(
-#line  2801 "VBNET.ATG" 
+#line  2796 "VBNET.ATG" 
 out Statement statement) {
 
-#line  2803 "VBNET.ATG" 
+#line  2798 "VBNET.ATG" 
 		Statement embeddedStatement = null;
 		statement = null;
 		Expression expr = null;
@@ -5891,224 +5885,224 @@ out Statement statement) {
 		if (la.kind == 107) {
 			lexer.NextToken();
 
-#line  2809 "VBNET.ATG" 
+#line  2804 "VBNET.ATG" 
 			ExitType exitType = ExitType.None; 
 			switch (la.kind) {
 			case 195: {
 				lexer.NextToken();
 
-#line  2811 "VBNET.ATG" 
+#line  2806 "VBNET.ATG" 
 				exitType = ExitType.Sub; 
 				break;
 			}
 			case 114: {
 				lexer.NextToken();
 
-#line  2813 "VBNET.ATG" 
+#line  2808 "VBNET.ATG" 
 				exitType = ExitType.Function; 
 				break;
 			}
 			case 171: {
 				lexer.NextToken();
 
-#line  2815 "VBNET.ATG" 
+#line  2810 "VBNET.ATG" 
 				exitType = ExitType.Property; 
 				break;
 			}
 			case 95: {
 				lexer.NextToken();
 
-#line  2817 "VBNET.ATG" 
+#line  2812 "VBNET.ATG" 
 				exitType = ExitType.Do; 
 				break;
 			}
 			case 111: {
 				lexer.NextToken();
 
-#line  2819 "VBNET.ATG" 
+#line  2814 "VBNET.ATG" 
 				exitType = ExitType.For; 
 				break;
 			}
 			case 203: {
 				lexer.NextToken();
 
-#line  2821 "VBNET.ATG" 
+#line  2816 "VBNET.ATG" 
 				exitType = ExitType.Try; 
 				break;
 			}
 			case 216: {
 				lexer.NextToken();
 
-#line  2823 "VBNET.ATG" 
+#line  2818 "VBNET.ATG" 
 				exitType = ExitType.While; 
 				break;
 			}
 			case 182: {
 				lexer.NextToken();
 
-#line  2825 "VBNET.ATG" 
+#line  2820 "VBNET.ATG" 
 				exitType = ExitType.Select; 
 				break;
 			}
 			default: SynErr(274); break;
 			}
 
-#line  2827 "VBNET.ATG" 
+#line  2822 "VBNET.ATG" 
 			statement = new ExitStatement(exitType); 
 		} else if (la.kind == 203) {
 			TryStatement(
-#line  2828 "VBNET.ATG" 
+#line  2823 "VBNET.ATG" 
 out statement);
 		} else if (la.kind == 76) {
 			lexer.NextToken();
 
-#line  2829 "VBNET.ATG" 
+#line  2824 "VBNET.ATG" 
 			ContinueType continueType = ContinueType.None; 
 			if (la.kind == 95 || la.kind == 111 || la.kind == 216) {
 				if (la.kind == 95) {
 					lexer.NextToken();
 
-#line  2829 "VBNET.ATG" 
+#line  2824 "VBNET.ATG" 
 					continueType = ContinueType.Do; 
 				} else if (la.kind == 111) {
 					lexer.NextToken();
 
-#line  2829 "VBNET.ATG" 
+#line  2824 "VBNET.ATG" 
 					continueType = ContinueType.For; 
 				} else {
 					lexer.NextToken();
 
-#line  2829 "VBNET.ATG" 
+#line  2824 "VBNET.ATG" 
 					continueType = ContinueType.While; 
 				}
 			}
 
-#line  2829 "VBNET.ATG" 
+#line  2824 "VBNET.ATG" 
 			statement = new ContinueStatement(continueType); 
 		} else if (la.kind == 200) {
 			lexer.NextToken();
 			if (StartOf(24)) {
 				Expr(
-#line  2831 "VBNET.ATG" 
+#line  2826 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2831 "VBNET.ATG" 
+#line  2826 "VBNET.ATG" 
 			statement = new ThrowStatement(expr); 
 		} else if (la.kind == 180) {
 			lexer.NextToken();
 			if (StartOf(24)) {
 				Expr(
-#line  2833 "VBNET.ATG" 
+#line  2828 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2833 "VBNET.ATG" 
+#line  2828 "VBNET.ATG" 
 			statement = new ReturnStatement(expr); 
 		} else if (la.kind == 196) {
 			lexer.NextToken();
 			Expr(
-#line  2835 "VBNET.ATG" 
+#line  2830 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  2835 "VBNET.ATG" 
+#line  2830 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(100);
 			Expect(196);
 
-#line  2836 "VBNET.ATG" 
+#line  2831 "VBNET.ATG" 
 			statement = new LockStatement(expr, embeddedStatement); 
 		} else if (la.kind == 174) {
 			lexer.NextToken();
 			Identifier();
 
-#line  2838 "VBNET.ATG" 
+#line  2833 "VBNET.ATG" 
 			name = t.val; 
 			if (la.kind == 25) {
 				lexer.NextToken();
 				if (StartOf(37)) {
 					ArgumentList(
-#line  2839 "VBNET.ATG" 
+#line  2834 "VBNET.ATG" 
 out p);
 				}
 				Expect(26);
 			}
 
-#line  2841 "VBNET.ATG" 
+#line  2836 "VBNET.ATG" 
 			statement = new RaiseEventStatement(name, p);
 			
 		} else if (la.kind == 218) {
 			WithStatement(
-#line  2844 "VBNET.ATG" 
+#line  2839 "VBNET.ATG" 
 out statement);
 		} else if (la.kind == 43) {
 			lexer.NextToken();
 
-#line  2846 "VBNET.ATG" 
+#line  2841 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  2847 "VBNET.ATG" 
+#line  2842 "VBNET.ATG" 
 out expr);
 			Expect(12);
 			Expr(
-#line  2847 "VBNET.ATG" 
+#line  2842 "VBNET.ATG" 
 out handlerExpr);
 
-#line  2849 "VBNET.ATG" 
+#line  2844 "VBNET.ATG" 
 			statement = new AddHandlerStatement(expr, handlerExpr);
 			
 		} else if (la.kind == 178) {
 			lexer.NextToken();
 
-#line  2852 "VBNET.ATG" 
+#line  2847 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  2853 "VBNET.ATG" 
+#line  2848 "VBNET.ATG" 
 out expr);
 			Expect(12);
 			Expr(
-#line  2853 "VBNET.ATG" 
+#line  2848 "VBNET.ATG" 
 out handlerExpr);
 
-#line  2855 "VBNET.ATG" 
+#line  2850 "VBNET.ATG" 
 			statement = new RemoveHandlerStatement(expr, handlerExpr);
 			
 		} else if (la.kind == 216) {
 			lexer.NextToken();
 			Expr(
-#line  2858 "VBNET.ATG" 
+#line  2853 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  2859 "VBNET.ATG" 
+#line  2854 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(100);
 			Expect(216);
 
-#line  2861 "VBNET.ATG" 
+#line  2856 "VBNET.ATG" 
 			statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
 			
 		} else if (la.kind == 95) {
 			lexer.NextToken();
 
-#line  2866 "VBNET.ATG" 
+#line  2861 "VBNET.ATG" 
 			ConditionType conditionType = ConditionType.None;
 			
 			if (la.kind == 209 || la.kind == 216) {
 				WhileOrUntil(
-#line  2869 "VBNET.ATG" 
+#line  2864 "VBNET.ATG" 
 out conditionType);
 				Expr(
-#line  2869 "VBNET.ATG" 
+#line  2864 "VBNET.ATG" 
 out expr);
 				EndOfStmt();
 				Block(
-#line  2870 "VBNET.ATG" 
+#line  2865 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(138);
 
-#line  2873 "VBNET.ATG" 
+#line  2868 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, 
 				                               embeddedStatement, 
 				                               conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, 
@@ -6117,26 +6111,26 @@ out embeddedStatement);
 			} else if (la.kind == 1 || la.kind == 11) {
 				EndOfStmt();
 				Block(
-#line  2880 "VBNET.ATG" 
+#line  2875 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(138);
 				if (la.kind == 209 || la.kind == 216) {
 					WhileOrUntil(
-#line  2881 "VBNET.ATG" 
+#line  2876 "VBNET.ATG" 
 out conditionType);
 					Expr(
-#line  2881 "VBNET.ATG" 
+#line  2876 "VBNET.ATG" 
 out expr);
 				}
 
-#line  2883 "VBNET.ATG" 
+#line  2878 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End);
 				
 			} else SynErr(275);
 		} else if (la.kind == 111) {
 			lexer.NextToken();
 
-#line  2888 "VBNET.ATG" 
+#line  2883 "VBNET.ATG" 
 			Expression group = null;
 			TypeReference typeReference;
 			string        typeName;
@@ -6145,24 +6139,24 @@ out expr);
 			if (la.kind == 97) {
 				lexer.NextToken();
 				LoopControlVariable(
-#line  2895 "VBNET.ATG" 
+#line  2890 "VBNET.ATG" 
 out typeReference, out typeName);
 				Expect(125);
 				Expr(
-#line  2896 "VBNET.ATG" 
+#line  2891 "VBNET.ATG" 
 out group);
 				EndOfStmt();
 				Block(
-#line  2897 "VBNET.ATG" 
+#line  2892 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(149);
 				if (StartOf(24)) {
 					Expr(
-#line  2898 "VBNET.ATG" 
+#line  2893 "VBNET.ATG" 
 out expr);
 				}
 
-#line  2900 "VBNET.ATG" 
+#line  2895 "VBNET.ATG" 
 				statement = new ForeachStatement(typeReference, 
 				                                typeName,
 				                                group, 
@@ -6174,7 +6168,7 @@ out expr);
 				
 			} else if (StartOf(38)) {
 
-#line  2911 "VBNET.ATG" 
+#line  2906 "VBNET.ATG" 
 				Expression start = null;
 				Expression end = null;
 				Expression step = null;
@@ -6183,59 +6177,59 @@ out expr);
 				List<Expression> nextExpressions = null;
 				
 				if (
-#line  2918 "VBNET.ATG" 
+#line  2913 "VBNET.ATG" 
 IsLoopVariableDeclaration()) {
 					LoopControlVariable(
-#line  2919 "VBNET.ATG" 
+#line  2914 "VBNET.ATG" 
 out typeReference, out typeName);
 				} else {
 
-#line  2921 "VBNET.ATG" 
+#line  2916 "VBNET.ATG" 
 					typeReference = null; typeName = null; 
 					SimpleExpr(
-#line  2922 "VBNET.ATG" 
+#line  2917 "VBNET.ATG" 
 out variableExpr);
 				}
 				Expect(10);
 				Expr(
-#line  2924 "VBNET.ATG" 
+#line  2919 "VBNET.ATG" 
 out start);
 				Expect(201);
 				Expr(
-#line  2924 "VBNET.ATG" 
+#line  2919 "VBNET.ATG" 
 out end);
 				if (la.kind == 190) {
 					lexer.NextToken();
 					Expr(
-#line  2924 "VBNET.ATG" 
+#line  2919 "VBNET.ATG" 
 out step);
 				}
 				EndOfStmt();
 				Block(
-#line  2925 "VBNET.ATG" 
+#line  2920 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(149);
 				if (StartOf(24)) {
 					Expr(
-#line  2928 "VBNET.ATG" 
+#line  2923 "VBNET.ATG" 
 out nextExpr);
 
-#line  2930 "VBNET.ATG" 
+#line  2925 "VBNET.ATG" 
 					nextExpressions = new List<Expression>();
 					nextExpressions.Add(nextExpr);
 					
 					while (la.kind == 12) {
 						lexer.NextToken();
 						Expr(
-#line  2933 "VBNET.ATG" 
+#line  2928 "VBNET.ATG" 
 out nextExpr);
 
-#line  2933 "VBNET.ATG" 
+#line  2928 "VBNET.ATG" 
 						nextExpressions.Add(nextExpr); 
 					}
 				}
 
-#line  2936 "VBNET.ATG" 
+#line  2931 "VBNET.ATG" 
 				statement = new ForNextStatement {
 				TypeReference = typeReference,
 				VariableName = typeName, 
@@ -6251,27 +6245,27 @@ out nextExpr);
 		} else if (la.kind == 105) {
 			lexer.NextToken();
 			Expr(
-#line  2949 "VBNET.ATG" 
+#line  2944 "VBNET.ATG" 
 out expr);
 
-#line  2949 "VBNET.ATG" 
+#line  2944 "VBNET.ATG" 
 			statement = new ErrorStatement(expr); 
 		} else if (la.kind == 176) {
 			lexer.NextToken();
 
-#line  2951 "VBNET.ATG" 
+#line  2946 "VBNET.ATG" 
 			bool isPreserve = false; 
 			if (la.kind == 169) {
 				lexer.NextToken();
 
-#line  2951 "VBNET.ATG" 
+#line  2946 "VBNET.ATG" 
 				isPreserve = true; 
 			}
 			ReDimClause(
-#line  2952 "VBNET.ATG" 
+#line  2947 "VBNET.ATG" 
 out expr);
 
-#line  2954 "VBNET.ATG" 
+#line  2949 "VBNET.ATG" 
 			ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
 			statement = reDimStatement;
 			SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
@@ -6279,48 +6273,48 @@ out expr);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				ReDimClause(
-#line  2958 "VBNET.ATG" 
+#line  2953 "VBNET.ATG" 
 out expr);
 
-#line  2959 "VBNET.ATG" 
+#line  2954 "VBNET.ATG" 
 				SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression); 
 			}
 		} else if (la.kind == 104) {
 			lexer.NextToken();
 			Expr(
-#line  2963 "VBNET.ATG" 
+#line  2958 "VBNET.ATG" 
 out expr);
 
-#line  2965 "VBNET.ATG" 
+#line  2960 "VBNET.ATG" 
 			EraseStatement eraseStatement = new EraseStatement();
 			if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr);}
 			
 			while (la.kind == 12) {
 				lexer.NextToken();
 				Expr(
-#line  2968 "VBNET.ATG" 
+#line  2963 "VBNET.ATG" 
 out expr);
 
-#line  2968 "VBNET.ATG" 
+#line  2963 "VBNET.ATG" 
 				if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr); }
 			}
 
-#line  2969 "VBNET.ATG" 
+#line  2964 "VBNET.ATG" 
 			statement = eraseStatement; 
 		} else if (la.kind == 191) {
 			lexer.NextToken();
 
-#line  2971 "VBNET.ATG" 
+#line  2966 "VBNET.ATG" 
 			statement = new StopStatement(); 
 		} else if (
-#line  2973 "VBNET.ATG" 
+#line  2968 "VBNET.ATG" 
 la.kind == Tokens.If) {
 			Expect(122);
 
-#line  2974 "VBNET.ATG" 
+#line  2969 "VBNET.ATG" 
 			Location ifStartLocation = t.Location; 
 			Expr(
-#line  2974 "VBNET.ATG" 
+#line  2969 "VBNET.ATG" 
 out expr);
 			if (la.kind == 199) {
 				lexer.NextToken();
@@ -6328,46 +6322,46 @@ out expr);
 			if (la.kind == 1 || la.kind == 11) {
 				EndOfStmt();
 				Block(
-#line  2977 "VBNET.ATG" 
+#line  2972 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  2979 "VBNET.ATG" 
+#line  2974 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
 				ifStatement.StartLocation = ifStartLocation;
 				Location elseIfStart;
 				
 				while (la.kind == 99 || 
-#line  2985 "VBNET.ATG" 
+#line  2980 "VBNET.ATG" 
 IsElseIf()) {
 					if (
-#line  2985 "VBNET.ATG" 
+#line  2980 "VBNET.ATG" 
 IsElseIf()) {
 						Expect(98);
 
-#line  2985 "VBNET.ATG" 
+#line  2980 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 						Expect(122);
 					} else {
 						lexer.NextToken();
 
-#line  2986 "VBNET.ATG" 
+#line  2981 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 					}
 
-#line  2988 "VBNET.ATG" 
+#line  2983 "VBNET.ATG" 
 					Expression condition = null; Statement block = null; 
 					Expr(
-#line  2989 "VBNET.ATG" 
+#line  2984 "VBNET.ATG" 
 out condition);
 					if (la.kind == 199) {
 						lexer.NextToken();
 					}
 					EndOfStmt();
 					Block(
-#line  2990 "VBNET.ATG" 
+#line  2985 "VBNET.ATG" 
 out block);
 
-#line  2992 "VBNET.ATG" 
+#line  2987 "VBNET.ATG" 
 					ElseIfSection elseIfSection = new ElseIfSection(condition, block);
 					elseIfSection.StartLocation = elseIfStart;
 					elseIfSection.EndLocation = t.Location;
@@ -6381,39 +6375,39 @@ out block);
 						EndOfStmt();
 					}
 					Block(
-#line  3001 "VBNET.ATG" 
+#line  2996 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  3003 "VBNET.ATG" 
+#line  2998 "VBNET.ATG" 
 					ifStatement.FalseStatement.Add(embeddedStatement);
 					
 				}
 				Expect(100);
 				Expect(122);
 
-#line  3007 "VBNET.ATG" 
+#line  3002 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location;
 				statement = ifStatement;
 				
 			} else if (StartOf(39)) {
 
-#line  3012 "VBNET.ATG" 
+#line  3007 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr);
 				ifStatement.StartLocation = ifStartLocation;
 				
 				SingleLineStatementList(
-#line  3015 "VBNET.ATG" 
+#line  3010 "VBNET.ATG" 
 ifStatement.TrueStatement);
 				if (la.kind == 98) {
 					lexer.NextToken();
 					if (StartOf(39)) {
 						SingleLineStatementList(
-#line  3018 "VBNET.ATG" 
+#line  3013 "VBNET.ATG" 
 ifStatement.FalseStatement);
 					}
 				}
 
-#line  3020 "VBNET.ATG" 
+#line  3015 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location; statement = ifStatement; 
 			} else SynErr(277);
 		} else if (la.kind == 182) {
@@ -6422,82 +6416,82 @@ ifStatement.FalseStatement);
 				lexer.NextToken();
 			}
 			Expr(
-#line  3023 "VBNET.ATG" 
+#line  3018 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 
-#line  3024 "VBNET.ATG" 
+#line  3019 "VBNET.ATG" 
 			List<SwitchSection> selectSections = new List<SwitchSection>();
 			Statement block = null;
 			
 			while (la.kind == 61) {
 
-#line  3028 "VBNET.ATG" 
+#line  3023 "VBNET.ATG" 
 				List<CaseLabel> caseClauses = null; Location caseLocation = la.Location; 
 				lexer.NextToken();
 				CaseClauses(
-#line  3029 "VBNET.ATG" 
+#line  3024 "VBNET.ATG" 
 out caseClauses);
 				if (
-#line  3029 "VBNET.ATG" 
+#line  3024 "VBNET.ATG" 
 IsNotStatementSeparator()) {
 					lexer.NextToken();
 				}
 				EndOfStmt();
 
-#line  3031 "VBNET.ATG" 
+#line  3026 "VBNET.ATG" 
 				SwitchSection selectSection = new SwitchSection(caseClauses);
 				selectSection.StartLocation = caseLocation;
 				
 				Block(
-#line  3034 "VBNET.ATG" 
+#line  3029 "VBNET.ATG" 
 out block);
 
-#line  3036 "VBNET.ATG" 
+#line  3031 "VBNET.ATG" 
 				selectSection.Children = block.Children;
 				selectSection.EndLocation = t.EndLocation;
 				selectSections.Add(selectSection);
 				
 			}
 
-#line  3042 "VBNET.ATG" 
+#line  3037 "VBNET.ATG" 
 			statement = new SwitchStatement(expr, selectSections);
 			
 			Expect(100);
 			Expect(182);
 		} else if (la.kind == 157) {
 
-#line  3045 "VBNET.ATG" 
+#line  3040 "VBNET.ATG" 
 			OnErrorStatement onErrorStatement = null; 
 			OnErrorStatement(
-#line  3046 "VBNET.ATG" 
+#line  3041 "VBNET.ATG" 
 out onErrorStatement);
 
-#line  3046 "VBNET.ATG" 
+#line  3041 "VBNET.ATG" 
 			statement = onErrorStatement; 
 		} else if (la.kind == 119) {
 
-#line  3047 "VBNET.ATG" 
+#line  3042 "VBNET.ATG" 
 			GotoStatement goToStatement = null; 
 			GotoStatement(
-#line  3048 "VBNET.ATG" 
+#line  3043 "VBNET.ATG" 
 out goToStatement);
 
-#line  3048 "VBNET.ATG" 
+#line  3043 "VBNET.ATG" 
 			statement = goToStatement; 
 		} else if (la.kind == 179) {
 
-#line  3049 "VBNET.ATG" 
+#line  3044 "VBNET.ATG" 
 			ResumeStatement resumeStatement = null; 
 			ResumeStatement(
-#line  3050 "VBNET.ATG" 
+#line  3045 "VBNET.ATG" 
 out resumeStatement);
 
-#line  3050 "VBNET.ATG" 
+#line  3045 "VBNET.ATG" 
 			statement = resumeStatement; 
 		} else if (StartOf(38)) {
 
-#line  3053 "VBNET.ATG" 
+#line  3048 "VBNET.ATG" 
 			Expression val = null;
 			AssignmentOperatorType op;
 			
@@ -6505,25 +6499,25 @@ out resumeStatement);
 			                        la.kind == Tokens.Not   || la.kind == Tokens.Times;
 			
 			SimpleExpr(
-#line  3059 "VBNET.ATG" 
+#line  3054 "VBNET.ATG" 
 out expr);
 			if (StartOf(40)) {
 				AssignmentOperator(
-#line  3061 "VBNET.ATG" 
+#line  3056 "VBNET.ATG" 
 out op);
 				Expr(
-#line  3061 "VBNET.ATG" 
+#line  3056 "VBNET.ATG" 
 out val);
 
-#line  3061 "VBNET.ATG" 
+#line  3056 "VBNET.ATG" 
 				expr = new AssignmentExpression(expr, op, val); 
 			} else if (la.kind == 1 || la.kind == 11 || la.kind == 98) {
 
-#line  3062 "VBNET.ATG" 
+#line  3057 "VBNET.ATG" 
 				if (mustBeAssignment) Error("error in assignment."); 
 			} else SynErr(278);
 
-#line  3065 "VBNET.ATG" 
+#line  3060 "VBNET.ATG" 
 			// a field reference expression that stands alone is a
 			// invocation expression without parantheses and arguments
 			if(expr is MemberReferenceExpression || expr is IdentifierExpression) {
@@ -6534,63 +6528,63 @@ out val);
 		} else if (la.kind == 60) {
 			lexer.NextToken();
 			SimpleExpr(
-#line  3072 "VBNET.ATG" 
+#line  3067 "VBNET.ATG" 
 out expr);
 
-#line  3072 "VBNET.ATG" 
+#line  3067 "VBNET.ATG" 
 			statement = new ExpressionStatement(expr); 
 		} else if (la.kind == 211) {
 			lexer.NextToken();
 
-#line  3074 "VBNET.ATG" 
+#line  3069 "VBNET.ATG" 
 			Statement block;  
 			if (
-#line  3075 "VBNET.ATG" 
+#line  3070 "VBNET.ATG" 
 Peek(1).kind == Tokens.As) {
 
-#line  3076 "VBNET.ATG" 
+#line  3071 "VBNET.ATG" 
 				LocalVariableDeclaration resourceAquisition = new LocalVariableDeclaration(Modifiers.None); 
 				VariableDeclarator(
-#line  3077 "VBNET.ATG" 
+#line  3072 "VBNET.ATG" 
 resourceAquisition.Variables);
 				while (la.kind == 12) {
 					lexer.NextToken();
 					VariableDeclarator(
-#line  3079 "VBNET.ATG" 
+#line  3074 "VBNET.ATG" 
 resourceAquisition.Variables);
 				}
 				Block(
-#line  3081 "VBNET.ATG" 
+#line  3076 "VBNET.ATG" 
 out block);
 
-#line  3083 "VBNET.ATG" 
+#line  3078 "VBNET.ATG" 
 				statement = new UsingStatement(resourceAquisition, block);
 				
 			} else if (StartOf(24)) {
 				Expr(
-#line  3085 "VBNET.ATG" 
+#line  3080 "VBNET.ATG" 
 out expr);
 				Block(
-#line  3086 "VBNET.ATG" 
+#line  3081 "VBNET.ATG" 
 out block);
 
-#line  3087 "VBNET.ATG" 
+#line  3082 "VBNET.ATG" 
 				statement = new UsingStatement(new ExpressionStatement(expr), block); 
 			} else SynErr(279);
 			Expect(100);
 			Expect(211);
 		} else if (StartOf(41)) {
 			LocalDeclarationStatement(
-#line  3090 "VBNET.ATG" 
+#line  3085 "VBNET.ATG" 
 out statement);
 		} else SynErr(280);
 	}
 
 	void LocalDeclarationStatement(
-#line  2770 "VBNET.ATG" 
+#line  2765 "VBNET.ATG" 
 out Statement statement) {
 
-#line  2772 "VBNET.ATG" 
+#line  2767 "VBNET.ATG" 
 		ModifierList m = new ModifierList();
 		LocalVariableDeclaration localVariableDeclaration;
 		bool dimfound = false;
@@ -6599,22 +6593,22 @@ out Statement statement) {
 			if (la.kind == 75) {
 				lexer.NextToken();
 
-#line  2778 "VBNET.ATG" 
+#line  2773 "VBNET.ATG" 
 				m.Add(Modifiers.Const, t.Location); 
 			} else if (la.kind == 189) {
 				lexer.NextToken();
 
-#line  2779 "VBNET.ATG" 
+#line  2774 "VBNET.ATG" 
 				m.Add(Modifiers.Static, t.Location); 
 			} else {
 				lexer.NextToken();
 
-#line  2780 "VBNET.ATG" 
+#line  2775 "VBNET.ATG" 
 				dimfound = true; 
 			}
 		}
 
-#line  2783 "VBNET.ATG" 
+#line  2778 "VBNET.ATG" 
 		if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
 		Error("Dim is not allowed on constants.");
 		}
@@ -6627,135 +6621,135 @@ out Statement statement) {
 		localVariableDeclaration.StartLocation = t.Location;
 		
 		VariableDeclarator(
-#line  2794 "VBNET.ATG" 
+#line  2789 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		while (la.kind == 12) {
 			lexer.NextToken();
 			VariableDeclarator(
-#line  2795 "VBNET.ATG" 
+#line  2790 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		}
 
-#line  2797 "VBNET.ATG" 
+#line  2792 "VBNET.ATG" 
 		statement = localVariableDeclaration;
 		
 	}
 
 	void TryStatement(
-#line  3291 "VBNET.ATG" 
+#line  3286 "VBNET.ATG" 
 out Statement tryStatement) {
 
-#line  3293 "VBNET.ATG" 
+#line  3288 "VBNET.ATG" 
 		Statement blockStmt = null, finallyStmt = null;List<CatchClause> catchClauses = null;
 		
 		Expect(203);
 		EndOfStmt();
 		Block(
-#line  3296 "VBNET.ATG" 
+#line  3291 "VBNET.ATG" 
 out blockStmt);
 		if (la.kind == 62 || la.kind == 100 || la.kind == 110) {
 			CatchClauses(
-#line  3297 "VBNET.ATG" 
+#line  3292 "VBNET.ATG" 
 out catchClauses);
 		}
 		if (la.kind == 110) {
 			lexer.NextToken();
 			EndOfStmt();
 			Block(
-#line  3298 "VBNET.ATG" 
+#line  3293 "VBNET.ATG" 
 out finallyStmt);
 		}
 		Expect(100);
 		Expect(203);
 
-#line  3301 "VBNET.ATG" 
+#line  3296 "VBNET.ATG" 
 		tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
 		
 	}
 
 	void WithStatement(
-#line  3271 "VBNET.ATG" 
+#line  3266 "VBNET.ATG" 
 out Statement withStatement) {
 
-#line  3273 "VBNET.ATG" 
+#line  3268 "VBNET.ATG" 
 		Statement blockStmt = null;
 		Expression expr = null;
 		
 		Expect(218);
 
-#line  3276 "VBNET.ATG" 
+#line  3271 "VBNET.ATG" 
 		Location start = t.Location; 
 		Expr(
-#line  3277 "VBNET.ATG" 
+#line  3272 "VBNET.ATG" 
 out expr);
 		EndOfStmt();
 
-#line  3279 "VBNET.ATG" 
+#line  3274 "VBNET.ATG" 
 		withStatement = new WithStatement(expr);
 		withStatement.StartLocation = start;
 		
 		Block(
-#line  3282 "VBNET.ATG" 
+#line  3277 "VBNET.ATG" 
 out blockStmt);
 
-#line  3284 "VBNET.ATG" 
+#line  3279 "VBNET.ATG" 
 		((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
 		
 		Expect(100);
 		Expect(218);
 
-#line  3287 "VBNET.ATG" 
+#line  3282 "VBNET.ATG" 
 		withStatement.EndLocation = t.Location; 
 	}
 
 	void WhileOrUntil(
-#line  3264 "VBNET.ATG" 
+#line  3259 "VBNET.ATG" 
 out ConditionType conditionType) {
 
-#line  3265 "VBNET.ATG" 
+#line  3260 "VBNET.ATG" 
 		conditionType = ConditionType.None; 
 		if (la.kind == 216) {
 			lexer.NextToken();
 
-#line  3266 "VBNET.ATG" 
+#line  3261 "VBNET.ATG" 
 			conditionType = ConditionType.While; 
 		} else if (la.kind == 209) {
 			lexer.NextToken();
 
-#line  3267 "VBNET.ATG" 
+#line  3262 "VBNET.ATG" 
 			conditionType = ConditionType.Until; 
 		} else SynErr(281);
 	}
 
 	void LoopControlVariable(
-#line  3107 "VBNET.ATG" 
+#line  3102 "VBNET.ATG" 
 out TypeReference type, out string name) {
 
-#line  3108 "VBNET.ATG" 
+#line  3103 "VBNET.ATG" 
 		ArrayList arrayModifiers = null;
 		type = null;
 		
 		Qualident(
-#line  3112 "VBNET.ATG" 
+#line  3107 "VBNET.ATG" 
 out name);
 		if (
-#line  3113 "VBNET.ATG" 
+#line  3108 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  3113 "VBNET.ATG" 
+#line  3108 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 50) {
 			lexer.NextToken();
 			TypeName(
-#line  3114 "VBNET.ATG" 
+#line  3109 "VBNET.ATG" 
 out type);
 
-#line  3114 "VBNET.ATG" 
+#line  3109 "VBNET.ATG" 
 			if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } 
 		}
 
-#line  3116 "VBNET.ATG" 
+#line  3111 "VBNET.ATG" 
 		if (type != null) {
 		if(type.RankSpecifier != null && arrayModifiers != null) {
 			Error("array rank only allowed one time");
@@ -6767,34 +6761,34 @@ out type);
 	}
 
 	void ReDimClause(
-#line  3186 "VBNET.ATG" 
+#line  3181 "VBNET.ATG" 
 out Expression expr) {
 		SimpleNonInvocationExpression(
-#line  3188 "VBNET.ATG" 
+#line  3183 "VBNET.ATG" 
 out expr);
 		ReDimClauseInternal(
-#line  3189 "VBNET.ATG" 
+#line  3184 "VBNET.ATG" 
 ref expr);
 	}
 
 	void SingleLineStatementList(
-#line  3093 "VBNET.ATG" 
+#line  3088 "VBNET.ATG" 
 List<Statement> list) {
 
-#line  3094 "VBNET.ATG" 
+#line  3089 "VBNET.ATG" 
 		Statement embeddedStatement = null; 
 		if (la.kind == 100) {
 			lexer.NextToken();
 
-#line  3096 "VBNET.ATG" 
+#line  3091 "VBNET.ATG" 
 			embeddedStatement = new EndStatement(); 
 		} else if (StartOf(36)) {
 			EmbeddedStatement(
-#line  3097 "VBNET.ATG" 
+#line  3092 "VBNET.ATG" 
 out embeddedStatement);
 		} else SynErr(282);
 
-#line  3098 "VBNET.ATG" 
+#line  3093 "VBNET.ATG" 
 		if (embeddedStatement != null) list.Add(embeddedStatement); 
 		while (la.kind == 11) {
 			lexer.NextToken();
@@ -6804,62 +6798,62 @@ out embeddedStatement);
 			if (la.kind == 100) {
 				lexer.NextToken();
 
-#line  3100 "VBNET.ATG" 
+#line  3095 "VBNET.ATG" 
 				embeddedStatement = new EndStatement(); 
 			} else if (StartOf(36)) {
 				EmbeddedStatement(
-#line  3101 "VBNET.ATG" 
+#line  3096 "VBNET.ATG" 
 out embeddedStatement);
 			} else SynErr(283);
 
-#line  3102 "VBNET.ATG" 
+#line  3097 "VBNET.ATG" 
 			if (embeddedStatement != null) list.Add(embeddedStatement); 
 		}
 	}
 
 	void CaseClauses(
-#line  3224 "VBNET.ATG" 
+#line  3219 "VBNET.ATG" 
 out List<CaseLabel> caseClauses) {
 
-#line  3226 "VBNET.ATG" 
+#line  3221 "VBNET.ATG" 
 		caseClauses = new List<CaseLabel>();
 		CaseLabel caseClause = null;
 		
 		CaseClause(
-#line  3229 "VBNET.ATG" 
+#line  3224 "VBNET.ATG" 
 out caseClause);
 
-#line  3229 "VBNET.ATG" 
+#line  3224 "VBNET.ATG" 
 		if (caseClause != null) { caseClauses.Add(caseClause); } 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			CaseClause(
-#line  3230 "VBNET.ATG" 
+#line  3225 "VBNET.ATG" 
 out caseClause);
 
-#line  3230 "VBNET.ATG" 
+#line  3225 "VBNET.ATG" 
 			if (caseClause != null) { caseClauses.Add(caseClause); } 
 		}
 	}
 
 	void OnErrorStatement(
-#line  3127 "VBNET.ATG" 
+#line  3122 "VBNET.ATG" 
 out OnErrorStatement stmt) {
 
-#line  3129 "VBNET.ATG" 
+#line  3124 "VBNET.ATG" 
 		stmt = null;
 		GotoStatement goToStatement = null;
 		
 		Expect(157);
 		Expect(105);
 		if (
-#line  3135 "VBNET.ATG" 
+#line  3130 "VBNET.ATG" 
 IsNegativeLabelName()) {
 			Expect(119);
 			Expect(18);
 			Expect(5);
 
-#line  3137 "VBNET.ATG" 
+#line  3132 "VBNET.ATG" 
 			long intLabel = Int64.Parse(t.val);
 			if(intLabel != 1) {
 				Error("invalid label in on error statement.");
@@ -6868,10 +6862,10 @@ IsNegativeLabelName()) {
 			
 		} else if (la.kind == 119) {
 			GotoStatement(
-#line  3143 "VBNET.ATG" 
+#line  3138 "VBNET.ATG" 
 out goToStatement);
 
-#line  3145 "VBNET.ATG" 
+#line  3140 "VBNET.ATG" 
 			string val = goToStatement.Label;
 			
 			// if value is numeric, make sure that is 0
@@ -6888,88 +6882,88 @@ out goToStatement);
 			lexer.NextToken();
 			Expect(149);
 
-#line  3159 "VBNET.ATG" 
+#line  3154 "VBNET.ATG" 
 			stmt = new OnErrorStatement(new ResumeStatement(true));
 			
 		} else SynErr(284);
 	}
 
 	void GotoStatement(
-#line  3165 "VBNET.ATG" 
+#line  3160 "VBNET.ATG" 
 out GotoStatement goToStatement) {
 
-#line  3167 "VBNET.ATG" 
+#line  3162 "VBNET.ATG" 
 		string label = String.Empty;
 		
 		Expect(119);
 		LabelName(
-#line  3170 "VBNET.ATG" 
+#line  3165 "VBNET.ATG" 
 out label);
 
-#line  3172 "VBNET.ATG" 
+#line  3167 "VBNET.ATG" 
 		goToStatement = new GotoStatement(label);
 		
 	}
 
 	void ResumeStatement(
-#line  3213 "VBNET.ATG" 
+#line  3208 "VBNET.ATG" 
 out ResumeStatement resumeStatement) {
 
-#line  3215 "VBNET.ATG" 
+#line  3210 "VBNET.ATG" 
 		resumeStatement = null;
 		string label = String.Empty;
 		
 		if (
-#line  3218 "VBNET.ATG" 
+#line  3213 "VBNET.ATG" 
 IsResumeNext()) {
 			Expect(179);
 			Expect(149);
 
-#line  3219 "VBNET.ATG" 
+#line  3214 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(true); 
 		} else if (la.kind == 179) {
 			lexer.NextToken();
 			if (StartOf(42)) {
 				LabelName(
-#line  3220 "VBNET.ATG" 
+#line  3215 "VBNET.ATG" 
 out label);
 			}
 
-#line  3220 "VBNET.ATG" 
+#line  3215 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(label); 
 		} else SynErr(285);
 	}
 
 	void ReDimClauseInternal(
-#line  3192 "VBNET.ATG" 
+#line  3187 "VBNET.ATG" 
 ref Expression expr) {
 
-#line  3193 "VBNET.ATG" 
+#line  3188 "VBNET.ATG" 
 		List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; 
 		while (la.kind == 16 || 
-#line  3196 "VBNET.ATG" 
+#line  3191 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			if (la.kind == 16) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  3195 "VBNET.ATG" 
+#line  3190 "VBNET.ATG" 
 out name);
 
-#line  3195 "VBNET.ATG" 
+#line  3190 "VBNET.ATG" 
 				expr = new MemberReferenceExpression(expr, name); 
 			} else {
 				InvocationExpression(
-#line  3197 "VBNET.ATG" 
+#line  3192 "VBNET.ATG" 
 ref expr);
 			}
 		}
 		Expect(25);
 		NormalOrReDimArgumentList(
-#line  3200 "VBNET.ATG" 
+#line  3195 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeRedim);
 		Expect(26);
 
-#line  3202 "VBNET.ATG" 
+#line  3197 "VBNET.ATG" 
 		expr = new InvocationExpression(expr, arguments);
 		if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
 			if (this.Errors.Count == 0) {
@@ -6981,10 +6975,10 @@ out arguments, out canBeNormal, out canBeRedim);
 	}
 
 	void CaseClause(
-#line  3234 "VBNET.ATG" 
+#line  3229 "VBNET.ATG" 
 out CaseLabel caseClause) {
 
-#line  3236 "VBNET.ATG" 
+#line  3231 "VBNET.ATG" 
 		Expression expr = null;
 		Expression sexpr = null;
 		BinaryOperatorType op = BinaryOperatorType.None;
@@ -6993,7 +6987,7 @@ out CaseLabel caseClause) {
 		if (la.kind == 98) {
 			lexer.NextToken();
 
-#line  3242 "VBNET.ATG" 
+#line  3237 "VBNET.ATG" 
 			caseClause = new CaseLabel(); 
 		} else if (StartOf(43)) {
 			if (la.kind == 131) {
@@ -7003,76 +6997,76 @@ out CaseLabel caseClause) {
 			case 28: {
 				lexer.NextToken();
 
-#line  3246 "VBNET.ATG" 
+#line  3241 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 27: {
 				lexer.NextToken();
 
-#line  3247 "VBNET.ATG" 
+#line  3242 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 31: {
 				lexer.NextToken();
 
-#line  3248 "VBNET.ATG" 
+#line  3243 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 30: {
 				lexer.NextToken();
 
-#line  3249 "VBNET.ATG" 
+#line  3244 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 10: {
 				lexer.NextToken();
 
-#line  3250 "VBNET.ATG" 
+#line  3245 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 29: {
 				lexer.NextToken();
 
-#line  3251 "VBNET.ATG" 
+#line  3246 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			default: SynErr(286); break;
 			}
 			Expr(
-#line  3253 "VBNET.ATG" 
+#line  3248 "VBNET.ATG" 
 out expr);
 
-#line  3255 "VBNET.ATG" 
+#line  3250 "VBNET.ATG" 
 			caseClause = new CaseLabel(op, expr);
 			
 		} else if (StartOf(24)) {
 			Expr(
-#line  3257 "VBNET.ATG" 
+#line  3252 "VBNET.ATG" 
 out expr);
 			if (la.kind == 201) {
 				lexer.NextToken();
 				Expr(
-#line  3257 "VBNET.ATG" 
+#line  3252 "VBNET.ATG" 
 out sexpr);
 			}
 
-#line  3259 "VBNET.ATG" 
+#line  3254 "VBNET.ATG" 
 			caseClause = new CaseLabel(expr, sexpr);
 			
 		} else SynErr(287);
 	}
 
 	void CatchClauses(
-#line  3306 "VBNET.ATG" 
+#line  3301 "VBNET.ATG" 
 out List<CatchClause> catchClauses) {
 
-#line  3308 "VBNET.ATG" 
+#line  3303 "VBNET.ATG" 
 		catchClauses = new List<CatchClause>();
 		TypeReference type = null;
 		Statement blockStmt = null;
@@ -7084,27 +7078,27 @@ out List<CatchClause> catchClauses) {
 			if (StartOf(14)) {
 				Identifier();
 
-#line  3316 "VBNET.ATG" 
+#line  3311 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 50) {
 					lexer.NextToken();
 					TypeName(
-#line  3316 "VBNET.ATG" 
+#line  3311 "VBNET.ATG" 
 out type);
 				}
 			}
 			if (la.kind == 214) {
 				lexer.NextToken();
 				Expr(
-#line  3317 "VBNET.ATG" 
+#line  3312 "VBNET.ATG" 
 out expr);
 			}
 			EndOfStmt();
 			Block(
-#line  3319 "VBNET.ATG" 
+#line  3314 "VBNET.ATG" 
 out blockStmt);
 
-#line  3320 "VBNET.ATG" 
+#line  3315 "VBNET.ATG" 
 			catchClauses.Add(new CatchClause(type, name, blockStmt, expr)); 
 		}
 	}
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
index 6947aa5b23..13666fd09e 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
@@ -1094,11 +1094,6 @@ StructureMemberDecl<ModifierList m, List<AttributeSection> attributes>
 			TypeName<out type>
 		)
 	]
-	(.
-		if(type == null) {
-			type = new TypeReference("System.Object", true);
-		}
-	.)
 	[ "=" VariableInitializer<out initializer> ]
 	[ ImplementsClause<out implementsClause> ]
 	EndOfStmt
diff --git a/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs b/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
index 12c7a42b76..d3b47cf85a 100644
--- a/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
+++ b/src/Libraries/NRefactory/Project/Src/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
@@ -571,17 +571,34 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
 			outputFormatter.PrintToken(Tokens.OpenParenthesis);
 			AppendCommaSeparatedList(propertyDeclaration.Parameters);
 			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.As);
-			outputFormatter.Space();
-			VisitReturnTypeAttributes(propertyDeclaration.Attributes, data);
-			TrackedVisit(propertyDeclaration.TypeReference, data);
+			
+			if (!propertyDeclaration.TypeReference.IsNull) {
+				outputFormatter.Space();
+				outputFormatter.PrintToken(Tokens.As);
+				outputFormatter.Space();
+				
+				VisitReturnTypeAttributes(propertyDeclaration.Attributes, data);
+				
+				ObjectCreateExpression init = propertyDeclaration.Initializer as ObjectCreateExpression;
+				if (init != null && TypeReference.AreEqualReferences(init.CreateType, propertyDeclaration.TypeReference)) {
+					TrackedVisit(propertyDeclaration.Initializer, data);
+				} else {
+					TrackedVisit(propertyDeclaration.TypeReference, data);
+				}
+			}
 			
 			PrintInterfaceImplementations(propertyDeclaration.InterfaceImplementations);
 			
+			if (!propertyDeclaration.Initializer.IsNull && !(propertyDeclaration.Initializer is ObjectCreateExpression)) {
+				outputFormatter.Space();
+				outputFormatter.PrintToken(Tokens.Assign);
+				outputFormatter.Space();
+				TrackedVisit(propertyDeclaration.Initializer, data);
+			}
+			
 			outputFormatter.NewLine();
 			
-			if (!IsAbstract(propertyDeclaration)) {
+			if (!IsAbstract(propertyDeclaration) && (propertyDeclaration.GetRegion.Block != NullBlockStatement.Instance  || propertyDeclaration.SetRegion.Block != NullBlockStatement.Instance)) {
 				outputFormatter.IsInMemberBody = true;
 				++outputFormatter.IndentationLevel;
 				exitTokenStack.Push(Tokens.Property);
diff --git a/src/Libraries/NRefactory/Project/Src/Visitors/ToCSharpConvertVisitor.cs b/src/Libraries/NRefactory/Project/Src/Visitors/ToCSharpConvertVisitor.cs
index 2d291a5879..0f01b63d0e 100644
--- a/src/Libraries/NRefactory/Project/Src/Visitors/ToCSharpConvertVisitor.cs
+++ b/src/Libraries/NRefactory/Project/Src/Visitors/ToCSharpConvertVisitor.cs
@@ -26,6 +26,7 @@ namespace ICSharpCode.NRefactory.Visitors
 		//      or convert to implicit interface implementation
 		//   Modules: make all members static
 		//   Use Convert.ToInt32 for VB casts
+		//   Add System.Object-TypeReference to properties without TypeReference
 		
 		public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
 		{
@@ -104,6 +105,10 @@ namespace ICSharpCode.NRefactory.Visitors
 		public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
 		{
 			ConvertInterfaceImplementation(propertyDeclaration);
+			
+			if (propertyDeclaration.TypeReference.IsNull)
+				propertyDeclaration.TypeReference = new TypeReference("object", true);
+			
 			return base.VisitPropertyDeclaration(propertyDeclaration, data);
 		}
 		
diff --git a/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs b/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs
index b2f9dea708..9ba8975b40 100644
--- a/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs
+++ b/src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs
@@ -286,6 +286,15 @@ End Using");
 			               "End Property");
 		}
 		
+		[Test]
+		public void AutoProperty()
+		{
+			TestTypeMember("Public Property Value()");
+			TestTypeMember("Public Property Value() As Integer");
+			TestTypeMember("Public Property Value() As Integer = 5");
+			TestTypeMember("Public Property Value() As New List()");
+		}
+		
 		[Test]
 		public void AbstractProperty()
 		{
diff --git a/src/Libraries/NRefactory/Test/Parser/TypeLevel/PropertyDeclarationTests.cs b/src/Libraries/NRefactory/Test/Parser/TypeLevel/PropertyDeclarationTests.cs
index afd089fa92..3be1f6ce5b 100644
--- a/src/Libraries/NRefactory/Test/Parser/TypeLevel/PropertyDeclarationTests.cs
+++ b/src/Libraries/NRefactory/Test/Parser/TypeLevel/PropertyDeclarationTests.cs
@@ -122,7 +122,6 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		{
 			PropertyDeclaration pd = ParseUtilVBNet.ParseTypeMember<PropertyDeclaration>("ReadOnly Property MyProperty \nGet\nEnd Get\nEnd Property");
 			Assert.AreEqual("MyProperty", pd.Name);
-			Assert.AreEqual("System.Object", pd.TypeReference.Type);
 			Assert.IsTrue(pd.HasGetRegion);
 			Assert.IsFalse(pd.HasSetRegion);
 			Assert.IsTrue((pd.Modifier & Modifiers.ReadOnly) == Modifiers.ReadOnly);
@@ -133,7 +132,6 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		{
 			PropertyDeclaration pd = ParseUtilVBNet.ParseTypeMember<PropertyDeclaration>("WriteOnly Property MyProperty \n Set\nEnd Set\nEnd Property ");
 			Assert.AreEqual("MyProperty", pd.Name);
-			Assert.AreEqual("System.Object", pd.TypeReference.Type);
 			Assert.IsFalse(pd.HasGetRegion);
 			Assert.IsTrue(pd.HasSetRegion);
 			Assert.IsTrue((pd.Modifier & Modifiers.WriteOnly) == Modifiers.WriteOnly);
@@ -144,7 +142,6 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		{
 			PropertyDeclaration pd = ParseUtilVBNet.ParseTypeMember<PropertyDeclaration>("Property MyProperty");
 			Assert.AreEqual("MyProperty", pd.Name);
-			Assert.AreEqual("System.Object", pd.TypeReference.Type);
 			Assert.IsTrue(pd.HasGetRegion);
 			Assert.IsTrue(pd.HasSetRegion);
 			Assert.AreEqual(pd.Initializer, Expression.Null);
@@ -155,7 +152,6 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		{
 			PropertyDeclaration pd = ParseUtilVBNet.ParseTypeMember<PropertyDeclaration>("ReadOnly Property MyProperty");
 			Assert.AreEqual("MyProperty", pd.Name);
-			Assert.AreEqual("System.Object", pd.TypeReference.Type);
 			Assert.IsTrue(pd.HasGetRegion);
 			Assert.IsFalse(pd.HasSetRegion);
 			Assert.AreEqual(pd.Initializer, Expression.Null);
@@ -166,7 +162,6 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		{
 			PropertyDeclaration pd = ParseUtilVBNet.ParseTypeMember<PropertyDeclaration>("WriteOnly Property MyProperty");
 			Assert.AreEqual("MyProperty", pd.Name);
-			Assert.AreEqual("System.Object", pd.TypeReference.Type);
 			Assert.IsFalse(pd.HasGetRegion);
 			Assert.IsTrue(pd.HasSetRegion);
 			Assert.AreEqual(pd.Initializer, Expression.Null);
@@ -177,7 +172,6 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		{
 			PropertyDeclaration pd = ParseUtilVBNet.ParseTypeMember<PropertyDeclaration>("Property MyProperty = 5");
 			Assert.AreEqual("MyProperty", pd.Name);
-			Assert.AreEqual("System.Object", pd.TypeReference.Type);
 			Assert.IsTrue(pd.HasGetRegion);
 			Assert.IsTrue(pd.HasSetRegion);
 			Assert.AreEqual(pd.Initializer.ToString(), new PrimitiveExpression(5).ToString());