diff --git a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
index c7fd8483a6..6ae4eef1ba 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
@@ -966,26 +966,26 @@ templates);
 	}
 
 	void TypeParameterList(
-#line  2355 "cs.ATG" 
+#line  2360 "cs.ATG" 
 List<TemplateDefinition> templates) {
 
-#line  2357 "cs.ATG" 
+#line  2362 "cs.ATG" 
 		TemplateDefinition template;
 		
 		Expect(23);
 		VariantTypeParameter(
-#line  2361 "cs.ATG" 
+#line  2366 "cs.ATG" 
 out template);
 
-#line  2361 "cs.ATG" 
+#line  2366 "cs.ATG" 
 		templates.Add(template); 
 		while (la.kind == 14) {
 			lexer.NextToken();
 			VariantTypeParameter(
-#line  2363 "cs.ATG" 
+#line  2368 "cs.ATG" 
 out template);
 
-#line  2363 "cs.ATG" 
+#line  2368 "cs.ATG" 
 			templates.Add(template); 
 		}
 		Expect(22);
@@ -1018,22 +1018,22 @@ out typeRef, false);
 	}
 
 	void TypeParameterConstraintsClause(
-#line  2383 "cs.ATG" 
+#line  2388 "cs.ATG" 
 List<TemplateDefinition> templates) {
 
-#line  2384 "cs.ATG" 
+#line  2389 "cs.ATG" 
 		string name = ""; TypeReference type; 
 		Expect(127);
 		Identifier();
 
-#line  2387 "cs.ATG" 
+#line  2392 "cs.ATG" 
 		name = t.val; 
 		Expect(9);
 		TypeParameterConstraintsClauseBase(
-#line  2389 "cs.ATG" 
+#line  2394 "cs.ATG" 
 out type);
 
-#line  2390 "cs.ATG" 
+#line  2395 "cs.ATG" 
 		TemplateDefinition td = null;
 		foreach (TemplateDefinition d in templates) {
 			if (d.Name == name) {
@@ -1046,10 +1046,10 @@ out type);
 		while (la.kind == 14) {
 			lexer.NextToken();
 			TypeParameterConstraintsClauseBase(
-#line  2399 "cs.ATG" 
+#line  2404 "cs.ATG" 
 out type);
 
-#line  2400 "cs.ATG" 
+#line  2405 "cs.ATG" 
 			td = null;
 			foreach (TemplateDefinition d in templates) {
 				if (d.Name == name) {
@@ -1366,34 +1366,34 @@ out r, canBeUnbound);
 	}
 
 	void TypeName(
-#line  2296 "cs.ATG" 
+#line  2301 "cs.ATG" 
 out TypeReference typeRef, bool canBeUnbound) {
 
-#line  2297 "cs.ATG" 
+#line  2302 "cs.ATG" 
 		List<TypeReference> typeArguments = null;
 		string alias = null;
 		string qualident;
 		Location startLocation = la.Location;
 		
 		if (
-#line  2303 "cs.ATG" 
+#line  2308 "cs.ATG" 
 IdentAndDoubleColon()) {
 			Identifier();
 
-#line  2304 "cs.ATG" 
+#line  2309 "cs.ATG" 
 			alias = t.val; 
 			Expect(10);
 		}
 		Qualident(
-#line  2307 "cs.ATG" 
+#line  2312 "cs.ATG" 
 out qualident);
 		if (la.kind == 23) {
 			TypeArgumentList(
-#line  2308 "cs.ATG" 
+#line  2313 "cs.ATG" 
 out typeArguments, canBeUnbound);
 		}
 
-#line  2310 "cs.ATG" 
+#line  2315 "cs.ATG" 
 		if (alias == null) {
 		typeRef = new TypeReference(qualident, typeArguments);
 		} else if (alias == "global") {
@@ -1404,26 +1404,26 @@ out typeArguments, canBeUnbound);
 		}
 		
 		while (
-#line  2319 "cs.ATG" 
+#line  2324 "cs.ATG" 
 DotAndIdent()) {
 			Expect(15);
 
-#line  2320 "cs.ATG" 
+#line  2325 "cs.ATG" 
 			typeArguments = null; 
 			Qualident(
-#line  2321 "cs.ATG" 
+#line  2326 "cs.ATG" 
 out qualident);
 			if (la.kind == 23) {
 				TypeArgumentList(
-#line  2322 "cs.ATG" 
+#line  2327 "cs.ATG" 
 out typeArguments, canBeUnbound);
 			}
 
-#line  2323 "cs.ATG" 
+#line  2328 "cs.ATG" 
 			typeRef = new InnerClassTypeReference(typeRef, qualident, typeArguments); 
 		}
 
-#line  2325 "cs.ATG" 
+#line  2330 "cs.ATG" 
 		typeRef.StartLocation = startLocation; 
 	}
 
@@ -2561,14 +2561,14 @@ out name);
 	}
 
 	void NullableQuestionMark(
-#line  2329 "cs.ATG" 
+#line  2334 "cs.ATG" 
 ref TypeReference typeRef) {
 
-#line  2330 "cs.ATG" 
+#line  2335 "cs.ATG" 
 		List<TypeReference> typeArguments = new List<TypeReference>(1); 
 		Expect(12);
 
-#line  2334 "cs.ATG" 
+#line  2339 "cs.ATG" 
 		if (typeRef != null) typeArguments.Add(typeRef);
 		typeRef = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
 		
@@ -4314,7 +4314,7 @@ out expr);
 ref Expression outExpr) {
 
 #line  2168 "cs.ATG" 
-		Expression expr;   
+		Expression expr; Location startLocation = la.Location; 
 		ConditionalAndExpr(
 #line  2170 "cs.ATG" 
 ref outExpr);
@@ -4328,7 +4328,7 @@ out expr);
 ref expr);
 
 #line  2170 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr);  
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
@@ -4734,24 +4734,24 @@ out expr);
 	}
 
 	void QueryExpression(
-#line  2420 "cs.ATG" 
+#line  2425 "cs.ATG" 
 out Expression outExpr) {
 
-#line  2421 "cs.ATG" 
+#line  2426 "cs.ATG" 
 		QueryExpression q = new QueryExpression(); outExpr = q; q.StartLocation = la.Location; 
 		QueryExpressionFromClause fromClause;
 		
 		QueryExpressionFromClause(
-#line  2425 "cs.ATG" 
+#line  2430 "cs.ATG" 
 out fromClause);
 
-#line  2425 "cs.ATG" 
+#line  2430 "cs.ATG" 
 		q.FromClause = fromClause; 
 		QueryExpressionBody(
-#line  2426 "cs.ATG" 
+#line  2431 "cs.ATG" 
 ref q);
 
-#line  2427 "cs.ATG" 
+#line  2432 "cs.ATG" 
 		q.EndLocation = t.EndLocation; 
 		outExpr = q; /* set outExpr to q again if QueryExpressionBody changed it (can happen with 'into' clauses) */ 
 		
@@ -4777,40 +4777,40 @@ lambda);
 	}
 
 	void TypeArgumentList(
-#line  2339 "cs.ATG" 
+#line  2344 "cs.ATG" 
 out List<TypeReference> types, bool canBeUnbound) {
 
-#line  2341 "cs.ATG" 
+#line  2346 "cs.ATG" 
 		types = new List<TypeReference>();
 		TypeReference type = null;
 		
 		Expect(23);
 		if (
-#line  2346 "cs.ATG" 
+#line  2351 "cs.ATG" 
 canBeUnbound && (la.kind == Tokens.GreaterThan || la.kind == Tokens.Comma)) {
 
-#line  2347 "cs.ATG" 
+#line  2352 "cs.ATG" 
 			types.Add(TypeReference.Null); 
 			while (la.kind == 14) {
 				lexer.NextToken();
 
-#line  2348 "cs.ATG" 
+#line  2353 "cs.ATG" 
 				types.Add(TypeReference.Null); 
 			}
 		} else if (StartOf(10)) {
 			Type(
-#line  2349 "cs.ATG" 
+#line  2354 "cs.ATG" 
 out type);
 
-#line  2349 "cs.ATG" 
+#line  2354 "cs.ATG" 
 			if (type != null) { types.Add(type); } 
 			while (la.kind == 14) {
 				lexer.NextToken();
 				Type(
-#line  2350 "cs.ATG" 
+#line  2355 "cs.ATG" 
 out type);
 
-#line  2350 "cs.ATG" 
+#line  2355 "cs.ATG" 
 				if (type != null) { types.Add(type); } 
 			}
 		} else SynErr(208);
@@ -5187,7 +5187,7 @@ out expr);
 ref Expression outExpr) {
 
 #line  2174 "cs.ATG" 
-		Expression expr; 
+		Expression expr; Location startLocation = la.Location; 
 		InclusiveOrExpr(
 #line  2176 "cs.ATG" 
 ref outExpr);
@@ -5201,7 +5201,7 @@ out expr);
 ref expr);
 
 #line  2176 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr);  
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
@@ -5210,7 +5210,7 @@ ref expr);
 ref Expression outExpr) {
 
 #line  2180 "cs.ATG" 
-		Expression expr; 
+		Expression expr; Location startLocation = la.Location; 
 		ExclusiveOrExpr(
 #line  2182 "cs.ATG" 
 ref outExpr);
@@ -5224,7 +5224,7 @@ out expr);
 ref expr);
 
 #line  2182 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr);  
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
@@ -5233,7 +5233,7 @@ ref expr);
 ref Expression outExpr) {
 
 #line  2186 "cs.ATG" 
-		Expression expr; 
+		Expression expr; Location startLocation = la.Location; 
 		AndExpr(
 #line  2188 "cs.ATG" 
 ref outExpr);
@@ -5247,7 +5247,7 @@ out expr);
 ref expr);
 
 #line  2188 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr);  
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
@@ -5256,7 +5256,7 @@ ref expr);
 ref Expression outExpr) {
 
 #line  2192 "cs.ATG" 
-		Expression expr; 
+		Expression expr; Location startLocation = la.Location; 
 		EqualityExpr(
 #line  2194 "cs.ATG" 
 ref outExpr);
@@ -5270,7 +5270,7 @@ out expr);
 ref expr);
 
 #line  2194 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr);  
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
@@ -5281,317 +5281,322 @@ ref Expression outExpr) {
 #line  2199 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		RelationalExpr(
-#line  2203 "cs.ATG" 
+#line  2204 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 33 || la.kind == 34) {
 			if (la.kind == 34) {
 				lexer.NextToken();
 
-#line  2206 "cs.ATG" 
+#line  2207 "cs.ATG" 
 				op = BinaryOperatorType.InEquality; 
 			} else {
 				lexer.NextToken();
 
-#line  2207 "cs.ATG" 
+#line  2208 "cs.ATG" 
 				op = BinaryOperatorType.Equality; 
 			}
 			UnaryExpr(
-#line  2209 "cs.ATG" 
+#line  2210 "cs.ATG" 
 out expr);
 			RelationalExpr(
-#line  2209 "cs.ATG" 
+#line  2210 "cs.ATG" 
 ref expr);
 
-#line  2209 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  2210 "cs.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void RelationalExpr(
-#line  2213 "cs.ATG" 
+#line  2214 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  2215 "cs.ATG" 
+#line  2216 "cs.ATG" 
 		TypeReference type;
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		ShiftExpr(
-#line  2220 "cs.ATG" 
+#line  2222 "cs.ATG" 
 ref outExpr);
 		while (StartOf(37)) {
 			if (StartOf(38)) {
 				if (la.kind == 23) {
 					lexer.NextToken();
 
-#line  2222 "cs.ATG" 
+#line  2224 "cs.ATG" 
 					op = BinaryOperatorType.LessThan; 
 				} else if (la.kind == 22) {
 					lexer.NextToken();
 
-#line  2223 "cs.ATG" 
+#line  2225 "cs.ATG" 
 					op = BinaryOperatorType.GreaterThan; 
 				} else if (la.kind == 36) {
 					lexer.NextToken();
 
-#line  2224 "cs.ATG" 
+#line  2226 "cs.ATG" 
 					op = BinaryOperatorType.LessThanOrEqual; 
 				} else if (la.kind == 35) {
 					lexer.NextToken();
 
-#line  2225 "cs.ATG" 
+#line  2227 "cs.ATG" 
 					op = BinaryOperatorType.GreaterThanOrEqual; 
 				} else SynErr(213);
 				UnaryExpr(
-#line  2227 "cs.ATG" 
+#line  2229 "cs.ATG" 
 out expr);
 				ShiftExpr(
-#line  2228 "cs.ATG" 
+#line  2230 "cs.ATG" 
 ref expr);
 
-#line  2229 "cs.ATG" 
-				outExpr = new BinaryOperatorExpression(outExpr, op, expr); 
+#line  2231 "cs.ATG" 
+				outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 			} else {
 				if (la.kind == 85) {
 					lexer.NextToken();
 					TypeWithRestriction(
-#line  2232 "cs.ATG" 
+#line  2234 "cs.ATG" 
 out type, false, false);
 					if (
-#line  2233 "cs.ATG" 
+#line  2235 "cs.ATG" 
 la.kind == Tokens.Question && !IsPossibleExpressionStart(Peek(1).kind)) {
 						NullableQuestionMark(
-#line  2234 "cs.ATG" 
+#line  2236 "cs.ATG" 
 ref type);
 					}
 
-#line  2235 "cs.ATG" 
-					outExpr = new TypeOfIsExpression(outExpr, type); 
+#line  2237 "cs.ATG" 
+					outExpr = new TypeOfIsExpression(outExpr, type)  { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 				} else if (la.kind == 50) {
 					lexer.NextToken();
 					TypeWithRestriction(
-#line  2237 "cs.ATG" 
+#line  2239 "cs.ATG" 
 out type, false, false);
 					if (
-#line  2238 "cs.ATG" 
+#line  2240 "cs.ATG" 
 la.kind == Tokens.Question && !IsPossibleExpressionStart(Peek(1).kind)) {
 						NullableQuestionMark(
-#line  2239 "cs.ATG" 
+#line  2241 "cs.ATG" 
 ref type);
 					}
 
-#line  2240 "cs.ATG" 
-					outExpr = new CastExpression(type, outExpr, CastType.TryCast); 
+#line  2242 "cs.ATG" 
+					outExpr = new CastExpression(type, outExpr, CastType.TryCast) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 				} else SynErr(214);
 			}
 		}
 	}
 
 	void ShiftExpr(
-#line  2245 "cs.ATG" 
+#line  2247 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  2247 "cs.ATG" 
+#line  2249 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		AdditiveExpr(
-#line  2251 "cs.ATG" 
+#line  2254 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 37 || 
-#line  2254 "cs.ATG" 
+#line  2257 "cs.ATG" 
 IsShiftRight()) {
 			if (la.kind == 37) {
 				lexer.NextToken();
 
-#line  2253 "cs.ATG" 
+#line  2256 "cs.ATG" 
 				op = BinaryOperatorType.ShiftLeft; 
 			} else {
 				Expect(22);
 				Expect(22);
 
-#line  2255 "cs.ATG" 
+#line  2258 "cs.ATG" 
 				op = BinaryOperatorType.ShiftRight; 
 			}
 			UnaryExpr(
-#line  2258 "cs.ATG" 
+#line  2261 "cs.ATG" 
 out expr);
 			AdditiveExpr(
-#line  2258 "cs.ATG" 
+#line  2261 "cs.ATG" 
 ref expr);
 
-#line  2258 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  2261 "cs.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void AdditiveExpr(
-#line  2262 "cs.ATG" 
+#line  2265 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  2264 "cs.ATG" 
+#line  2267 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		MultiplicativeExpr(
-#line  2268 "cs.ATG" 
+#line  2272 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 4 || la.kind == 5) {
 			if (la.kind == 4) {
 				lexer.NextToken();
 
-#line  2271 "cs.ATG" 
+#line  2275 "cs.ATG" 
 				op = BinaryOperatorType.Add; 
 			} else {
 				lexer.NextToken();
 
-#line  2272 "cs.ATG" 
+#line  2276 "cs.ATG" 
 				op = BinaryOperatorType.Subtract; 
 			}
 			UnaryExpr(
-#line  2274 "cs.ATG" 
+#line  2278 "cs.ATG" 
 out expr);
 			MultiplicativeExpr(
-#line  2274 "cs.ATG" 
+#line  2278 "cs.ATG" 
 ref expr);
 
-#line  2274 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  2278 "cs.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void MultiplicativeExpr(
-#line  2278 "cs.ATG" 
+#line  2282 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  2280 "cs.ATG" 
+#line  2284 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		while (la.kind == 6 || la.kind == 7 || la.kind == 8) {
 			if (la.kind == 6) {
 				lexer.NextToken();
 
-#line  2286 "cs.ATG" 
+#line  2291 "cs.ATG" 
 				op = BinaryOperatorType.Multiply; 
 			} else if (la.kind == 7) {
 				lexer.NextToken();
 
-#line  2287 "cs.ATG" 
+#line  2292 "cs.ATG" 
 				op = BinaryOperatorType.Divide; 
 			} else {
 				lexer.NextToken();
 
-#line  2288 "cs.ATG" 
+#line  2293 "cs.ATG" 
 				op = BinaryOperatorType.Modulus; 
 			}
 			UnaryExpr(
-#line  2290 "cs.ATG" 
+#line  2295 "cs.ATG" 
 out expr);
 
-#line  2290 "cs.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr); 
+#line  2295 "cs.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 		}
 	}
 
 	void VariantTypeParameter(
-#line  2368 "cs.ATG" 
+#line  2373 "cs.ATG" 
 out TemplateDefinition typeParameter) {
 
-#line  2370 "cs.ATG" 
+#line  2375 "cs.ATG" 
 		typeParameter = new TemplateDefinition();
 		AttributeSection section;
 		
 		while (la.kind == 18) {
 			AttributeSection(
-#line  2374 "cs.ATG" 
+#line  2379 "cs.ATG" 
 out section);
 
-#line  2374 "cs.ATG" 
+#line  2379 "cs.ATG" 
 			typeParameter.Attributes.Add(section); 
 		}
 		if (la.kind == 81 || la.kind == 93) {
 			if (la.kind == 81) {
 				lexer.NextToken();
 
-#line  2376 "cs.ATG" 
+#line  2381 "cs.ATG" 
 				typeParameter.VarianceModifier = VarianceModifier.Contravariant; 
 			} else {
 				lexer.NextToken();
 
-#line  2377 "cs.ATG" 
+#line  2382 "cs.ATG" 
 				typeParameter.VarianceModifier = VarianceModifier.Covariant; 
 			}
 		}
 		Identifier();
 
-#line  2379 "cs.ATG" 
+#line  2384 "cs.ATG" 
 		typeParameter.Name = t.val; typeParameter.StartLocation = t.Location; 
 
-#line  2380 "cs.ATG" 
+#line  2385 "cs.ATG" 
 		typeParameter.EndLocation = t.EndLocation; 
 	}
 
 	void TypeParameterConstraintsClauseBase(
-#line  2411 "cs.ATG" 
+#line  2416 "cs.ATG" 
 out TypeReference type) {
 
-#line  2412 "cs.ATG" 
+#line  2417 "cs.ATG" 
 		TypeReference t; type = null; 
 		if (la.kind == 109) {
 			lexer.NextToken();
 
-#line  2414 "cs.ATG" 
+#line  2419 "cs.ATG" 
 			type = TypeReference.StructConstraint; 
 		} else if (la.kind == 59) {
 			lexer.NextToken();
 
-#line  2415 "cs.ATG" 
+#line  2420 "cs.ATG" 
 			type = TypeReference.ClassConstraint; 
 		} else if (la.kind == 89) {
 			lexer.NextToken();
 			Expect(20);
 			Expect(21);
 
-#line  2416 "cs.ATG" 
+#line  2421 "cs.ATG" 
 			type = TypeReference.NewConstraint; 
 		} else if (StartOf(10)) {
 			Type(
-#line  2417 "cs.ATG" 
+#line  2422 "cs.ATG" 
 out t);
 
-#line  2417 "cs.ATG" 
+#line  2422 "cs.ATG" 
 			type = t; 
 		} else SynErr(215);
 	}
 
 	void QueryExpressionFromClause(
-#line  2432 "cs.ATG" 
+#line  2437 "cs.ATG" 
 out QueryExpressionFromClause fc) {
 
-#line  2433 "cs.ATG" 
+#line  2438 "cs.ATG" 
 		fc = new QueryExpressionFromClause();
 		fc.StartLocation = la.Location;
 		CollectionRangeVariable variable;
 		
 		Expect(137);
 		QueryExpressionFromOrJoinClause(
-#line  2439 "cs.ATG" 
+#line  2444 "cs.ATG" 
 out variable);
 
-#line  2440 "cs.ATG" 
+#line  2445 "cs.ATG" 
 		fc.EndLocation = t.EndLocation;
 		fc.Sources.Add(variable);
 		
 	}
 
 	void QueryExpressionBody(
-#line  2476 "cs.ATG" 
+#line  2481 "cs.ATG" 
 ref QueryExpression q) {
 
-#line  2477 "cs.ATG" 
+#line  2482 "cs.ATG" 
 		QueryExpressionFromClause fromClause;     QueryExpressionWhereClause whereClause;
 		QueryExpressionLetClause letClause;       QueryExpressionJoinClause joinClause;
 		QueryExpressionOrderClause orderClause;
@@ -5600,252 +5605,252 @@ ref QueryExpression q) {
 		while (StartOf(39)) {
 			if (la.kind == 137) {
 				QueryExpressionFromClause(
-#line  2483 "cs.ATG" 
+#line  2488 "cs.ATG" 
 out fromClause);
 
-#line  2483 "cs.ATG" 
+#line  2488 "cs.ATG" 
 				SafeAdd<QueryExpressionClause>(q, q.MiddleClauses, fromClause); 
 			} else if (la.kind == 127) {
 				QueryExpressionWhereClause(
-#line  2484 "cs.ATG" 
+#line  2489 "cs.ATG" 
 out whereClause);
 
-#line  2484 "cs.ATG" 
+#line  2489 "cs.ATG" 
 				SafeAdd<QueryExpressionClause>(q, q.MiddleClauses, whereClause); 
 			} else if (la.kind == 141) {
 				QueryExpressionLetClause(
-#line  2485 "cs.ATG" 
+#line  2490 "cs.ATG" 
 out letClause);
 
-#line  2485 "cs.ATG" 
+#line  2490 "cs.ATG" 
 				SafeAdd<QueryExpressionClause>(q, q.MiddleClauses, letClause); 
 			} else if (la.kind == 142) {
 				QueryExpressionJoinClause(
-#line  2486 "cs.ATG" 
+#line  2491 "cs.ATG" 
 out joinClause);
 
-#line  2486 "cs.ATG" 
+#line  2491 "cs.ATG" 
 				SafeAdd<QueryExpressionClause>(q, q.MiddleClauses, joinClause); 
 			} else {
 				QueryExpressionOrderByClause(
-#line  2487 "cs.ATG" 
+#line  2492 "cs.ATG" 
 out orderClause);
 
-#line  2487 "cs.ATG" 
+#line  2492 "cs.ATG" 
 				SafeAdd<QueryExpressionClause>(q, q.MiddleClauses, orderClause); 
 			}
 		}
 		if (la.kind == 133) {
 			QueryExpressionSelectClause(
-#line  2489 "cs.ATG" 
+#line  2494 "cs.ATG" 
 out selectClause);
 
-#line  2489 "cs.ATG" 
+#line  2494 "cs.ATG" 
 			q.SelectOrGroupClause = selectClause; 
 		} else if (la.kind == 134) {
 			QueryExpressionGroupClause(
-#line  2490 "cs.ATG" 
+#line  2495 "cs.ATG" 
 out groupClause);
 
-#line  2490 "cs.ATG" 
+#line  2495 "cs.ATG" 
 			q.SelectOrGroupClause = groupClause; 
 		} else SynErr(216);
 		if (la.kind == 136) {
 			QueryExpressionIntoClause(
-#line  2492 "cs.ATG" 
+#line  2497 "cs.ATG" 
 ref q);
 		}
 	}
 
 	void QueryExpressionFromOrJoinClause(
-#line  2466 "cs.ATG" 
+#line  2471 "cs.ATG" 
 out CollectionRangeVariable variable) {
 
-#line  2467 "cs.ATG" 
+#line  2472 "cs.ATG" 
 		TypeReference type; Expression expr; variable = new CollectionRangeVariable(); 
 
-#line  2469 "cs.ATG" 
+#line  2474 "cs.ATG" 
 		variable.Type = null; 
 		if (
-#line  2470 "cs.ATG" 
+#line  2475 "cs.ATG" 
 IsLocalVarDecl()) {
 			Type(
-#line  2470 "cs.ATG" 
+#line  2475 "cs.ATG" 
 out type);
 
-#line  2470 "cs.ATG" 
+#line  2475 "cs.ATG" 
 			variable.Type = type; 
 		}
 		Identifier();
 
-#line  2471 "cs.ATG" 
+#line  2476 "cs.ATG" 
 		variable.Identifier = t.val; 
 		Expect(81);
 		Expr(
-#line  2473 "cs.ATG" 
+#line  2478 "cs.ATG" 
 out expr);
 
-#line  2473 "cs.ATG" 
+#line  2478 "cs.ATG" 
 		variable.Expression = expr; 
 	}
 
 	void QueryExpressionJoinClause(
-#line  2445 "cs.ATG" 
+#line  2450 "cs.ATG" 
 out QueryExpressionJoinClause jc) {
 
-#line  2446 "cs.ATG" 
+#line  2451 "cs.ATG" 
 		jc = new QueryExpressionJoinClause(); jc.StartLocation = la.Location; 
 		Expression expr;
 		CollectionRangeVariable variable;
 		
 		Expect(142);
 		QueryExpressionFromOrJoinClause(
-#line  2452 "cs.ATG" 
+#line  2457 "cs.ATG" 
 out variable);
 		Expect(143);
 		Expr(
-#line  2454 "cs.ATG" 
+#line  2459 "cs.ATG" 
 out expr);
 
-#line  2454 "cs.ATG" 
+#line  2459 "cs.ATG" 
 		jc.OnExpression = expr; 
 		Expect(144);
 		Expr(
-#line  2456 "cs.ATG" 
+#line  2461 "cs.ATG" 
 out expr);
 
-#line  2456 "cs.ATG" 
+#line  2461 "cs.ATG" 
 		jc.EqualsExpression = expr; 
 		if (la.kind == 136) {
 			lexer.NextToken();
 			Identifier();
 
-#line  2458 "cs.ATG" 
+#line  2463 "cs.ATG" 
 			jc.IntoIdentifier = t.val; 
 		}
 
-#line  2461 "cs.ATG" 
+#line  2466 "cs.ATG" 
 		jc.EndLocation = t.EndLocation;
 		jc.Source = variable;
 		
 	}
 
 	void QueryExpressionWhereClause(
-#line  2495 "cs.ATG" 
+#line  2500 "cs.ATG" 
 out QueryExpressionWhereClause wc) {
 
-#line  2496 "cs.ATG" 
+#line  2501 "cs.ATG" 
 		Expression expr; wc = new QueryExpressionWhereClause(); wc.StartLocation = la.Location; 
 		Expect(127);
 		Expr(
-#line  2499 "cs.ATG" 
+#line  2504 "cs.ATG" 
 out expr);
 
-#line  2499 "cs.ATG" 
+#line  2504 "cs.ATG" 
 		wc.Condition = expr; 
 
-#line  2500 "cs.ATG" 
+#line  2505 "cs.ATG" 
 		wc.EndLocation = t.EndLocation; 
 	}
 
 	void QueryExpressionLetClause(
-#line  2503 "cs.ATG" 
+#line  2508 "cs.ATG" 
 out QueryExpressionLetClause wc) {
 
-#line  2504 "cs.ATG" 
+#line  2509 "cs.ATG" 
 		Expression expr; wc = new QueryExpressionLetClause(); wc.StartLocation = la.Location; 
 		Expect(141);
 		Identifier();
 
-#line  2507 "cs.ATG" 
+#line  2512 "cs.ATG" 
 		wc.Identifier = t.val; 
 		Expect(3);
 		Expr(
-#line  2509 "cs.ATG" 
+#line  2514 "cs.ATG" 
 out expr);
 
-#line  2509 "cs.ATG" 
+#line  2514 "cs.ATG" 
 		wc.Expression = expr; 
 
-#line  2510 "cs.ATG" 
+#line  2515 "cs.ATG" 
 		wc.EndLocation = t.EndLocation; 
 	}
 
 	void QueryExpressionOrderByClause(
-#line  2513 "cs.ATG" 
+#line  2518 "cs.ATG" 
 out QueryExpressionOrderClause oc) {
 
-#line  2514 "cs.ATG" 
+#line  2519 "cs.ATG" 
 		QueryExpressionOrdering ordering; oc = new QueryExpressionOrderClause(); oc.StartLocation = la.Location; 
 		Expect(140);
 		QueryExpressionOrdering(
-#line  2517 "cs.ATG" 
+#line  2522 "cs.ATG" 
 out ordering);
 
-#line  2517 "cs.ATG" 
+#line  2522 "cs.ATG" 
 		SafeAdd(oc, oc.Orderings, ordering); 
 		while (la.kind == 14) {
 			lexer.NextToken();
 			QueryExpressionOrdering(
-#line  2519 "cs.ATG" 
+#line  2524 "cs.ATG" 
 out ordering);
 
-#line  2519 "cs.ATG" 
+#line  2524 "cs.ATG" 
 			SafeAdd(oc, oc.Orderings, ordering); 
 		}
 
-#line  2521 "cs.ATG" 
+#line  2526 "cs.ATG" 
 		oc.EndLocation = t.EndLocation; 
 	}
 
 	void QueryExpressionSelectClause(
-#line  2534 "cs.ATG" 
+#line  2539 "cs.ATG" 
 out QueryExpressionSelectClause sc) {
 
-#line  2535 "cs.ATG" 
+#line  2540 "cs.ATG" 
 		Expression expr; sc = new QueryExpressionSelectClause(); sc.StartLocation = la.Location; 
 		Expect(133);
 		Expr(
-#line  2538 "cs.ATG" 
+#line  2543 "cs.ATG" 
 out expr);
 
-#line  2538 "cs.ATG" 
+#line  2543 "cs.ATG" 
 		sc.Projection = expr; 
 
-#line  2539 "cs.ATG" 
+#line  2544 "cs.ATG" 
 		sc.EndLocation = t.EndLocation; 
 	}
 
 	void QueryExpressionGroupClause(
-#line  2542 "cs.ATG" 
+#line  2547 "cs.ATG" 
 out QueryExpressionGroupClause gc) {
 
-#line  2543 "cs.ATG" 
+#line  2548 "cs.ATG" 
 		Expression expr; gc = new QueryExpressionGroupClause(); gc.StartLocation = la.Location; 
 		Expect(134);
 		Expr(
-#line  2546 "cs.ATG" 
+#line  2551 "cs.ATG" 
 out expr);
 
-#line  2546 "cs.ATG" 
+#line  2551 "cs.ATG" 
 		gc.Projection = expr; 
 		Expect(135);
 		Expr(
-#line  2548 "cs.ATG" 
+#line  2553 "cs.ATG" 
 out expr);
 
-#line  2548 "cs.ATG" 
+#line  2553 "cs.ATG" 
 		gc.GroupBy = expr; 
 
-#line  2549 "cs.ATG" 
+#line  2554 "cs.ATG" 
 		gc.EndLocation = t.EndLocation; 
 	}
 
 	void QueryExpressionIntoClause(
-#line  2552 "cs.ATG" 
+#line  2557 "cs.ATG" 
 ref QueryExpression q) {
 
-#line  2553 "cs.ATG" 
+#line  2558 "cs.ATG" 
 		QueryExpression firstQuery = q;
 		QueryExpression continuedQuery = new QueryExpression(); 
 		continuedQuery.StartLocation = q.StartLocation;
@@ -5862,43 +5867,43 @@ ref QueryExpression q) {
 		Expect(136);
 		Identifier();
 
-#line  2568 "cs.ATG" 
+#line  2573 "cs.ATG" 
 		fromVariable.Identifier = t.val; 
 
-#line  2569 "cs.ATG" 
+#line  2574 "cs.ATG" 
 		continuedQuery.FromClause.EndLocation = t.EndLocation; 
 		QueryExpressionBody(
-#line  2570 "cs.ATG" 
+#line  2575 "cs.ATG" 
 ref q);
 	}
 
 	void QueryExpressionOrdering(
-#line  2524 "cs.ATG" 
+#line  2529 "cs.ATG" 
 out QueryExpressionOrdering ordering) {
 
-#line  2525 "cs.ATG" 
+#line  2530 "cs.ATG" 
 		Expression expr; ordering = new QueryExpressionOrdering(); ordering.StartLocation = la.Location; 
 		Expr(
-#line  2527 "cs.ATG" 
+#line  2532 "cs.ATG" 
 out expr);
 
-#line  2527 "cs.ATG" 
+#line  2532 "cs.ATG" 
 		ordering.Criteria = expr; 
 		if (la.kind == 138 || la.kind == 139) {
 			if (la.kind == 138) {
 				lexer.NextToken();
 
-#line  2528 "cs.ATG" 
+#line  2533 "cs.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Ascending; 
 			} else {
 				lexer.NextToken();
 
-#line  2529 "cs.ATG" 
+#line  2534 "cs.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Descending; 
 			}
 		}
 
-#line  2531 "cs.ATG" 
+#line  2536 "cs.ATG" 
 		ordering.EndLocation = t.EndLocation; 
 	}
 
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG
index b42b4efccb..7e67725bbe 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG
@@ -2165,39 +2165,40 @@ AnonymousMethodExpr<out Expression outExpr>
 .
 
 ConditionalOrExpr<ref Expression outExpr>
-(. Expression expr;   .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	ConditionalAndExpr<ref outExpr>  { "||" UnaryExpr<out expr> ConditionalAndExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr);  .) }
+	ConditionalAndExpr<ref outExpr>  { "||" UnaryExpr<out expr> ConditionalAndExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 ConditionalAndExpr<ref Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	InclusiveOrExpr<ref outExpr>  { "&&" UnaryExpr<out expr> InclusiveOrExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr);  .) }
+	InclusiveOrExpr<ref outExpr>  { "&&" UnaryExpr<out expr> InclusiveOrExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 InclusiveOrExpr<ref Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	ExclusiveOrExpr<ref outExpr>  { "|" UnaryExpr<out expr> ExclusiveOrExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr);  .) }
+	ExclusiveOrExpr<ref outExpr>  { "|" UnaryExpr<out expr> ExclusiveOrExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 ExclusiveOrExpr<ref Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	AndExpr<ref outExpr>  { "^" UnaryExpr<out expr> AndExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr);  .) }
+	AndExpr<ref outExpr>  { "^" UnaryExpr<out expr> AndExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 AndExpr<ref Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	EqualityExpr<ref outExpr> { "&" UnaryExpr<out expr> EqualityExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr);  .) }
+	EqualityExpr<ref outExpr> { "&" UnaryExpr<out expr> EqualityExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 EqualityExpr<ref Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .)
 =
 	RelationalExpr<ref outExpr>
@@ -2206,7 +2207,7 @@ EqualityExpr<ref Expression outExpr>
 			"!="   (. op = BinaryOperatorType.InEquality; .)
 			| "==" (. op = BinaryOperatorType.Equality; .)
 		)
-		UnaryExpr<out expr> RelationalExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .) 
+		UnaryExpr<out expr> RelationalExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) 
 	}
 .
 
@@ -2215,6 +2216,7 @@ RelationalExpr<ref Expression outExpr>
 	TypeReference type;
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .)
 =
 	ShiftExpr<ref outExpr>
@@ -2226,18 +2228,18 @@ RelationalExpr<ref Expression outExpr>
 		)
 		UnaryExpr<out expr>
 		ShiftExpr<ref expr>
-		(. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .)
+		(. outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
 	|
 		(	"is"
 			TypeWithRestriction<out type, false, false>
 			[ IF (la.kind == Tokens.Question && !IsPossibleExpressionStart(Peek(1).kind))
 				NullableQuestionMark<ref type> ]
-			(. outExpr = new TypeOfIsExpression(outExpr, type); .)
+			(. outExpr = new TypeOfIsExpression(outExpr, type)  { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
 		|	"as"
 			TypeWithRestriction<out type, false, false>
 			[ IF (la.kind == Tokens.Question && !IsPossibleExpressionStart(Peek(1).kind))
 				NullableQuestionMark<ref type> ]
-			(. outExpr = new CastExpression(type, outExpr, CastType.TryCast); .)
+			(. outExpr = new CastExpression(type, outExpr, CastType.TryCast) { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
 		)
 	}
 .
@@ -2246,6 +2248,7 @@ ShiftExpr<ref Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .)
 =
 	AdditiveExpr<ref outExpr> 
@@ -2255,7 +2258,7 @@ ShiftExpr<ref Expression outExpr>
 				">" ">" (. op = BinaryOperatorType.ShiftRight; .)
 			)
 		)
-		UnaryExpr<out expr> AdditiveExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .) 
+		UnaryExpr<out expr> AdditiveExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) 
 	}
 .
 
@@ -2263,6 +2266,7 @@ AdditiveExpr<ref Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .)
 =
 	MultiplicativeExpr<ref outExpr>
@@ -2271,7 +2275,7 @@ AdditiveExpr<ref Expression outExpr>
 			"+"   (. op = BinaryOperatorType.Add; .)
 			| "-" (. op = BinaryOperatorType.Subtract; .)
 		)
-		UnaryExpr<out expr> MultiplicativeExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .)
+		UnaryExpr<out expr> MultiplicativeExpr<ref expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
 	}
 .
 
@@ -2279,6 +2283,7 @@ MultiplicativeExpr<ref Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .)
 =
 	{
@@ -2287,7 +2292,7 @@ MultiplicativeExpr<ref Expression outExpr>
 			| "/" (. op = BinaryOperatorType.Divide; .)
 			| "%" (. op = BinaryOperatorType.Modulus; .)
 		) 
-		UnaryExpr<out expr> (. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .) 
+		UnaryExpr<out expr> (. outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; .) 
 	}
 .
 
diff --git a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
index 2b0c92d516..a3a02b659d 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
@@ -182,7 +182,7 @@ out u);
 	void GlobalAttributeSection() {
 		Expect(40);
 
-#line  2790 "VBNET.ATG" 
+#line  2797 "VBNET.ATG" 
 		Location startPos = t.Location; 
 		if (la.kind == 65) {
 			lexer.NextToken();
@@ -190,20 +190,20 @@ out u);
 			lexer.NextToken();
 		} else SynErr(243);
 
-#line  2792 "VBNET.ATG" 
+#line  2799 "VBNET.ATG" 
 		string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
 		List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
 		
 		Expect(21);
 		Attribute(
-#line  2796 "VBNET.ATG" 
+#line  2803 "VBNET.ATG" 
 out attribute);
 
-#line  2796 "VBNET.ATG" 
+#line  2803 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2797 "VBNET.ATG" 
+#line  2804 "VBNET.ATG" 
 NotFinalComma()) {
 			if (la.kind == 22) {
 				lexer.NextToken();
@@ -215,10 +215,10 @@ NotFinalComma()) {
 				Expect(21);
 			}
 			Attribute(
-#line  2797 "VBNET.ATG" 
+#line  2804 "VBNET.ATG" 
 out attribute);
 
-#line  2797 "VBNET.ATG" 
+#line  2804 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 22) {
@@ -227,7 +227,7 @@ out attribute);
 		Expect(39);
 		EndOfStmt();
 
-#line  2802 "VBNET.ATG" 
+#line  2809 "VBNET.ATG" 
 		AttributeSection section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -353,47 +353,47 @@ out aliasedType);
 	}
 
 	void Qualident(
-#line  3567 "VBNET.ATG" 
+#line  3574 "VBNET.ATG" 
 out string qualident) {
 
-#line  3569 "VBNET.ATG" 
+#line  3576 "VBNET.ATG" 
 		string name;
 		qualidentBuilder.Length = 0; 
 		
 		Identifier();
 
-#line  3573 "VBNET.ATG" 
+#line  3580 "VBNET.ATG" 
 		qualidentBuilder.Append(t.val); 
 		while (
-#line  3574 "VBNET.ATG" 
+#line  3581 "VBNET.ATG" 
 DotAndIdentOrKw()) {
 			Expect(26);
 			IdentifierOrKeyword(
-#line  3574 "VBNET.ATG" 
+#line  3581 "VBNET.ATG" 
 out name);
 
-#line  3574 "VBNET.ATG" 
+#line  3581 "VBNET.ATG" 
 			qualidentBuilder.Append('.'); qualidentBuilder.Append(name); 
 		}
 
-#line  3576 "VBNET.ATG" 
+#line  3583 "VBNET.ATG" 
 		qualident = qualidentBuilder.ToString(); 
 	}
 
 	void TypeName(
-#line  2663 "VBNET.ATG" 
+#line  2670 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  2664 "VBNET.ATG" 
+#line  2671 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  2666 "VBNET.ATG" 
+#line  2673 "VBNET.ATG" 
 out typeref, false);
 		ArrayTypeModifiers(
-#line  2670 "VBNET.ATG" 
+#line  2677 "VBNET.ATG" 
 out rank);
 
-#line  2671 "VBNET.ATG" 
+#line  2678 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -424,10 +424,10 @@ out rank);
 	}
 
 	void AttributeSection(
-#line  2868 "VBNET.ATG" 
+#line  2875 "VBNET.ATG" 
 out AttributeSection section) {
 
-#line  2870 "VBNET.ATG" 
+#line  2877 "VBNET.ATG" 
 		string attributeTarget = "";
 		List<ASTAttribute> attributes = new List<ASTAttribute>();
 		ASTAttribute attribute;
@@ -435,22 +435,22 @@ out AttributeSection section) {
 		
 		Expect(40);
 		if (
-#line  2876 "VBNET.ATG" 
+#line  2883 "VBNET.ATG" 
 IsLocalAttrTarget()) {
 			if (la.kind == 119) {
 				lexer.NextToken();
 
-#line  2877 "VBNET.ATG" 
+#line  2884 "VBNET.ATG" 
 				attributeTarget = "event";
 			} else if (la.kind == 195) {
 				lexer.NextToken();
 
-#line  2878 "VBNET.ATG" 
+#line  2885 "VBNET.ATG" 
 				attributeTarget = "return";
 			} else {
 				Identifier();
 
-#line  2881 "VBNET.ATG" 
+#line  2888 "VBNET.ATG" 
 				string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
 				if (val != "field"	|| val != "method" ||
 					val != "module" || val != "param"  ||
@@ -463,20 +463,20 @@ IsLocalAttrTarget()) {
 			Expect(21);
 		}
 		Attribute(
-#line  2891 "VBNET.ATG" 
+#line  2898 "VBNET.ATG" 
 out attribute);
 
-#line  2891 "VBNET.ATG" 
+#line  2898 "VBNET.ATG" 
 		attributes.Add(attribute); 
 		while (
-#line  2892 "VBNET.ATG" 
+#line  2899 "VBNET.ATG" 
 NotFinalComma()) {
 			Expect(22);
 			Attribute(
-#line  2892 "VBNET.ATG" 
+#line  2899 "VBNET.ATG" 
 out attribute);
 
-#line  2892 "VBNET.ATG" 
+#line  2899 "VBNET.ATG" 
 			attributes.Add(attribute); 
 		}
 		if (la.kind == 22) {
@@ -484,7 +484,7 @@ out attribute);
 		}
 		Expect(39);
 
-#line  2896 "VBNET.ATG" 
+#line  2903 "VBNET.ATG" 
 		section = new AttributeSection {
 		AttributeTarget = attributeTarget,
 		Attributes = attributes,
@@ -495,69 +495,69 @@ out attribute);
 	}
 
 	void TypeModifier(
-#line  3652 "VBNET.ATG" 
+#line  3659 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 188: {
 			lexer.NextToken();
 
-#line  3653 "VBNET.ATG" 
+#line  3660 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location); 
 			break;
 		}
 		case 187: {
 			lexer.NextToken();
 
-#line  3654 "VBNET.ATG" 
+#line  3661 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location); 
 			break;
 		}
 		case 125: {
 			lexer.NextToken();
 
-#line  3655 "VBNET.ATG" 
+#line  3662 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location); 
 			break;
 		}
 		case 185: {
 			lexer.NextToken();
 
-#line  3656 "VBNET.ATG" 
+#line  3663 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location); 
 			break;
 		}
 		case 200: {
 			lexer.NextToken();
 
-#line  3657 "VBNET.ATG" 
+#line  3664 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location); 
 			break;
 		}
 		case 199: {
 			lexer.NextToken();
 
-#line  3658 "VBNET.ATG" 
+#line  3665 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location); 
 			break;
 		}
 		case 156: {
 			lexer.NextToken();
 
-#line  3659 "VBNET.ATG" 
+#line  3666 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location); 
 			break;
 		}
 		case 166: {
 			lexer.NextToken();
 
-#line  3660 "VBNET.ATG" 
+#line  3667 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location); 
 			break;
 		}
 		case 183: {
 			lexer.NextToken();
 
-#line  3661 "VBNET.ATG" 
+#line  3668 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location); 
 			break;
 		}
@@ -1146,10 +1146,10 @@ m, attributes);
 	}
 
 	void NonArrayTypeName(
-#line  2689 "VBNET.ATG" 
+#line  2696 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  2691 "VBNET.ATG" 
+#line  2698 "VBNET.ATG" 
 		string name;
 		typeref = null;
 		bool isGlobal = false;
@@ -1159,36 +1159,36 @@ out TypeReference typeref, bool canBeUnbound) {
 				lexer.NextToken();
 				Expect(26);
 
-#line  2696 "VBNET.ATG" 
+#line  2703 "VBNET.ATG" 
 				isGlobal = true; 
 			}
 			QualIdentAndTypeArguments(
-#line  2697 "VBNET.ATG" 
+#line  2704 "VBNET.ATG" 
 out typeref, canBeUnbound);
 
-#line  2698 "VBNET.ATG" 
+#line  2705 "VBNET.ATG" 
 			typeref.IsGlobal = isGlobal; 
 			while (la.kind == 26) {
 				lexer.NextToken();
 
-#line  2699 "VBNET.ATG" 
+#line  2706 "VBNET.ATG" 
 				TypeReference nestedTypeRef; 
 				QualIdentAndTypeArguments(
-#line  2700 "VBNET.ATG" 
+#line  2707 "VBNET.ATG" 
 out nestedTypeRef, canBeUnbound);
 
-#line  2701 "VBNET.ATG" 
+#line  2708 "VBNET.ATG" 
 				typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes); 
 			}
 		} else if (la.kind == 168) {
 			lexer.NextToken();
 
-#line  2704 "VBNET.ATG" 
+#line  2711 "VBNET.ATG" 
 			typeref = new TypeReference("System.Object", true); 
 			if (la.kind == 33) {
 				lexer.NextToken();
 
-#line  2708 "VBNET.ATG" 
+#line  2715 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
@@ -1196,15 +1196,15 @@ out nestedTypeRef, canBeUnbound);
 			}
 		} else if (StartOf(12)) {
 			PrimitiveTypeName(
-#line  2714 "VBNET.ATG" 
+#line  2721 "VBNET.ATG" 
 out name);
 
-#line  2714 "VBNET.ATG" 
+#line  2721 "VBNET.ATG" 
 			typeref = new TypeReference(name, true); 
 			if (la.kind == 33) {
 				lexer.NextToken();
 
-#line  2718 "VBNET.ATG" 
+#line  2725 "VBNET.ATG" 
 				List<TypeReference> typeArguments = new List<TypeReference>(1);
 				if (typeref != null) typeArguments.Add(typeref);
 				typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
@@ -1290,162 +1290,162 @@ TypeDeclaration newType) {
 	}
 
 	void FormalParameterList(
-#line  2906 "VBNET.ATG" 
+#line  2913 "VBNET.ATG" 
 List<ParameterDeclarationExpression> parameter) {
 
-#line  2907 "VBNET.ATG" 
+#line  2914 "VBNET.ATG" 
 		ParameterDeclarationExpression p; 
 		FormalParameter(
-#line  2909 "VBNET.ATG" 
+#line  2916 "VBNET.ATG" 
 out p);
 
-#line  2909 "VBNET.ATG" 
+#line  2916 "VBNET.ATG" 
 		if (p != null) parameter.Add(p); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			FormalParameter(
-#line  2911 "VBNET.ATG" 
+#line  2918 "VBNET.ATG" 
 out p);
 
-#line  2911 "VBNET.ATG" 
+#line  2918 "VBNET.ATG" 
 			if (p != null) parameter.Add(p); 
 		}
 	}
 
 	void MemberModifier(
-#line  3664 "VBNET.ATG" 
+#line  3671 "VBNET.ATG" 
 ModifierList m) {
 		switch (la.kind) {
 		case 156: {
 			lexer.NextToken();
 
-#line  3665 "VBNET.ATG" 
+#line  3672 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 102: {
 			lexer.NextToken();
 
-#line  3666 "VBNET.ATG" 
+#line  3673 "VBNET.ATG" 
 			m.Add(Modifiers.Default, t.Location);
 			break;
 		}
 		case 125: {
 			lexer.NextToken();
 
-#line  3667 "VBNET.ATG" 
+#line  3674 "VBNET.ATG" 
 			m.Add(Modifiers.Internal, t.Location);
 			break;
 		}
 		case 199: {
 			lexer.NextToken();
 
-#line  3668 "VBNET.ATG" 
+#line  3675 "VBNET.ATG" 
 			m.Add(Modifiers.New, t.Location);
 			break;
 		}
 		case 181: {
 			lexer.NextToken();
 
-#line  3669 "VBNET.ATG" 
+#line  3676 "VBNET.ATG" 
 			m.Add(Modifiers.Override, t.Location);
 			break;
 		}
 		case 157: {
 			lexer.NextToken();
 
-#line  3670 "VBNET.ATG" 
+#line  3677 "VBNET.ATG" 
 			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
 		case 185: {
 			lexer.NextToken();
 
-#line  3671 "VBNET.ATG" 
+#line  3678 "VBNET.ATG" 
 			m.Add(Modifiers.Private, t.Location);
 			break;
 		}
 		case 187: {
 			lexer.NextToken();
 
-#line  3672 "VBNET.ATG" 
+#line  3679 "VBNET.ATG" 
 			m.Add(Modifiers.Protected, t.Location);
 			break;
 		}
 		case 188: {
 			lexer.NextToken();
 
-#line  3673 "VBNET.ATG" 
+#line  3680 "VBNET.ATG" 
 			m.Add(Modifiers.Public, t.Location);
 			break;
 		}
 		case 166: {
 			lexer.NextToken();
 
-#line  3674 "VBNET.ATG" 
+#line  3681 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 167: {
 			lexer.NextToken();
 
-#line  3675 "VBNET.ATG" 
+#line  3682 "VBNET.ATG" 
 			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
 		case 200: {
 			lexer.NextToken();
 
-#line  3676 "VBNET.ATG" 
+#line  3683 "VBNET.ATG" 
 			m.Add(Modifiers.Static, t.Location);
 			break;
 		}
 		case 180: {
 			lexer.NextToken();
 
-#line  3677 "VBNET.ATG" 
+#line  3684 "VBNET.ATG" 
 			m.Add(Modifiers.Virtual, t.Location);
 			break;
 		}
 		case 179: {
 			lexer.NextToken();
 
-#line  3678 "VBNET.ATG" 
+#line  3685 "VBNET.ATG" 
 			m.Add(Modifiers.Overloads, t.Location);
 			break;
 		}
 		case 190: {
 			lexer.NextToken();
 
-#line  3679 "VBNET.ATG" 
+#line  3686 "VBNET.ATG" 
 			m.Add(Modifiers.ReadOnly, t.Location);
 			break;
 		}
 		case 235: {
 			lexer.NextToken();
 
-#line  3680 "VBNET.ATG" 
+#line  3687 "VBNET.ATG" 
 			m.Add(Modifiers.WriteOnly, t.Location);
 			break;
 		}
 		case 234: {
 			lexer.NextToken();
 
-#line  3681 "VBNET.ATG" 
+#line  3688 "VBNET.ATG" 
 			m.Add(Modifiers.WithEvents, t.Location);
 			break;
 		}
 		case 105: {
 			lexer.NextToken();
 
-#line  3682 "VBNET.ATG" 
+#line  3689 "VBNET.ATG" 
 			m.Add(Modifiers.Dim, t.Location);
 			break;
 		}
 		case 183: {
 			lexer.NextToken();
 
-#line  3683 "VBNET.ATG" 
+#line  3690 "VBNET.ATG" 
 			m.Add(Modifiers.Partial, t.Location);
 			break;
 		}
@@ -2580,25 +2580,25 @@ out name);
 	}
 
 	void Block(
-#line  2954 "VBNET.ATG" 
+#line  2961 "VBNET.ATG" 
 out Statement stmt) {
 
-#line  2957 "VBNET.ATG" 
+#line  2964 "VBNET.ATG" 
 		BlockStatement blockStmt = new BlockStatement();
 		/* in snippet parsing mode, t might be null */
 		if (t != null) blockStmt.StartLocation = t.EndLocation;
 		BlockStart(blockStmt);
 		
 		while (StartOf(22) || 
-#line  2963 "VBNET.ATG" 
+#line  2970 "VBNET.ATG" 
 IsEndStmtAhead()) {
 			if (
-#line  2963 "VBNET.ATG" 
+#line  2970 "VBNET.ATG" 
 IsEndStmtAhead()) {
 				Expect(113);
 				EndOfStmt();
 
-#line  2963 "VBNET.ATG" 
+#line  2970 "VBNET.ATG" 
 				AddChild(new EndStatement()); 
 			} else {
 				Statement();
@@ -2606,7 +2606,7 @@ IsEndStmtAhead()) {
 			}
 		}
 
-#line  2968 "VBNET.ATG" 
+#line  2975 "VBNET.ATG" 
 		stmt = blockStmt;
 		if (t != null) blockStmt.EndLocation = t.EndLocation;
 		BlockEnd();
@@ -2906,10 +2906,10 @@ out expr);
 	}
 
 	void ObjectCreateExpression(
-#line  2105 "VBNET.ATG" 
+#line  2112 "VBNET.ATG" 
 out Expression oce) {
 
-#line  2107 "VBNET.ATG" 
+#line  2114 "VBNET.ATG" 
 		TypeReference type = null;
 		CollectionInitializerExpression initializer = null;
 		List<Expression> arguments = null;
@@ -2920,39 +2920,39 @@ out Expression oce) {
 		Expect(162);
 		if (StartOf(8)) {
 			NonArrayTypeName(
-#line  2115 "VBNET.ATG" 
+#line  2122 "VBNET.ATG" 
 out type, false);
 			if (la.kind == 37) {
 				lexer.NextToken();
 				NormalOrReDimArgumentList(
-#line  2116 "VBNET.ATG" 
+#line  2123 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeReDim);
 				Expect(38);
 				if (la.kind == 35 || 
-#line  2117 "VBNET.ATG" 
+#line  2124 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 					if (
-#line  2117 "VBNET.ATG" 
+#line  2124 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis) {
 						ArrayTypeModifiers(
-#line  2118 "VBNET.ATG" 
+#line  2125 "VBNET.ATG" 
 out dimensions);
 						CollectionInitializer(
-#line  2119 "VBNET.ATG" 
+#line  2126 "VBNET.ATG" 
 out initializer);
 					} else {
 						CollectionInitializer(
-#line  2120 "VBNET.ATG" 
+#line  2127 "VBNET.ATG" 
 out initializer);
 					}
 				}
 
-#line  2122 "VBNET.ATG" 
+#line  2129 "VBNET.ATG" 
 				if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); 
 			}
 		}
 
-#line  2126 "VBNET.ATG" 
+#line  2133 "VBNET.ATG" 
 		if (initializer == null) {
 		oce = new ObjectCreateExpression(type, arguments);
 		} else {
@@ -2967,53 +2967,53 @@ out initializer);
 		if (la.kind == 126 || la.kind == 233) {
 			if (la.kind == 233) {
 
-#line  2141 "VBNET.ATG" 
+#line  2148 "VBNET.ATG" 
 				MemberInitializerExpression memberInitializer = null;
 				Expression anonymousMember = null;
 				
 				lexer.NextToken();
 
-#line  2146 "VBNET.ATG" 
+#line  2153 "VBNET.ATG" 
 				CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
 				memberInitializers.StartLocation = la.Location;
 				
 				Expect(35);
 				if (la.kind == 26 || la.kind == 147) {
 					MemberInitializer(
-#line  2151 "VBNET.ATG" 
+#line  2158 "VBNET.ATG" 
 out memberInitializer);
 
-#line  2152 "VBNET.ATG" 
+#line  2159 "VBNET.ATG" 
 					memberInitializers.CreateExpressions.Add(memberInitializer); 
 				} else if (StartOf(24)) {
 					Expr(
-#line  2153 "VBNET.ATG" 
+#line  2160 "VBNET.ATG" 
 out anonymousMember);
 
-#line  2154 "VBNET.ATG" 
+#line  2161 "VBNET.ATG" 
 					memberInitializers.CreateExpressions.Add(anonymousMember); 
 				} else SynErr(270);
 				while (la.kind == 22) {
 					lexer.NextToken();
 					if (la.kind == 26 || la.kind == 147) {
 						MemberInitializer(
-#line  2158 "VBNET.ATG" 
+#line  2165 "VBNET.ATG" 
 out memberInitializer);
 
-#line  2159 "VBNET.ATG" 
+#line  2166 "VBNET.ATG" 
 						memberInitializers.CreateExpressions.Add(memberInitializer); 
 					} else if (StartOf(24)) {
 						Expr(
-#line  2160 "VBNET.ATG" 
+#line  2167 "VBNET.ATG" 
 out anonymousMember);
 
-#line  2161 "VBNET.ATG" 
+#line  2168 "VBNET.ATG" 
 						memberInitializers.CreateExpressions.Add(anonymousMember); 
 					} else SynErr(271);
 				}
 				Expect(36);
 
-#line  2166 "VBNET.ATG" 
+#line  2173 "VBNET.ATG" 
 				memberInitializers.EndLocation = t.Location;
 				if(oce is ObjectCreateExpression)
 				{
@@ -3023,10 +3023,10 @@ out anonymousMember);
 			} else {
 				lexer.NextToken();
 				CollectionInitializer(
-#line  2176 "VBNET.ATG" 
+#line  2183 "VBNET.ATG" 
 out initializer);
 
-#line  2178 "VBNET.ATG" 
+#line  2185 "VBNET.ATG" 
 				if(oce is ObjectCreateExpression)
 				((ObjectCreateExpression)oce).ObjectInitializer = initializer;
 				
@@ -3363,10 +3363,10 @@ out OverloadableOperatorType operatorType) {
 	}
 
 	void FormalParameter(
-#line  2915 "VBNET.ATG" 
+#line  2922 "VBNET.ATG" 
 out ParameterDeclarationExpression p) {
 
-#line  2917 "VBNET.ATG" 
+#line  2924 "VBNET.ATG" 
 		AttributeSection section;
 		List<AttributeSection> attributes = new List<AttributeSection>();
 		TypeReference type = null;
@@ -3378,36 +3378,36 @@ out ParameterDeclarationExpression p) {
 		
 		while (la.kind == 40) {
 			AttributeSection(
-#line  2927 "VBNET.ATG" 
+#line  2934 "VBNET.ATG" 
 out section);
 
-#line  2927 "VBNET.ATG" 
+#line  2934 "VBNET.ATG" 
 			attributes.Add(section); 
 		}
 		while (StartOf(29)) {
 			ParameterModifier(
-#line  2928 "VBNET.ATG" 
+#line  2935 "VBNET.ATG" 
 mod);
 		}
 		Identifier();
 
-#line  2929 "VBNET.ATG" 
+#line  2936 "VBNET.ATG" 
 		string parameterName = t.val; 
 		if (
-#line  2930 "VBNET.ATG" 
+#line  2937 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  2930 "VBNET.ATG" 
+#line  2937 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-#line  2931 "VBNET.ATG" 
+#line  2938 "VBNET.ATG" 
 out type);
 		}
 
-#line  2933 "VBNET.ATG" 
+#line  2940 "VBNET.ATG" 
 		if(type != null) {
 		if (arrayModifiers != null) {
 			if (type.RankSpecifier != null) {
@@ -3421,11 +3421,11 @@ out type);
 		if (la.kind == 20) {
 			lexer.NextToken();
 			Expr(
-#line  2943 "VBNET.ATG" 
+#line  2950 "VBNET.ATG" 
 out expr);
 		}
 
-#line  2945 "VBNET.ATG" 
+#line  2952 "VBNET.ATG" 
 		mod.Check();
 		p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
 		p.Attributes = attributes;
@@ -3509,31 +3509,31 @@ out stmt);
 	}
 
 	void PropertyAccessorAccessModifier(
-#line  3686 "VBNET.ATG" 
+#line  3693 "VBNET.ATG" 
 out Modifiers m) {
 
-#line  3687 "VBNET.ATG" 
+#line  3694 "VBNET.ATG" 
 		m = Modifiers.None; 
 		while (StartOf(30)) {
 			if (la.kind == 188) {
 				lexer.NextToken();
 
-#line  3689 "VBNET.ATG" 
+#line  3696 "VBNET.ATG" 
 				m |= Modifiers.Public; 
 			} else if (la.kind == 187) {
 				lexer.NextToken();
 
-#line  3690 "VBNET.ATG" 
+#line  3697 "VBNET.ATG" 
 				m |= Modifiers.Protected; 
 			} else if (la.kind == 125) {
 				lexer.NextToken();
 
-#line  3691 "VBNET.ATG" 
+#line  3698 "VBNET.ATG" 
 				m |= Modifiers.Internal; 
 			} else {
 				lexer.NextToken();
 
-#line  3692 "VBNET.ATG" 
+#line  3699 "VBNET.ATG" 
 				m |= Modifiers.Private; 
 			}
 		}
@@ -3554,14 +3554,14 @@ out arrayModifiers);
 	}
 
 	void ArrayNameModifier(
-#line  2742 "VBNET.ATG" 
+#line  2749 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  2744 "VBNET.ATG" 
+#line  2751 "VBNET.ATG" 
 		arrayModifiers = null;
 		
 		ArrayTypeModifiers(
-#line  2746 "VBNET.ATG" 
+#line  2753 "VBNET.ATG" 
 out arrayModifiers);
 	}
 
@@ -3673,55 +3673,55 @@ out eventName);
 	}
 
 	void IdentifierOrKeyword(
-#line  3619 "VBNET.ATG" 
+#line  3626 "VBNET.ATG" 
 out string name) {
 		lexer.NextToken();
 
-#line  3621 "VBNET.ATG" 
+#line  3628 "VBNET.ATG" 
 		name = t.val;  
 	}
 
 	void QueryExpr(
-#line  2265 "VBNET.ATG" 
+#line  2272 "VBNET.ATG" 
 out Expression expr) {
 
-#line  2267 "VBNET.ATG" 
+#line  2274 "VBNET.ATG" 
 		QueryExpressionVB qexpr = new QueryExpressionVB();
 		qexpr.StartLocation = la.Location;
 		expr = qexpr;
 		
 		FromOrAggregateQueryOperator(
-#line  2271 "VBNET.ATG" 
+#line  2278 "VBNET.ATG" 
 qexpr.Clauses);
 		while (StartOf(31)) {
 			QueryOperator(
-#line  2272 "VBNET.ATG" 
+#line  2279 "VBNET.ATG" 
 qexpr.Clauses);
 		}
 
-#line  2274 "VBNET.ATG" 
+#line  2281 "VBNET.ATG" 
 		qexpr.EndLocation = t.EndLocation;
 		
 	}
 
 	void LambdaExpr(
-#line  2185 "VBNET.ATG" 
+#line  2192 "VBNET.ATG" 
 out Expression expr) {
 
-#line  2187 "VBNET.ATG" 
+#line  2194 "VBNET.ATG" 
 		LambdaExpression lambda = null;
 		
 		if (la.kind == 210) {
 			SubLambdaExpression(
-#line  2189 "VBNET.ATG" 
+#line  2196 "VBNET.ATG" 
 out lambda);
 		} else if (la.kind == 127) {
 			FunctionLambdaExpression(
-#line  2190 "VBNET.ATG" 
+#line  2197 "VBNET.ATG" 
 out lambda);
 		} else SynErr(276);
 
-#line  2191 "VBNET.ATG" 
+#line  2198 "VBNET.ATG" 
 		expr = lambda; 
 	}
 
@@ -3732,33 +3732,34 @@ out Expression outExpr) {
 #line  1951 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		ConjunctionExpr(
-#line  1954 "VBNET.ATG" 
+#line  1955 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 175 || la.kind == 177 || la.kind == 236) {
 			if (la.kind == 175) {
 				lexer.NextToken();
 
-#line  1957 "VBNET.ATG" 
+#line  1958 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseOr; 
 			} else if (la.kind == 177) {
 				lexer.NextToken();
 
-#line  1958 "VBNET.ATG" 
+#line  1959 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalOr; 
 			} else {
 				lexer.NextToken();
 
-#line  1959 "VBNET.ATG" 
+#line  1960 "VBNET.ATG" 
 				op = BinaryOperatorType.ExclusiveOr; 
 			}
 			ConjunctionExpr(
-#line  1961 "VBNET.ATG" 
+#line  1962 "VBNET.ATG" 
 out expr);
 
-#line  1961 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  1962 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
@@ -3889,7 +3890,7 @@ la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 out name);
 
 #line  1697 "VBNET.ATG" 
-				pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name)); 
+				pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); 
 			} else if (la.kind == 27 || la.kind == 28) {
 
 #line  1698 "VBNET.ATG" 
@@ -4250,7 +4251,7 @@ out name);
 out name);
 
 #line  1783 "VBNET.ATG" 
-				pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name)); 
+				pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); 
 			} else {
 
 #line  1784 "VBNET.ATG" 
@@ -4293,25 +4294,25 @@ out name);
 	}
 
 	void TypeArgumentList(
-#line  2778 "VBNET.ATG" 
+#line  2785 "VBNET.ATG" 
 List<TypeReference> typeArguments) {
 
-#line  2780 "VBNET.ATG" 
+#line  2787 "VBNET.ATG" 
 		TypeReference typeref;
 		
 		TypeName(
-#line  2782 "VBNET.ATG" 
+#line  2789 "VBNET.ATG" 
 out typeref);
 
-#line  2782 "VBNET.ATG" 
+#line  2789 "VBNET.ATG" 
 		if (typeref != null) typeArguments.Add(typeref); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			TypeName(
-#line  2785 "VBNET.ATG" 
+#line  2792 "VBNET.ATG" 
 out typeref);
 
-#line  2785 "VBNET.ATG" 
+#line  2792 "VBNET.ATG" 
 			if (typeref != null) typeArguments.Add(typeref); 
 		}
 	}
@@ -4340,114 +4341,114 @@ out parameters);
 	}
 
 	void PrimitiveTypeName(
-#line  3626 "VBNET.ATG" 
+#line  3633 "VBNET.ATG" 
 out string type) {
 
-#line  3627 "VBNET.ATG" 
+#line  3634 "VBNET.ATG" 
 		type = String.Empty; 
 		switch (la.kind) {
 		case 68: {
 			lexer.NextToken();
 
-#line  3628 "VBNET.ATG" 
+#line  3635 "VBNET.ATG" 
 			type = "System.Boolean"; 
 			break;
 		}
 		case 99: {
 			lexer.NextToken();
 
-#line  3629 "VBNET.ATG" 
+#line  3636 "VBNET.ATG" 
 			type = "System.DateTime"; 
 			break;
 		}
 		case 82: {
 			lexer.NextToken();
 
-#line  3630 "VBNET.ATG" 
+#line  3637 "VBNET.ATG" 
 			type = "System.Char"; 
 			break;
 		}
 		case 208: {
 			lexer.NextToken();
 
-#line  3631 "VBNET.ATG" 
+#line  3638 "VBNET.ATG" 
 			type = "System.String"; 
 			break;
 		}
 		case 100: {
 			lexer.NextToken();
 
-#line  3632 "VBNET.ATG" 
+#line  3639 "VBNET.ATG" 
 			type = "System.Decimal"; 
 			break;
 		}
 		case 71: {
 			lexer.NextToken();
 
-#line  3633 "VBNET.ATG" 
+#line  3640 "VBNET.ATG" 
 			type = "System.Byte"; 
 			break;
 		}
 		case 201: {
 			lexer.NextToken();
 
-#line  3634 "VBNET.ATG" 
+#line  3641 "VBNET.ATG" 
 			type = "System.Int16"; 
 			break;
 		}
 		case 141: {
 			lexer.NextToken();
 
-#line  3635 "VBNET.ATG" 
+#line  3642 "VBNET.ATG" 
 			type = "System.Int32"; 
 			break;
 		}
 		case 151: {
 			lexer.NextToken();
 
-#line  3636 "VBNET.ATG" 
+#line  3643 "VBNET.ATG" 
 			type = "System.Int64"; 
 			break;
 		}
 		case 202: {
 			lexer.NextToken();
 
-#line  3637 "VBNET.ATG" 
+#line  3644 "VBNET.ATG" 
 			type = "System.Single"; 
 			break;
 		}
 		case 109: {
 			lexer.NextToken();
 
-#line  3638 "VBNET.ATG" 
+#line  3645 "VBNET.ATG" 
 			type = "System.Double"; 
 			break;
 		}
 		case 221: {
 			lexer.NextToken();
 
-#line  3639 "VBNET.ATG" 
+#line  3646 "VBNET.ATG" 
 			type = "System.UInt32"; 
 			break;
 		}
 		case 222: {
 			lexer.NextToken();
 
-#line  3640 "VBNET.ATG" 
+#line  3647 "VBNET.ATG" 
 			type = "System.UInt64"; 
 			break;
 		}
 		case 225: {
 			lexer.NextToken();
 
-#line  3641 "VBNET.ATG" 
+#line  3648 "VBNET.ATG" 
 			type = "System.UInt16"; 
 			break;
 		}
 		case 196: {
 			lexer.NextToken();
 
-#line  3642 "VBNET.ATG" 
+#line  3649 "VBNET.ATG" 
 			type = "System.SByte"; 
 			break;
 		}
@@ -4580,19 +4581,19 @@ out TypeReference type) {
 	}
 
 	void GetTypeTypeName(
-#line  2677 "VBNET.ATG" 
+#line  2684 "VBNET.ATG" 
 out TypeReference typeref) {
 
-#line  2678 "VBNET.ATG" 
+#line  2685 "VBNET.ATG" 
 		ArrayList rank = null; 
 		NonArrayTypeName(
-#line  2680 "VBNET.ATG" 
+#line  2687 "VBNET.ATG" 
 out typeref, true);
 		ArrayTypeModifiers(
-#line  2681 "VBNET.ATG" 
+#line  2688 "VBNET.ATG" 
 out rank);
 
-#line  2682 "VBNET.ATG" 
+#line  2689 "VBNET.ATG" 
 		if (rank != null && typeref != null) {
 		typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
 		}
@@ -4917,377 +4918,386 @@ out innerExpression);
 	}
 
 	void ArgumentList(
-#line  2608 "VBNET.ATG" 
+#line  2615 "VBNET.ATG" 
 out List<Expression> arguments) {
 
-#line  2610 "VBNET.ATG" 
+#line  2617 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		Expression expr = null;
 		
 		if (StartOf(24)) {
 			Argument(
-#line  2613 "VBNET.ATG" 
+#line  2620 "VBNET.ATG" 
 out expr);
 		}
 		while (la.kind == 22) {
 			lexer.NextToken();
 
-#line  2614 "VBNET.ATG" 
+#line  2621 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 			if (StartOf(24)) {
 				Argument(
-#line  2615 "VBNET.ATG" 
+#line  2622 "VBNET.ATG" 
 out expr);
 			}
 
-#line  2616 "VBNET.ATG" 
+#line  2623 "VBNET.ATG" 
 			if (expr == null) expr = Expression.Null; 
 		}
 
-#line  2618 "VBNET.ATG" 
+#line  2625 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); 
 	}
 
 	void ConjunctionExpr(
-#line  1965 "VBNET.ATG" 
+#line  1966 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1967 "VBNET.ATG" 
+#line  1968 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		NotExpr(
-#line  1970 "VBNET.ATG" 
+#line  1972 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 60 || la.kind == 61) {
 			if (la.kind == 60) {
 				lexer.NextToken();
 
-#line  1973 "VBNET.ATG" 
+#line  1975 "VBNET.ATG" 
 				op = BinaryOperatorType.BitwiseAnd; 
 			} else {
 				lexer.NextToken();
 
-#line  1974 "VBNET.ATG" 
+#line  1976 "VBNET.ATG" 
 				op = BinaryOperatorType.LogicalAnd; 
 			}
 			NotExpr(
-#line  1976 "VBNET.ATG" 
+#line  1978 "VBNET.ATG" 
 out expr);
 
-#line  1976 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  1978 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void NotExpr(
-#line  1980 "VBNET.ATG" 
+#line  1982 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1981 "VBNET.ATG" 
+#line  1983 "VBNET.ATG" 
 		UnaryOperatorType uop = UnaryOperatorType.None; 
 		while (la.kind == 164) {
 			lexer.NextToken();
 
-#line  1982 "VBNET.ATG" 
+#line  1984 "VBNET.ATG" 
 			uop = UnaryOperatorType.Not; 
 		}
 		ComparisonExpr(
-#line  1983 "VBNET.ATG" 
+#line  1985 "VBNET.ATG" 
 out outExpr);
 
-#line  1984 "VBNET.ATG" 
+#line  1986 "VBNET.ATG" 
 		if (uop != UnaryOperatorType.None)
 		outExpr = new UnaryOperatorExpression(outExpr, uop);
 		
 	}
 
 	void ComparisonExpr(
-#line  1989 "VBNET.ATG" 
+#line  1991 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  1991 "VBNET.ATG" 
+#line  1993 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		ShiftExpr(
-#line  1994 "VBNET.ATG" 
+#line  1997 "VBNET.ATG" 
 out outExpr);
 		while (StartOf(40)) {
 			switch (la.kind) {
 			case 40: {
 				lexer.NextToken();
 
-#line  1997 "VBNET.ATG" 
+#line  2000 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 39: {
 				lexer.NextToken();
 
-#line  1998 "VBNET.ATG" 
+#line  2001 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 43: {
 				lexer.NextToken();
 
-#line  1999 "VBNET.ATG" 
+#line  2002 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 42: {
 				lexer.NextToken();
 
-#line  2000 "VBNET.ATG" 
+#line  2003 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 41: {
 				lexer.NextToken();
 
-#line  2001 "VBNET.ATG" 
+#line  2004 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			case 20: {
 				lexer.NextToken();
 
-#line  2002 "VBNET.ATG" 
+#line  2005 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 150: {
 				lexer.NextToken();
 
-#line  2003 "VBNET.ATG" 
+#line  2006 "VBNET.ATG" 
 				op = BinaryOperatorType.Like; 
 				break;
 			}
 			case 144: {
 				lexer.NextToken();
 
-#line  2004 "VBNET.ATG" 
+#line  2007 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceEquality; 
 				break;
 			}
 			case 145: {
 				lexer.NextToken();
 
-#line  2005 "VBNET.ATG" 
+#line  2008 "VBNET.ATG" 
 				op = BinaryOperatorType.ReferenceInequality; 
 				break;
 			}
 			}
 			if (StartOf(41)) {
 				ShiftExpr(
-#line  2008 "VBNET.ATG" 
+#line  2011 "VBNET.ATG" 
 out expr);
 
-#line  2008 "VBNET.ATG" 
-				outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  2011 "VBNET.ATG" 
+				outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 			} else if (la.kind == 164) {
+
+#line  2012 "VBNET.ATG" 
+				Location startLocation2 = la.Location; 
 				lexer.NextToken();
 				ShiftExpr(
-#line  2011 "VBNET.ATG" 
+#line  2014 "VBNET.ATG" 
 out expr);
 
-#line  2011 "VBNET.ATG" 
-				outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not));  
+#line  2014 "VBNET.ATG" 
+				outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not) { StartLocation = startLocation2, EndLocation = t.EndLocation }) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 			} else SynErr(295);
 		}
 	}
 
 	void ShiftExpr(
-#line  2016 "VBNET.ATG" 
+#line  2019 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  2018 "VBNET.ATG" 
+#line  2021 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		ConcatenationExpr(
-#line  2021 "VBNET.ATG" 
+#line  2025 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 44 || la.kind == 45) {
 			if (la.kind == 44) {
 				lexer.NextToken();
 
-#line  2024 "VBNET.ATG" 
+#line  2028 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftLeft; 
 			} else {
 				lexer.NextToken();
 
-#line  2025 "VBNET.ATG" 
+#line  2029 "VBNET.ATG" 
 				op = BinaryOperatorType.ShiftRight; 
 			}
 			ConcatenationExpr(
-#line  2027 "VBNET.ATG" 
+#line  2031 "VBNET.ATG" 
 out expr);
 
-#line  2027 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  2031 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void ConcatenationExpr(
-#line  2031 "VBNET.ATG" 
+#line  2035 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  2032 "VBNET.ATG" 
-		Expression expr; 
+#line  2036 "VBNET.ATG" 
+		Expression expr; Location startLocation = la.Location; 
 		AdditiveExpr(
-#line  2034 "VBNET.ATG" 
+#line  2038 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 23) {
 			lexer.NextToken();
 			AdditiveExpr(
-#line  2034 "VBNET.ATG" 
+#line  2038 "VBNET.ATG" 
 out expr);
 
-#line  2034 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr);  
+#line  2038 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void AdditiveExpr(
-#line  2037 "VBNET.ATG" 
+#line  2041 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  2039 "VBNET.ATG" 
+#line  2043 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		ModuloExpr(
-#line  2042 "VBNET.ATG" 
+#line  2047 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 30 || la.kind == 31) {
 			if (la.kind == 31) {
 				lexer.NextToken();
 
-#line  2045 "VBNET.ATG" 
+#line  2050 "VBNET.ATG" 
 				op = BinaryOperatorType.Add; 
 			} else {
 				lexer.NextToken();
 
-#line  2046 "VBNET.ATG" 
+#line  2051 "VBNET.ATG" 
 				op = BinaryOperatorType.Subtract; 
 			}
 			ModuloExpr(
-#line  2048 "VBNET.ATG" 
+#line  2053 "VBNET.ATG" 
 out expr);
 
-#line  2048 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
+#line  2053 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void ModuloExpr(
-#line  2052 "VBNET.ATG" 
+#line  2057 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  2053 "VBNET.ATG" 
-		Expression expr; 
+#line  2058 "VBNET.ATG" 
+		Expression expr; Location startLocation = la.Location; 
 		IntegerDivisionExpr(
-#line  2055 "VBNET.ATG" 
+#line  2060 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 154) {
 			lexer.NextToken();
 			IntegerDivisionExpr(
-#line  2055 "VBNET.ATG" 
+#line  2060 "VBNET.ATG" 
 out expr);
 
-#line  2055 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr);  
+#line  2060 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void IntegerDivisionExpr(
-#line  2058 "VBNET.ATG" 
+#line  2063 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  2059 "VBNET.ATG" 
-		Expression expr; 
+#line  2064 "VBNET.ATG" 
+		Expression expr; Location startLocation = la.Location; 
 		MultiplicativeExpr(
-#line  2061 "VBNET.ATG" 
+#line  2066 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 25) {
 			lexer.NextToken();
 			MultiplicativeExpr(
-#line  2061 "VBNET.ATG" 
+#line  2066 "VBNET.ATG" 
 out expr);
 
-#line  2061 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr);  
+#line  2066 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void MultiplicativeExpr(
-#line  2064 "VBNET.ATG" 
+#line  2069 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  2066 "VBNET.ATG" 
+#line  2071 "VBNET.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 		
 		UnaryExpr(
-#line  2069 "VBNET.ATG" 
+#line  2075 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 24 || la.kind == 34) {
 			if (la.kind == 34) {
 				lexer.NextToken();
 
-#line  2072 "VBNET.ATG" 
+#line  2078 "VBNET.ATG" 
 				op = BinaryOperatorType.Multiply; 
 			} else {
 				lexer.NextToken();
 
-#line  2073 "VBNET.ATG" 
+#line  2079 "VBNET.ATG" 
 				op = BinaryOperatorType.Divide; 
 			}
 			UnaryExpr(
-#line  2075 "VBNET.ATG" 
+#line  2081 "VBNET.ATG" 
 out expr);
 
-#line  2075 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr); 
+#line  2081 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
 		}
 	}
 
 	void UnaryExpr(
-#line  2079 "VBNET.ATG" 
+#line  2085 "VBNET.ATG" 
 out Expression uExpr) {
 
-#line  2081 "VBNET.ATG" 
+#line  2087 "VBNET.ATG" 
 		Expression expr;
 		UnaryOperatorType uop = UnaryOperatorType.None;
+		Location startLocation = la.Location;
 		bool isUOp = false;
 		
 		while (la.kind == 30 || la.kind == 31 || la.kind == 34) {
 			if (la.kind == 31) {
 				lexer.NextToken();
 
-#line  2085 "VBNET.ATG" 
+#line  2092 "VBNET.ATG" 
 				uop = UnaryOperatorType.Plus; isUOp = true; 
 			} else if (la.kind == 30) {
 				lexer.NextToken();
 
-#line  2086 "VBNET.ATG" 
+#line  2093 "VBNET.ATG" 
 				uop = UnaryOperatorType.Minus; isUOp = true; 
 			} else {
 				lexer.NextToken();
 
-#line  2087 "VBNET.ATG" 
+#line  2094 "VBNET.ATG" 
 				uop = UnaryOperatorType.Dereference;  isUOp = true;
 			}
 		}
 		ExponentiationExpr(
-#line  2089 "VBNET.ATG" 
+#line  2096 "VBNET.ATG" 
 out expr);
 
-#line  2091 "VBNET.ATG" 
+#line  2098 "VBNET.ATG" 
 		if (isUOp) {
-		uExpr = new UnaryOperatorExpression(expr, uop);
+		uExpr = new UnaryOperatorExpression(expr, uop) { StartLocation = startLocation, EndLocation = t.EndLocation };
 		} else {
 			uExpr = expr;
 		}
@@ -5295,107 +5305,107 @@ out expr);
 	}
 
 	void ExponentiationExpr(
-#line  2099 "VBNET.ATG" 
+#line  2106 "VBNET.ATG" 
 out Expression outExpr) {
 
-#line  2100 "VBNET.ATG" 
-		Expression expr; 
+#line  2107 "VBNET.ATG" 
+		Expression expr; Location startLocation = la.Location; 
 		SimpleExpr(
-#line  2102 "VBNET.ATG" 
+#line  2109 "VBNET.ATG" 
 out outExpr);
 		while (la.kind == 32) {
 			lexer.NextToken();
 			SimpleExpr(
-#line  2102 "VBNET.ATG" 
+#line  2109 "VBNET.ATG" 
 out expr);
 
-#line  2102 "VBNET.ATG" 
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr);  
+#line  2109 "VBNET.ATG" 
+			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  
 		}
 	}
 
 	void NormalOrReDimArgumentList(
-#line  2622 "VBNET.ATG" 
+#line  2629 "VBNET.ATG" 
 out List<Expression> arguments, out bool canBeNormal, out bool canBeRedim) {
 
-#line  2624 "VBNET.ATG" 
+#line  2631 "VBNET.ATG" 
 		arguments = new List<Expression>();
 		canBeNormal = true; canBeRedim = !IsNamedAssign();
 		Expression expr = null;
 		
 		if (StartOf(24)) {
 			Argument(
-#line  2629 "VBNET.ATG" 
+#line  2636 "VBNET.ATG" 
 out expr);
 			if (la.kind == 216) {
 				lexer.NextToken();
 
-#line  2630 "VBNET.ATG" 
+#line  2637 "VBNET.ATG" 
 				EnsureIsZero(expr); canBeNormal = false; 
 				Expr(
-#line  2631 "VBNET.ATG" 
+#line  2638 "VBNET.ATG" 
 out expr);
 			}
 		}
 		while (la.kind == 22) {
 			lexer.NextToken();
 
-#line  2634 "VBNET.ATG" 
+#line  2641 "VBNET.ATG" 
 			if (expr == null) canBeRedim = false; 
 
-#line  2635 "VBNET.ATG" 
+#line  2642 "VBNET.ATG" 
 			arguments.Add(expr ?? Expression.Null); expr = null; 
 
-#line  2636 "VBNET.ATG" 
+#line  2643 "VBNET.ATG" 
 			canBeRedim &= !IsNamedAssign(); 
 			if (StartOf(24)) {
 				Argument(
-#line  2637 "VBNET.ATG" 
+#line  2644 "VBNET.ATG" 
 out expr);
 				if (la.kind == 216) {
 					lexer.NextToken();
 
-#line  2638 "VBNET.ATG" 
+#line  2645 "VBNET.ATG" 
 					EnsureIsZero(expr); canBeNormal = false; 
 					Expr(
-#line  2639 "VBNET.ATG" 
+#line  2646 "VBNET.ATG" 
 out expr);
 				}
 			}
 
-#line  2641 "VBNET.ATG" 
+#line  2648 "VBNET.ATG" 
 			if (expr == null) { canBeRedim = false; expr = Expression.Null; } 
 		}
 
-#line  2643 "VBNET.ATG" 
+#line  2650 "VBNET.ATG" 
 		if (expr != null) arguments.Add(expr); else canBeRedim = false; 
 	}
 
 	void ArrayTypeModifiers(
-#line  2751 "VBNET.ATG" 
+#line  2758 "VBNET.ATG" 
 out ArrayList arrayModifiers) {
 
-#line  2753 "VBNET.ATG" 
+#line  2760 "VBNET.ATG" 
 		arrayModifiers = new ArrayList();
 		int i = 0;
 		
 		while (
-#line  2756 "VBNET.ATG" 
+#line  2763 "VBNET.ATG" 
 IsDims()) {
 			Expect(37);
 			if (la.kind == 22 || la.kind == 38) {
 				RankList(
-#line  2758 "VBNET.ATG" 
+#line  2765 "VBNET.ATG" 
 out i);
 			}
 
-#line  2760 "VBNET.ATG" 
+#line  2767 "VBNET.ATG" 
 			arrayModifiers.Add(i);
 			
 			Expect(38);
 		}
 
-#line  2765 "VBNET.ATG" 
+#line  2772 "VBNET.ATG" 
 		if(arrayModifiers.Count == 0) {
 		 arrayModifiers = null;
 		}
@@ -5403,10 +5413,10 @@ out i);
 	}
 
 	void MemberInitializer(
-#line  2589 "VBNET.ATG" 
+#line  2596 "VBNET.ATG" 
 out MemberInitializerExpression memberInitializer) {
 
-#line  2591 "VBNET.ATG" 
+#line  2598 "VBNET.ATG" 
 		memberInitializer = new MemberInitializerExpression();
 		memberInitializer.StartLocation = la.Location;
 		Expression initExpr = null;
@@ -5416,19 +5426,19 @@ out MemberInitializerExpression memberInitializer) {
 		if (la.kind == 147) {
 			lexer.NextToken();
 
-#line  2597 "VBNET.ATG" 
+#line  2604 "VBNET.ATG" 
 			isKey = true; 
 		}
 		Expect(26);
 		IdentifierOrKeyword(
-#line  2598 "VBNET.ATG" 
+#line  2605 "VBNET.ATG" 
 out name);
 		Expect(20);
 		Expr(
-#line  2598 "VBNET.ATG" 
+#line  2605 "VBNET.ATG" 
 out initExpr);
 
-#line  2600 "VBNET.ATG" 
+#line  2607 "VBNET.ATG" 
 		memberInitializer.Name = name;
 		memberInitializer.Expression = initExpr;
 		memberInitializer.IsKey = isKey;
@@ -5437,10 +5447,10 @@ out initExpr);
 	}
 
 	void SubLambdaExpression(
-#line  2194 "VBNET.ATG" 
+#line  2201 "VBNET.ATG" 
 out LambdaExpression lambda) {
 
-#line  2196 "VBNET.ATG" 
+#line  2203 "VBNET.ATG" 
 		lambda = new LambdaExpression();
 		lambda.ReturnType = new TypeReference("System.Void", true);
 		Expression inner = null;
@@ -5452,7 +5462,7 @@ out LambdaExpression lambda) {
 			lexer.NextToken();
 			if (StartOf(6)) {
 				FormalParameterList(
-#line  2203 "VBNET.ATG" 
+#line  2210 "VBNET.ATG" 
 lambda.Parameters);
 			}
 			Expect(38);
@@ -5460,19 +5470,19 @@ lambda.Parameters);
 		if (StartOf(42)) {
 			if (StartOf(24)) {
 				Expr(
-#line  2206 "VBNET.ATG" 
+#line  2213 "VBNET.ATG" 
 out inner);
 
-#line  2208 "VBNET.ATG" 
+#line  2215 "VBNET.ATG" 
 				lambda.ExpressionBody = inner;
 				lambda.EndLocation = t.EndLocation; // la.Location?
 				
 			} else {
 				EmbeddedStatement(
-#line  2212 "VBNET.ATG" 
+#line  2219 "VBNET.ATG" 
 out statement);
 
-#line  2214 "VBNET.ATG" 
+#line  2221 "VBNET.ATG" 
 				lambda.StatementBody = statement;
 				lambda.EndLocation = t.EndLocation;
 				
@@ -5480,12 +5490,12 @@ out statement);
 		} else if (la.kind == 1) {
 			lexer.NextToken();
 			Block(
-#line  2220 "VBNET.ATG" 
+#line  2227 "VBNET.ATG" 
 out statement);
 			Expect(113);
 			Expect(210);
 
-#line  2223 "VBNET.ATG" 
+#line  2230 "VBNET.ATG" 
 			lambda.StatementBody = statement;
 			lambda.EndLocation = t.EndLocation;
 			
@@ -5493,10 +5503,10 @@ out statement);
 	}
 
 	void FunctionLambdaExpression(
-#line  2229 "VBNET.ATG" 
+#line  2236 "VBNET.ATG" 
 out LambdaExpression lambda) {
 
-#line  2231 "VBNET.ATG" 
+#line  2238 "VBNET.ATG" 
 		lambda = new LambdaExpression();
 		TypeReference typeRef = null;
 		Expression inner = null;
@@ -5508,7 +5518,7 @@ out LambdaExpression lambda) {
 			lexer.NextToken();
 			if (StartOf(6)) {
 				FormalParameterList(
-#line  2238 "VBNET.ATG" 
+#line  2245 "VBNET.ATG" 
 lambda.Parameters);
 			}
 			Expect(38);
@@ -5516,28 +5526,28 @@ lambda.Parameters);
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-#line  2239 "VBNET.ATG" 
+#line  2246 "VBNET.ATG" 
 out typeRef);
 
-#line  2239 "VBNET.ATG" 
+#line  2246 "VBNET.ATG" 
 			lambda.ReturnType = typeRef; 
 		}
 		if (StartOf(42)) {
 			if (StartOf(24)) {
 				Expr(
-#line  2242 "VBNET.ATG" 
+#line  2249 "VBNET.ATG" 
 out inner);
 
-#line  2244 "VBNET.ATG" 
+#line  2251 "VBNET.ATG" 
 				lambda.ExpressionBody = inner;
 				lambda.EndLocation = t.EndLocation; // la.Location?
 				
 			} else {
 				EmbeddedStatement(
-#line  2248 "VBNET.ATG" 
+#line  2255 "VBNET.ATG" 
 out statement);
 
-#line  2250 "VBNET.ATG" 
+#line  2257 "VBNET.ATG" 
 				lambda.StatementBody = statement;
 				lambda.EndLocation = t.EndLocation;
 				
@@ -5545,12 +5555,12 @@ out statement);
 		} else if (la.kind == 1) {
 			lexer.NextToken();
 			Block(
-#line  2256 "VBNET.ATG" 
+#line  2263 "VBNET.ATG" 
 out statement);
 			Expect(113);
 			Expect(127);
 
-#line  2259 "VBNET.ATG" 
+#line  2266 "VBNET.ATG" 
 			lambda.StatementBody = statement;
 			lambda.EndLocation = t.EndLocation;
 			
@@ -5558,10 +5568,10 @@ out statement);
 	}
 
 	void EmbeddedStatement(
-#line  3029 "VBNET.ATG" 
+#line  3036 "VBNET.ATG" 
 out Statement statement) {
 
-#line  3031 "VBNET.ATG" 
+#line  3038 "VBNET.ATG" 
 		Statement embeddedStatement = null;
 		statement = null;
 		Expression expr = null;
@@ -5572,224 +5582,224 @@ out Statement statement) {
 		if (la.kind == 120) {
 			lexer.NextToken();
 
-#line  3039 "VBNET.ATG" 
+#line  3046 "VBNET.ATG" 
 			ExitType exitType = ExitType.None; 
 			switch (la.kind) {
 			case 210: {
 				lexer.NextToken();
 
-#line  3041 "VBNET.ATG" 
+#line  3048 "VBNET.ATG" 
 				exitType = ExitType.Sub; 
 				break;
 			}
 			case 127: {
 				lexer.NextToken();
 
-#line  3043 "VBNET.ATG" 
+#line  3050 "VBNET.ATG" 
 				exitType = ExitType.Function; 
 				break;
 			}
 			case 186: {
 				lexer.NextToken();
 
-#line  3045 "VBNET.ATG" 
+#line  3052 "VBNET.ATG" 
 				exitType = ExitType.Property; 
 				break;
 			}
 			case 108: {
 				lexer.NextToken();
 
-#line  3047 "VBNET.ATG" 
+#line  3054 "VBNET.ATG" 
 				exitType = ExitType.Do; 
 				break;
 			}
 			case 124: {
 				lexer.NextToken();
 
-#line  3049 "VBNET.ATG" 
+#line  3056 "VBNET.ATG" 
 				exitType = ExitType.For; 
 				break;
 			}
 			case 218: {
 				lexer.NextToken();
 
-#line  3051 "VBNET.ATG" 
+#line  3058 "VBNET.ATG" 
 				exitType = ExitType.Try; 
 				break;
 			}
 			case 231: {
 				lexer.NextToken();
 
-#line  3053 "VBNET.ATG" 
+#line  3060 "VBNET.ATG" 
 				exitType = ExitType.While; 
 				break;
 			}
 			case 197: {
 				lexer.NextToken();
 
-#line  3055 "VBNET.ATG" 
+#line  3062 "VBNET.ATG" 
 				exitType = ExitType.Select; 
 				break;
 			}
 			default: SynErr(298); break;
 			}
 
-#line  3057 "VBNET.ATG" 
+#line  3064 "VBNET.ATG" 
 			statement = new ExitStatement(exitType); 
 		} else if (la.kind == 218) {
 			TryStatement(
-#line  3058 "VBNET.ATG" 
+#line  3065 "VBNET.ATG" 
 out statement);
 		} else if (la.kind == 89) {
 			lexer.NextToken();
 
-#line  3059 "VBNET.ATG" 
+#line  3066 "VBNET.ATG" 
 			ContinueType continueType = ContinueType.None; 
 			if (la.kind == 108 || la.kind == 124 || la.kind == 231) {
 				if (la.kind == 108) {
 					lexer.NextToken();
 
-#line  3059 "VBNET.ATG" 
+#line  3066 "VBNET.ATG" 
 					continueType = ContinueType.Do; 
 				} else if (la.kind == 124) {
 					lexer.NextToken();
 
-#line  3059 "VBNET.ATG" 
+#line  3066 "VBNET.ATG" 
 					continueType = ContinueType.For; 
 				} else {
 					lexer.NextToken();
 
-#line  3059 "VBNET.ATG" 
+#line  3066 "VBNET.ATG" 
 					continueType = ContinueType.While; 
 				}
 			}
 
-#line  3059 "VBNET.ATG" 
+#line  3066 "VBNET.ATG" 
 			statement = new ContinueStatement(continueType); 
 		} else if (la.kind == 215) {
 			lexer.NextToken();
 			if (StartOf(24)) {
 				Expr(
-#line  3061 "VBNET.ATG" 
+#line  3068 "VBNET.ATG" 
 out expr);
 			}
 
-#line  3061 "VBNET.ATG" 
+#line  3068 "VBNET.ATG" 
 			statement = new ThrowStatement(expr); 
 		} else if (la.kind == 195) {
 			lexer.NextToken();
 			if (StartOf(24)) {
 				Expr(
-#line  3063 "VBNET.ATG" 
+#line  3070 "VBNET.ATG" 
 out expr);
 			}
 
-#line  3063 "VBNET.ATG" 
+#line  3070 "VBNET.ATG" 
 			statement = new ReturnStatement(expr); 
 		} else if (la.kind == 211) {
 			lexer.NextToken();
 			Expr(
-#line  3065 "VBNET.ATG" 
+#line  3072 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  3065 "VBNET.ATG" 
+#line  3072 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(113);
 			Expect(211);
 
-#line  3066 "VBNET.ATG" 
+#line  3073 "VBNET.ATG" 
 			statement = new LockStatement(expr, embeddedStatement); 
 		} else if (la.kind == 189) {
 			lexer.NextToken();
 			Identifier();
 
-#line  3068 "VBNET.ATG" 
+#line  3075 "VBNET.ATG" 
 			name = t.val; 
 			if (la.kind == 37) {
 				lexer.NextToken();
 				if (StartOf(43)) {
 					ArgumentList(
-#line  3069 "VBNET.ATG" 
+#line  3076 "VBNET.ATG" 
 out p);
 				}
 				Expect(38);
 			}
 
-#line  3071 "VBNET.ATG" 
+#line  3078 "VBNET.ATG" 
 			statement = new RaiseEventStatement(name, p);
 			
 		} else if (la.kind == 233) {
 			WithStatement(
-#line  3074 "VBNET.ATG" 
+#line  3081 "VBNET.ATG" 
 out statement);
 		} else if (la.kind == 56) {
 			lexer.NextToken();
 
-#line  3076 "VBNET.ATG" 
+#line  3083 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  3077 "VBNET.ATG" 
+#line  3084 "VBNET.ATG" 
 out expr);
 			Expect(22);
 			Expr(
-#line  3077 "VBNET.ATG" 
+#line  3084 "VBNET.ATG" 
 out handlerExpr);
 
-#line  3079 "VBNET.ATG" 
+#line  3086 "VBNET.ATG" 
 			statement = new AddHandlerStatement(expr, handlerExpr);
 			
 		} else if (la.kind == 193) {
 			lexer.NextToken();
 
-#line  3082 "VBNET.ATG" 
+#line  3089 "VBNET.ATG" 
 			Expression handlerExpr = null; 
 			Expr(
-#line  3083 "VBNET.ATG" 
+#line  3090 "VBNET.ATG" 
 out expr);
 			Expect(22);
 			Expr(
-#line  3083 "VBNET.ATG" 
+#line  3090 "VBNET.ATG" 
 out handlerExpr);
 
-#line  3085 "VBNET.ATG" 
+#line  3092 "VBNET.ATG" 
 			statement = new RemoveHandlerStatement(expr, handlerExpr);
 			
 		} else if (la.kind == 231) {
 			lexer.NextToken();
 			Expr(
-#line  3088 "VBNET.ATG" 
+#line  3095 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 			Block(
-#line  3089 "VBNET.ATG" 
+#line  3096 "VBNET.ATG" 
 out embeddedStatement);
 			Expect(113);
 			Expect(231);
 
-#line  3091 "VBNET.ATG" 
+#line  3098 "VBNET.ATG" 
 			statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
 			
 		} else if (la.kind == 108) {
 			lexer.NextToken();
 
-#line  3096 "VBNET.ATG" 
+#line  3103 "VBNET.ATG" 
 			ConditionType conditionType = ConditionType.None;
 			
 			if (la.kind == 224 || la.kind == 231) {
 				WhileOrUntil(
-#line  3099 "VBNET.ATG" 
+#line  3106 "VBNET.ATG" 
 out conditionType);
 				Expr(
-#line  3099 "VBNET.ATG" 
+#line  3106 "VBNET.ATG" 
 out expr);
 				EndOfStmt();
 				Block(
-#line  3100 "VBNET.ATG" 
+#line  3107 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(152);
 
-#line  3103 "VBNET.ATG" 
+#line  3110 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, 
 				                               embeddedStatement, 
 				                               conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, 
@@ -5798,26 +5808,26 @@ out embeddedStatement);
 			} else if (la.kind == 1 || la.kind == 21) {
 				EndOfStmt();
 				Block(
-#line  3110 "VBNET.ATG" 
+#line  3117 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(152);
 				if (la.kind == 224 || la.kind == 231) {
 					WhileOrUntil(
-#line  3111 "VBNET.ATG" 
+#line  3118 "VBNET.ATG" 
 out conditionType);
 					Expr(
-#line  3111 "VBNET.ATG" 
+#line  3118 "VBNET.ATG" 
 out expr);
 				}
 
-#line  3113 "VBNET.ATG" 
+#line  3120 "VBNET.ATG" 
 				statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End);
 				
 			} else SynErr(299);
 		} else if (la.kind == 124) {
 			lexer.NextToken();
 
-#line  3118 "VBNET.ATG" 
+#line  3125 "VBNET.ATG" 
 			Expression group = null;
 			TypeReference typeReference;
 			string        typeName;
@@ -5825,24 +5835,24 @@ out expr);
 			if (la.kind == 110) {
 				lexer.NextToken();
 				LoopControlVariable(
-#line  3124 "VBNET.ATG" 
+#line  3131 "VBNET.ATG" 
 out typeReference, out typeName);
 				Expect(138);
 				Expr(
-#line  3125 "VBNET.ATG" 
+#line  3132 "VBNET.ATG" 
 out group);
 				EndOfStmt();
 				Block(
-#line  3126 "VBNET.ATG" 
+#line  3133 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(163);
 				if (StartOf(24)) {
 					Expr(
-#line  3127 "VBNET.ATG" 
+#line  3134 "VBNET.ATG" 
 out expr);
 				}
 
-#line  3129 "VBNET.ATG" 
+#line  3136 "VBNET.ATG" 
 				statement = new ForeachStatement(typeReference, 
 				                                typeName,
 				                                group, 
@@ -5854,7 +5864,7 @@ out expr);
 				
 			} else if (StartOf(44)) {
 
-#line  3140 "VBNET.ATG" 
+#line  3147 "VBNET.ATG" 
 				Expression start = null;
 				Expression end = null;
 				Expression step = null;
@@ -5863,59 +5873,59 @@ out expr);
 				List<Expression> nextExpressions = null;
 				
 				if (
-#line  3147 "VBNET.ATG" 
+#line  3154 "VBNET.ATG" 
 IsLoopVariableDeclaration()) {
 					LoopControlVariable(
-#line  3148 "VBNET.ATG" 
+#line  3155 "VBNET.ATG" 
 out typeReference, out typeName);
 				} else {
 
-#line  3150 "VBNET.ATG" 
+#line  3157 "VBNET.ATG" 
 					typeReference = null; typeName = null; 
 					SimpleExpr(
-#line  3151 "VBNET.ATG" 
+#line  3158 "VBNET.ATG" 
 out variableExpr);
 				}
 				Expect(20);
 				Expr(
-#line  3153 "VBNET.ATG" 
+#line  3160 "VBNET.ATG" 
 out start);
 				Expect(216);
 				Expr(
-#line  3153 "VBNET.ATG" 
+#line  3160 "VBNET.ATG" 
 out end);
 				if (la.kind == 205) {
 					lexer.NextToken();
 					Expr(
-#line  3153 "VBNET.ATG" 
+#line  3160 "VBNET.ATG" 
 out step);
 				}
 				EndOfStmt();
 				Block(
-#line  3154 "VBNET.ATG" 
+#line  3161 "VBNET.ATG" 
 out embeddedStatement);
 				Expect(163);
 				if (StartOf(24)) {
 					Expr(
-#line  3157 "VBNET.ATG" 
+#line  3164 "VBNET.ATG" 
 out nextExpr);
 
-#line  3159 "VBNET.ATG" 
+#line  3166 "VBNET.ATG" 
 					nextExpressions = new List<Expression>();
 					nextExpressions.Add(nextExpr);
 					
 					while (la.kind == 22) {
 						lexer.NextToken();
 						Expr(
-#line  3162 "VBNET.ATG" 
+#line  3169 "VBNET.ATG" 
 out nextExpr);
 
-#line  3162 "VBNET.ATG" 
+#line  3169 "VBNET.ATG" 
 						nextExpressions.Add(nextExpr); 
 					}
 				}
 
-#line  3165 "VBNET.ATG" 
+#line  3172 "VBNET.ATG" 
 				statement = new ForNextStatement {
 				TypeReference = typeReference,
 				VariableName = typeName, 
@@ -5931,27 +5941,27 @@ out nextExpr);
 		} else if (la.kind == 118) {
 			lexer.NextToken();
 			Expr(
-#line  3178 "VBNET.ATG" 
+#line  3185 "VBNET.ATG" 
 out expr);
 
-#line  3178 "VBNET.ATG" 
+#line  3185 "VBNET.ATG" 
 			statement = new ErrorStatement(expr); 
 		} else if (la.kind == 191) {
 			lexer.NextToken();
 
-#line  3180 "VBNET.ATG" 
+#line  3187 "VBNET.ATG" 
 			bool isPreserve = false; 
 			if (la.kind == 184) {
 				lexer.NextToken();
 
-#line  3180 "VBNET.ATG" 
+#line  3187 "VBNET.ATG" 
 				isPreserve = true; 
 			}
 			ReDimClause(
-#line  3181 "VBNET.ATG" 
+#line  3188 "VBNET.ATG" 
 out expr);
 
-#line  3183 "VBNET.ATG" 
+#line  3190 "VBNET.ATG" 
 			ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
 			statement = reDimStatement;
 			SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
@@ -5959,48 +5969,48 @@ out expr);
 			while (la.kind == 22) {
 				lexer.NextToken();
 				ReDimClause(
-#line  3187 "VBNET.ATG" 
+#line  3194 "VBNET.ATG" 
 out expr);
 
-#line  3188 "VBNET.ATG" 
+#line  3195 "VBNET.ATG" 
 				SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression); 
 			}
 		} else if (la.kind == 117) {
 			lexer.NextToken();
 			Expr(
-#line  3192 "VBNET.ATG" 
+#line  3199 "VBNET.ATG" 
 out expr);
 
-#line  3194 "VBNET.ATG" 
+#line  3201 "VBNET.ATG" 
 			EraseStatement eraseStatement = new EraseStatement();
 			if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr);}
 			
 			while (la.kind == 22) {
 				lexer.NextToken();
 				Expr(
-#line  3197 "VBNET.ATG" 
+#line  3204 "VBNET.ATG" 
 out expr);
 
-#line  3197 "VBNET.ATG" 
+#line  3204 "VBNET.ATG" 
 				if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr); }
 			}
 
-#line  3198 "VBNET.ATG" 
+#line  3205 "VBNET.ATG" 
 			statement = eraseStatement; 
 		} else if (la.kind == 206) {
 			lexer.NextToken();
 
-#line  3200 "VBNET.ATG" 
+#line  3207 "VBNET.ATG" 
 			statement = new StopStatement(); 
 		} else if (
-#line  3202 "VBNET.ATG" 
+#line  3209 "VBNET.ATG" 
 la.kind == Tokens.If) {
 			Expect(135);
 
-#line  3203 "VBNET.ATG" 
+#line  3210 "VBNET.ATG" 
 			Location ifStartLocation = t.Location; 
 			Expr(
-#line  3203 "VBNET.ATG" 
+#line  3210 "VBNET.ATG" 
 out expr);
 			if (la.kind == 214) {
 				lexer.NextToken();
@@ -6008,46 +6018,46 @@ out expr);
 			if (la.kind == 1 || la.kind == 21) {
 				EndOfStmt();
 				Block(
-#line  3206 "VBNET.ATG" 
+#line  3213 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  3208 "VBNET.ATG" 
+#line  3215 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
 				ifStatement.StartLocation = ifStartLocation;
 				Location elseIfStart;
 				
 				while (la.kind == 112 || 
-#line  3214 "VBNET.ATG" 
+#line  3221 "VBNET.ATG" 
 IsElseIf()) {
 					if (
-#line  3214 "VBNET.ATG" 
+#line  3221 "VBNET.ATG" 
 IsElseIf()) {
 						Expect(111);
 
-#line  3214 "VBNET.ATG" 
+#line  3221 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 						Expect(135);
 					} else {
 						lexer.NextToken();
 
-#line  3215 "VBNET.ATG" 
+#line  3222 "VBNET.ATG" 
 						elseIfStart = t.Location; 
 					}
 
-#line  3217 "VBNET.ATG" 
+#line  3224 "VBNET.ATG" 
 					Expression condition = null; Statement block = null; 
 					Expr(
-#line  3218 "VBNET.ATG" 
+#line  3225 "VBNET.ATG" 
 out condition);
 					if (la.kind == 214) {
 						lexer.NextToken();
 					}
 					EndOfStmt();
 					Block(
-#line  3219 "VBNET.ATG" 
+#line  3226 "VBNET.ATG" 
 out block);
 
-#line  3221 "VBNET.ATG" 
+#line  3228 "VBNET.ATG" 
 					ElseIfSection elseIfSection = new ElseIfSection(condition, block);
 					elseIfSection.StartLocation = elseIfStart;
 					elseIfSection.EndLocation = t.Location;
@@ -6061,39 +6071,39 @@ out block);
 						EndOfStmt();
 					}
 					Block(
-#line  3230 "VBNET.ATG" 
+#line  3237 "VBNET.ATG" 
 out embeddedStatement);
 
-#line  3232 "VBNET.ATG" 
+#line  3239 "VBNET.ATG" 
 					ifStatement.FalseStatement.Add(embeddedStatement);
 					
 				}
 				Expect(113);
 				Expect(135);
 
-#line  3236 "VBNET.ATG" 
+#line  3243 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location;
 				statement = ifStatement;
 				
 			} else if (StartOf(45)) {
 
-#line  3241 "VBNET.ATG" 
+#line  3248 "VBNET.ATG" 
 				IfElseStatement ifStatement = new IfElseStatement(expr);
 				ifStatement.StartLocation = ifStartLocation;
 				
 				SingleLineStatementList(
-#line  3244 "VBNET.ATG" 
+#line  3251 "VBNET.ATG" 
 ifStatement.TrueStatement);
 				if (la.kind == 111) {
 					lexer.NextToken();
 					if (StartOf(45)) {
 						SingleLineStatementList(
-#line  3247 "VBNET.ATG" 
+#line  3254 "VBNET.ATG" 
 ifStatement.FalseStatement);
 					}
 				}
 
-#line  3249 "VBNET.ATG" 
+#line  3256 "VBNET.ATG" 
 				ifStatement.EndLocation = t.Location; statement = ifStatement; 
 			} else SynErr(301);
 		} else if (la.kind == 197) {
@@ -6102,82 +6112,82 @@ ifStatement.FalseStatement);
 				lexer.NextToken();
 			}
 			Expr(
-#line  3252 "VBNET.ATG" 
+#line  3259 "VBNET.ATG" 
 out expr);
 			EndOfStmt();
 
-#line  3253 "VBNET.ATG" 
+#line  3260 "VBNET.ATG" 
 			List<SwitchSection> selectSections = new List<SwitchSection>();
 			Statement block = null;
 			
 			while (la.kind == 74) {
 
-#line  3257 "VBNET.ATG" 
+#line  3264 "VBNET.ATG" 
 				List<CaseLabel> caseClauses = null; Location caseLocation = la.Location; 
 				lexer.NextToken();
 				CaseClauses(
-#line  3258 "VBNET.ATG" 
+#line  3265 "VBNET.ATG" 
 out caseClauses);
 				if (
-#line  3258 "VBNET.ATG" 
+#line  3265 "VBNET.ATG" 
 IsNotStatementSeparator()) {
 					lexer.NextToken();
 				}
 				EndOfStmt();
 
-#line  3260 "VBNET.ATG" 
+#line  3267 "VBNET.ATG" 
 				SwitchSection selectSection = new SwitchSection(caseClauses);
 				selectSection.StartLocation = caseLocation;
 				
 				Block(
-#line  3263 "VBNET.ATG" 
+#line  3270 "VBNET.ATG" 
 out block);
 
-#line  3265 "VBNET.ATG" 
+#line  3272 "VBNET.ATG" 
 				selectSection.Children = block.Children;
 				selectSection.EndLocation = t.EndLocation;
 				selectSections.Add(selectSection);
 				
 			}
 
-#line  3271 "VBNET.ATG" 
+#line  3278 "VBNET.ATG" 
 			statement = new SwitchStatement(expr, selectSections);
 			
 			Expect(113);
 			Expect(197);
 		} else if (la.kind == 171) {
 
-#line  3274 "VBNET.ATG" 
+#line  3281 "VBNET.ATG" 
 			OnErrorStatement onErrorStatement = null; 
 			OnErrorStatement(
-#line  3275 "VBNET.ATG" 
+#line  3282 "VBNET.ATG" 
 out onErrorStatement);
 
-#line  3275 "VBNET.ATG" 
+#line  3282 "VBNET.ATG" 
 			statement = onErrorStatement; 
 		} else if (la.kind == 132) {
 
-#line  3276 "VBNET.ATG" 
+#line  3283 "VBNET.ATG" 
 			GotoStatement goToStatement = null; 
 			GotoStatement(
-#line  3277 "VBNET.ATG" 
+#line  3284 "VBNET.ATG" 
 out goToStatement);
 
-#line  3277 "VBNET.ATG" 
+#line  3284 "VBNET.ATG" 
 			statement = goToStatement; 
 		} else if (la.kind == 194) {
 
-#line  3278 "VBNET.ATG" 
+#line  3285 "VBNET.ATG" 
 			ResumeStatement resumeStatement = null; 
 			ResumeStatement(
-#line  3279 "VBNET.ATG" 
+#line  3286 "VBNET.ATG" 
 out resumeStatement);
 
-#line  3279 "VBNET.ATG" 
+#line  3286 "VBNET.ATG" 
 			statement = resumeStatement; 
 		} else if (StartOf(44)) {
 
-#line  3282 "VBNET.ATG" 
+#line  3289 "VBNET.ATG" 
 			Expression val = null;
 			AssignmentOperatorType op;
 			Location startLoc = la.Location;
@@ -6186,28 +6196,28 @@ out resumeStatement);
 			                        la.kind == Tokens.Not   || la.kind == Tokens.Times;
 			
 			SimpleExpr(
-#line  3289 "VBNET.ATG" 
+#line  3296 "VBNET.ATG" 
 out expr);
 			if (StartOf(46)) {
 				AssignmentOperator(
-#line  3291 "VBNET.ATG" 
+#line  3298 "VBNET.ATG" 
 out op);
 				Expr(
-#line  3291 "VBNET.ATG" 
+#line  3298 "VBNET.ATG" 
 out val);
 
-#line  3293 "VBNET.ATG" 
+#line  3300 "VBNET.ATG" 
 				expr = new AssignmentExpression(expr, op, val);
 				expr.StartLocation = startLoc;
 				expr.EndLocation = t.EndLocation;
 				
 			} else if (StartOf(47)) {
 
-#line  3297 "VBNET.ATG" 
+#line  3304 "VBNET.ATG" 
 				if (mustBeAssignment) Error("error in assignment."); 
 			} else SynErr(302);
 
-#line  3300 "VBNET.ATG" 
+#line  3307 "VBNET.ATG" 
 			// a field reference expression that stands alone is a
 			// invocation expression without parantheses and arguments
 			if(expr is MemberReferenceExpression || expr is IdentifierExpression) {
@@ -6218,58 +6228,58 @@ out val);
 		} else if (la.kind == 73) {
 			lexer.NextToken();
 			SimpleExpr(
-#line  3307 "VBNET.ATG" 
+#line  3314 "VBNET.ATG" 
 out expr);
 
-#line  3307 "VBNET.ATG" 
+#line  3314 "VBNET.ATG" 
 			statement = new ExpressionStatement(expr); 
 		} else if (la.kind == 226) {
 			lexer.NextToken();
 
-#line  3309 "VBNET.ATG" 
+#line  3316 "VBNET.ATG" 
 			Statement block;  
 			if (
-#line  3310 "VBNET.ATG" 
+#line  3317 "VBNET.ATG" 
 Peek(1).kind == Tokens.As) {
 
-#line  3311 "VBNET.ATG" 
+#line  3318 "VBNET.ATG" 
 				LocalVariableDeclaration resourceAquisition = new LocalVariableDeclaration(Modifiers.None); 
 				VariableDeclarator(
-#line  3312 "VBNET.ATG" 
+#line  3319 "VBNET.ATG" 
 resourceAquisition.Variables);
 				while (la.kind == 22) {
 					lexer.NextToken();
 					VariableDeclarator(
-#line  3314 "VBNET.ATG" 
+#line  3321 "VBNET.ATG" 
 resourceAquisition.Variables);
 				}
 				Block(
-#line  3316 "VBNET.ATG" 
+#line  3323 "VBNET.ATG" 
 out block);
 
-#line  3318 "VBNET.ATG" 
+#line  3325 "VBNET.ATG" 
 				statement = new UsingStatement(resourceAquisition, block);
 				
 			} else if (StartOf(24)) {
 				Expr(
-#line  3320 "VBNET.ATG" 
+#line  3327 "VBNET.ATG" 
 out expr);
 				Block(
-#line  3321 "VBNET.ATG" 
+#line  3328 "VBNET.ATG" 
 out block);
 
-#line  3322 "VBNET.ATG" 
+#line  3329 "VBNET.ATG" 
 				statement = new UsingStatement(new ExpressionStatement(expr), block); 
 			} else SynErr(303);
 			Expect(113);
 			Expect(226);
 		} else if (StartOf(48)) {
 			LocalDeclarationStatement(
-#line  3325 "VBNET.ATG" 
+#line  3332 "VBNET.ATG" 
 out statement);
 		} else SynErr(304);
 
-#line  3328 "VBNET.ATG" 
+#line  3335 "VBNET.ATG" 
 		if (statement != null) {
 		statement.StartLocation = startLocation;
 		statement.EndLocation = t.EndLocation;
@@ -6278,35 +6288,35 @@ out statement);
 	}
 
 	void FromOrAggregateQueryOperator(
-#line  2278 "VBNET.ATG" 
+#line  2285 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2280 "VBNET.ATG" 
+#line  2287 "VBNET.ATG" 
 		QueryExpressionFromClause fromClause = null;
 		QueryExpressionAggregateClause aggregateClause = null;
 		
 		if (la.kind == 126) {
 			FromQueryOperator(
-#line  2283 "VBNET.ATG" 
+#line  2290 "VBNET.ATG" 
 out fromClause);
 
-#line  2284 "VBNET.ATG" 
+#line  2291 "VBNET.ATG" 
 			middleClauses.Add(fromClause); 
 		} else if (la.kind == 58) {
 			AggregateQueryOperator(
-#line  2285 "VBNET.ATG" 
+#line  2292 "VBNET.ATG" 
 out aggregateClause);
 
-#line  2286 "VBNET.ATG" 
+#line  2293 "VBNET.ATG" 
 			middleClauses.Add(aggregateClause); 
 		} else SynErr(305);
 	}
 
 	void QueryOperator(
-#line  2289 "VBNET.ATG" 
+#line  2296 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2291 "VBNET.ATG" 
+#line  2298 "VBNET.ATG" 
 		QueryExpressionJoinVBClause joinClause = null;
 		QueryExpressionGroupVBClause groupByClause = null;
 		QueryExpressionPartitionVBClause partitionClause = null;
@@ -6316,94 +6326,94 @@ List<QueryExpressionClause> middleClauses) {
 		
 		if (la.kind == 126) {
 			FromQueryOperator(
-#line  2298 "VBNET.ATG" 
+#line  2305 "VBNET.ATG" 
 out fromClause);
 
-#line  2299 "VBNET.ATG" 
+#line  2306 "VBNET.ATG" 
 			middleClauses.Add(fromClause); 
 		} else if (la.kind == 58) {
 			AggregateQueryOperator(
-#line  2300 "VBNET.ATG" 
+#line  2307 "VBNET.ATG" 
 out aggregateClause);
 
-#line  2301 "VBNET.ATG" 
+#line  2308 "VBNET.ATG" 
 			middleClauses.Add(aggregateClause); 
 		} else if (la.kind == 197) {
 			SelectQueryOperator(
-#line  2302 "VBNET.ATG" 
+#line  2309 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 107) {
 			DistinctQueryOperator(
-#line  2303 "VBNET.ATG" 
+#line  2310 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 230) {
 			WhereQueryOperator(
-#line  2304 "VBNET.ATG" 
+#line  2311 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 176) {
 			OrderByQueryOperator(
-#line  2305 "VBNET.ATG" 
+#line  2312 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 203 || la.kind == 212) {
 			PartitionQueryOperator(
-#line  2306 "VBNET.ATG" 
+#line  2313 "VBNET.ATG" 
 out partitionClause);
 
-#line  2307 "VBNET.ATG" 
+#line  2314 "VBNET.ATG" 
 			middleClauses.Add(partitionClause); 
 		} else if (la.kind == 148) {
 			LetQueryOperator(
-#line  2308 "VBNET.ATG" 
+#line  2315 "VBNET.ATG" 
 middleClauses);
 		} else if (la.kind == 146) {
 			JoinQueryOperator(
-#line  2309 "VBNET.ATG" 
+#line  2316 "VBNET.ATG" 
 out joinClause);
 
-#line  2310 "VBNET.ATG" 
+#line  2317 "VBNET.ATG" 
 			middleClauses.Add(joinClause); 
 		} else if (
-#line  2311 "VBNET.ATG" 
+#line  2318 "VBNET.ATG" 
 la.kind == Tokens.Group && Peek(1).kind == Tokens.Join) {
 			GroupJoinQueryOperator(
-#line  2311 "VBNET.ATG" 
+#line  2318 "VBNET.ATG" 
 out groupJoinClause);
 
-#line  2312 "VBNET.ATG" 
+#line  2319 "VBNET.ATG" 
 			middleClauses.Add(groupJoinClause); 
 		} else if (la.kind == 133) {
 			GroupByQueryOperator(
-#line  2313 "VBNET.ATG" 
+#line  2320 "VBNET.ATG" 
 out groupByClause);
 
-#line  2314 "VBNET.ATG" 
+#line  2321 "VBNET.ATG" 
 			middleClauses.Add(groupByClause); 
 		} else SynErr(306);
 	}
 
 	void FromQueryOperator(
-#line  2389 "VBNET.ATG" 
+#line  2396 "VBNET.ATG" 
 out QueryExpressionFromClause fromClause) {
 
-#line  2391 "VBNET.ATG" 
+#line  2398 "VBNET.ATG" 
 		fromClause = new QueryExpressionFromClause();
 		fromClause.StartLocation = la.Location;
 		
 		Expect(126);
 		CollectionRangeVariableDeclarationList(
-#line  2394 "VBNET.ATG" 
+#line  2401 "VBNET.ATG" 
 fromClause.Sources);
 
-#line  2396 "VBNET.ATG" 
+#line  2403 "VBNET.ATG" 
 		fromClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void AggregateQueryOperator(
-#line  2458 "VBNET.ATG" 
+#line  2465 "VBNET.ATG" 
 out QueryExpressionAggregateClause aggregateClause) {
 
-#line  2460 "VBNET.ATG" 
+#line  2467 "VBNET.ATG" 
 		aggregateClause = new QueryExpressionAggregateClause();
 		aggregateClause.IntoVariables = new List<ExpressionRangeVariable>();
 		aggregateClause.StartLocation = la.Location;
@@ -6411,77 +6421,77 @@ out QueryExpressionAggregateClause aggregateClause) {
 		
 		Expect(58);
 		CollectionRangeVariableDeclaration(
-#line  2465 "VBNET.ATG" 
+#line  2472 "VBNET.ATG" 
 out source);
 
-#line  2467 "VBNET.ATG" 
+#line  2474 "VBNET.ATG" 
 		aggregateClause.Source = source;
 		
 		while (StartOf(31)) {
 			QueryOperator(
-#line  2470 "VBNET.ATG" 
+#line  2477 "VBNET.ATG" 
 aggregateClause.MiddleClauses);
 		}
 		Expect(143);
 		ExpressionRangeVariableDeclarationList(
-#line  2472 "VBNET.ATG" 
+#line  2479 "VBNET.ATG" 
 aggregateClause.IntoVariables);
 
-#line  2474 "VBNET.ATG" 
+#line  2481 "VBNET.ATG" 
 		aggregateClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void SelectQueryOperator(
-#line  2400 "VBNET.ATG" 
+#line  2407 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2402 "VBNET.ATG" 
+#line  2409 "VBNET.ATG" 
 		QueryExpressionSelectVBClause selectClause = new QueryExpressionSelectVBClause();
 		selectClause.StartLocation = la.Location;
 		
 		Expect(197);
 		ExpressionRangeVariableDeclarationList(
-#line  2405 "VBNET.ATG" 
+#line  2412 "VBNET.ATG" 
 selectClause.Variables);
 
-#line  2407 "VBNET.ATG" 
+#line  2414 "VBNET.ATG" 
 		selectClause.EndLocation = t.Location;
 		middleClauses.Add(selectClause);
 		
 	}
 
 	void DistinctQueryOperator(
-#line  2412 "VBNET.ATG" 
+#line  2419 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2414 "VBNET.ATG" 
+#line  2421 "VBNET.ATG" 
 		QueryExpressionDistinctClause distinctClause = new QueryExpressionDistinctClause();
 		distinctClause.StartLocation = la.Location;
 		
 		Expect(107);
 
-#line  2419 "VBNET.ATG" 
+#line  2426 "VBNET.ATG" 
 		distinctClause.EndLocation = t.EndLocation;
 		middleClauses.Add(distinctClause);
 		
 	}
 
 	void WhereQueryOperator(
-#line  2424 "VBNET.ATG" 
+#line  2431 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2426 "VBNET.ATG" 
+#line  2433 "VBNET.ATG" 
 		QueryExpressionWhereClause whereClause = new QueryExpressionWhereClause();
 		whereClause.StartLocation = la.Location;
 		Expression operand = null;
 		
 		Expect(230);
 		Expr(
-#line  2430 "VBNET.ATG" 
+#line  2437 "VBNET.ATG" 
 out operand);
 
-#line  2432 "VBNET.ATG" 
+#line  2439 "VBNET.ATG" 
 		whereClause.Condition = operand;
 		whereClause.EndLocation = t.EndLocation;
 		
@@ -6490,10 +6500,10 @@ out operand);
 	}
 
 	void OrderByQueryOperator(
-#line  2317 "VBNET.ATG" 
+#line  2324 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2319 "VBNET.ATG" 
+#line  2326 "VBNET.ATG" 
 		QueryExpressionOrderClause orderClause = new QueryExpressionOrderClause();
 		orderClause.StartLocation = la.Location;
 		List<QueryExpressionOrdering> orderings = null;
@@ -6501,10 +6511,10 @@ List<QueryExpressionClause> middleClauses) {
 		Expect(176);
 		Expect(70);
 		OrderExpressionList(
-#line  2323 "VBNET.ATG" 
+#line  2330 "VBNET.ATG" 
 out orderings);
 
-#line  2325 "VBNET.ATG" 
+#line  2332 "VBNET.ATG" 
 		orderClause.Orderings = orderings;
 		orderClause.EndLocation = t.EndLocation;
 		middleClauses.Add(orderClause);
@@ -6512,10 +6522,10 @@ out orderings);
 	}
 
 	void PartitionQueryOperator(
-#line  2439 "VBNET.ATG" 
+#line  2446 "VBNET.ATG" 
 out QueryExpressionPartitionVBClause partitionClause) {
 
-#line  2441 "VBNET.ATG" 
+#line  2448 "VBNET.ATG" 
 		partitionClause = new QueryExpressionPartitionVBClause();
 		partitionClause.StartLocation = la.Location;
 		Expression expr = null;
@@ -6523,60 +6533,60 @@ out QueryExpressionPartitionVBClause partitionClause) {
 		if (la.kind == 212) {
 			lexer.NextToken();
 
-#line  2446 "VBNET.ATG" 
+#line  2453 "VBNET.ATG" 
 			partitionClause.PartitionType = QueryExpressionPartitionType.Take; 
 			if (la.kind == 231) {
 				lexer.NextToken();
 
-#line  2447 "VBNET.ATG" 
+#line  2454 "VBNET.ATG" 
 				partitionClause.PartitionType = QueryExpressionPartitionType.TakeWhile; 
 			}
 		} else if (la.kind == 203) {
 			lexer.NextToken();
 
-#line  2448 "VBNET.ATG" 
+#line  2455 "VBNET.ATG" 
 			partitionClause.PartitionType = QueryExpressionPartitionType.Skip; 
 			if (la.kind == 231) {
 				lexer.NextToken();
 
-#line  2449 "VBNET.ATG" 
+#line  2456 "VBNET.ATG" 
 				partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile; 
 			}
 		} else SynErr(307);
 		Expr(
-#line  2451 "VBNET.ATG" 
+#line  2458 "VBNET.ATG" 
 out expr);
 
-#line  2453 "VBNET.ATG" 
+#line  2460 "VBNET.ATG" 
 		partitionClause.Expression = expr;
 		partitionClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void LetQueryOperator(
-#line  2478 "VBNET.ATG" 
+#line  2485 "VBNET.ATG" 
 List<QueryExpressionClause> middleClauses) {
 
-#line  2480 "VBNET.ATG" 
+#line  2487 "VBNET.ATG" 
 		QueryExpressionLetVBClause letClause = new QueryExpressionLetVBClause();
 		letClause.StartLocation = la.Location;
 		
 		Expect(148);
 		ExpressionRangeVariableDeclarationList(
-#line  2483 "VBNET.ATG" 
+#line  2490 "VBNET.ATG" 
 letClause.Variables);
 
-#line  2485 "VBNET.ATG" 
+#line  2492 "VBNET.ATG" 
 		letClause.EndLocation = t.EndLocation;
 		middleClauses.Add(letClause);
 		
 	}
 
 	void JoinQueryOperator(
-#line  2522 "VBNET.ATG" 
+#line  2529 "VBNET.ATG" 
 out QueryExpressionJoinVBClause joinClause) {
 
-#line  2524 "VBNET.ATG" 
+#line  2531 "VBNET.ATG" 
 		joinClause = new QueryExpressionJoinVBClause();
 		joinClause.StartLocation = la.Location;
 		CollectionRangeVariable joinVariable = null;
@@ -6586,203 +6596,203 @@ out QueryExpressionJoinVBClause joinClause) {
 		
 		Expect(146);
 		CollectionRangeVariableDeclaration(
-#line  2531 "VBNET.ATG" 
+#line  2538 "VBNET.ATG" 
 out joinVariable);
 
-#line  2532 "VBNET.ATG" 
+#line  2539 "VBNET.ATG" 
 		joinClause.JoinVariable = joinVariable; 
 		if (la.kind == 146) {
 			JoinQueryOperator(
-#line  2534 "VBNET.ATG" 
+#line  2541 "VBNET.ATG" 
 out subJoin);
 
-#line  2535 "VBNET.ATG" 
+#line  2542 "VBNET.ATG" 
 			joinClause.SubJoin = subJoin; 
 		}
 		Expect(171);
 		JoinCondition(
-#line  2538 "VBNET.ATG" 
+#line  2545 "VBNET.ATG" 
 out condition);
 
-#line  2539 "VBNET.ATG" 
+#line  2546 "VBNET.ATG" 
 		SafeAdd(joinClause, joinClause.Conditions, condition); 
 		while (la.kind == 60) {
 			lexer.NextToken();
 			JoinCondition(
-#line  2541 "VBNET.ATG" 
+#line  2548 "VBNET.ATG" 
 out condition);
 
-#line  2542 "VBNET.ATG" 
+#line  2549 "VBNET.ATG" 
 			SafeAdd(joinClause, joinClause.Conditions, condition); 
 		}
 
-#line  2545 "VBNET.ATG" 
+#line  2552 "VBNET.ATG" 
 		joinClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void GroupJoinQueryOperator(
-#line  2375 "VBNET.ATG" 
+#line  2382 "VBNET.ATG" 
 out QueryExpressionGroupJoinVBClause groupJoinClause) {
 
-#line  2377 "VBNET.ATG" 
+#line  2384 "VBNET.ATG" 
 		groupJoinClause = new QueryExpressionGroupJoinVBClause();
 		groupJoinClause.StartLocation = la.Location;
 		QueryExpressionJoinVBClause joinClause = null;
 		
 		Expect(133);
 		JoinQueryOperator(
-#line  2381 "VBNET.ATG" 
+#line  2388 "VBNET.ATG" 
 out joinClause);
 		Expect(143);
 		ExpressionRangeVariableDeclarationList(
-#line  2382 "VBNET.ATG" 
+#line  2389 "VBNET.ATG" 
 groupJoinClause.IntoVariables);
 
-#line  2384 "VBNET.ATG" 
+#line  2391 "VBNET.ATG" 
 		groupJoinClause.JoinClause = joinClause;
 		groupJoinClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void GroupByQueryOperator(
-#line  2362 "VBNET.ATG" 
+#line  2369 "VBNET.ATG" 
 out QueryExpressionGroupVBClause groupByClause) {
 
-#line  2364 "VBNET.ATG" 
+#line  2371 "VBNET.ATG" 
 		groupByClause = new QueryExpressionGroupVBClause();
 		groupByClause.StartLocation = la.Location;
 		
 		Expect(133);
 		ExpressionRangeVariableDeclarationList(
-#line  2367 "VBNET.ATG" 
+#line  2374 "VBNET.ATG" 
 groupByClause.GroupVariables);
 		Expect(70);
 		ExpressionRangeVariableDeclarationList(
-#line  2368 "VBNET.ATG" 
+#line  2375 "VBNET.ATG" 
 groupByClause.ByVariables);
 		Expect(143);
 		ExpressionRangeVariableDeclarationList(
-#line  2369 "VBNET.ATG" 
+#line  2376 "VBNET.ATG" 
 groupByClause.IntoVariables);
 
-#line  2371 "VBNET.ATG" 
+#line  2378 "VBNET.ATG" 
 		groupByClause.EndLocation = t.EndLocation;
 		
 	}
 
 	void OrderExpressionList(
-#line  2331 "VBNET.ATG" 
+#line  2338 "VBNET.ATG" 
 out List<QueryExpressionOrdering> orderings) {
 
-#line  2333 "VBNET.ATG" 
+#line  2340 "VBNET.ATG" 
 		orderings = new List<QueryExpressionOrdering>();
 		QueryExpressionOrdering ordering = null;
 		
 		OrderExpression(
-#line  2336 "VBNET.ATG" 
+#line  2343 "VBNET.ATG" 
 out ordering);
 
-#line  2337 "VBNET.ATG" 
+#line  2344 "VBNET.ATG" 
 		orderings.Add(ordering); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			OrderExpression(
-#line  2339 "VBNET.ATG" 
+#line  2346 "VBNET.ATG" 
 out ordering);
 
-#line  2340 "VBNET.ATG" 
+#line  2347 "VBNET.ATG" 
 			orderings.Add(ordering); 
 		}
 	}
 
 	void OrderExpression(
-#line  2344 "VBNET.ATG" 
+#line  2351 "VBNET.ATG" 
 out QueryExpressionOrdering ordering) {
 
-#line  2346 "VBNET.ATG" 
+#line  2353 "VBNET.ATG" 
 		ordering = new QueryExpressionOrdering();
 		ordering.StartLocation = la.Location;
 		ordering.Direction = QueryExpressionOrderingDirection.None;
 		Expression orderExpr = null;
 		
 		Expr(
-#line  2351 "VBNET.ATG" 
+#line  2358 "VBNET.ATG" 
 out orderExpr);
 
-#line  2353 "VBNET.ATG" 
+#line  2360 "VBNET.ATG" 
 		ordering.Criteria = orderExpr;
 		
 		if (la.kind == 64 || la.kind == 104) {
 			if (la.kind == 64) {
 				lexer.NextToken();
 
-#line  2356 "VBNET.ATG" 
+#line  2363 "VBNET.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Ascending; 
 			} else {
 				lexer.NextToken();
 
-#line  2357 "VBNET.ATG" 
+#line  2364 "VBNET.ATG" 
 				ordering.Direction = QueryExpressionOrderingDirection.Descending; 
 			}
 		}
 
-#line  2359 "VBNET.ATG" 
+#line  2366 "VBNET.ATG" 
 		ordering.EndLocation = t.EndLocation; 
 	}
 
 	void ExpressionRangeVariableDeclarationList(
-#line  2490 "VBNET.ATG" 
+#line  2497 "VBNET.ATG" 
 List<ExpressionRangeVariable> variables) {
 
-#line  2492 "VBNET.ATG" 
+#line  2499 "VBNET.ATG" 
 		ExpressionRangeVariable variable = null;
 		
 		ExpressionRangeVariableDeclaration(
-#line  2494 "VBNET.ATG" 
+#line  2501 "VBNET.ATG" 
 out variable);
 
-#line  2495 "VBNET.ATG" 
+#line  2502 "VBNET.ATG" 
 		variables.Add(variable); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			ExpressionRangeVariableDeclaration(
-#line  2496 "VBNET.ATG" 
+#line  2503 "VBNET.ATG" 
 out variable);
 
-#line  2496 "VBNET.ATG" 
+#line  2503 "VBNET.ATG" 
 			variables.Add(variable); 
 		}
 	}
 
 	void CollectionRangeVariableDeclarationList(
-#line  2549 "VBNET.ATG" 
+#line  2556 "VBNET.ATG" 
 List<CollectionRangeVariable> rangeVariables) {
 
-#line  2550 "VBNET.ATG" 
+#line  2557 "VBNET.ATG" 
 		CollectionRangeVariable variableDeclaration; 
 		CollectionRangeVariableDeclaration(
-#line  2552 "VBNET.ATG" 
+#line  2559 "VBNET.ATG" 
 out variableDeclaration);
 
-#line  2553 "VBNET.ATG" 
+#line  2560 "VBNET.ATG" 
 		rangeVariables.Add(variableDeclaration); 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			CollectionRangeVariableDeclaration(
-#line  2554 "VBNET.ATG" 
+#line  2561 "VBNET.ATG" 
 out variableDeclaration);
 
-#line  2554 "VBNET.ATG" 
+#line  2561 "VBNET.ATG" 
 			rangeVariables.Add(variableDeclaration); 
 		}
 	}
 
 	void CollectionRangeVariableDeclaration(
-#line  2557 "VBNET.ATG" 
+#line  2564 "VBNET.ATG" 
 out CollectionRangeVariable rangeVariable) {
 
-#line  2559 "VBNET.ATG" 
+#line  2566 "VBNET.ATG" 
 		rangeVariable = new CollectionRangeVariable();
 		rangeVariable.StartLocation = la.Location;
 		TypeReference typeName = null;
@@ -6790,71 +6800,71 @@ out CollectionRangeVariable rangeVariable) {
 		
 		Identifier();
 
-#line  2564 "VBNET.ATG" 
+#line  2571 "VBNET.ATG" 
 		rangeVariable.Identifier = t.val; 
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-#line  2565 "VBNET.ATG" 
+#line  2572 "VBNET.ATG" 
 out typeName);
 
-#line  2565 "VBNET.ATG" 
+#line  2572 "VBNET.ATG" 
 			rangeVariable.Type = typeName; 
 		}
 		Expect(138);
 		Expr(
-#line  2566 "VBNET.ATG" 
+#line  2573 "VBNET.ATG" 
 out inExpr);
 
-#line  2568 "VBNET.ATG" 
+#line  2575 "VBNET.ATG" 
 		rangeVariable.Expression = inExpr;
 		rangeVariable.EndLocation = t.EndLocation;
 		
 	}
 
 	void ExpressionRangeVariableDeclaration(
-#line  2499 "VBNET.ATG" 
+#line  2506 "VBNET.ATG" 
 out ExpressionRangeVariable variable) {
 
-#line  2501 "VBNET.ATG" 
+#line  2508 "VBNET.ATG" 
 		variable = new ExpressionRangeVariable();
 		variable.StartLocation = la.Location;
 		Expression rhs = null;
 		TypeReference typeName = null;
 		
 		if (
-#line  2507 "VBNET.ATG" 
+#line  2514 "VBNET.ATG" 
 IsIdentifiedExpressionRange()) {
 			Identifier();
 
-#line  2508 "VBNET.ATG" 
+#line  2515 "VBNET.ATG" 
 			variable.Identifier = t.val; 
 			if (la.kind == 63) {
 				lexer.NextToken();
 				TypeName(
-#line  2510 "VBNET.ATG" 
+#line  2517 "VBNET.ATG" 
 out typeName);
 
-#line  2511 "VBNET.ATG" 
+#line  2518 "VBNET.ATG" 
 				variable.Type = typeName; 
 			}
 			Expect(20);
 		}
 		Expr(
-#line  2515 "VBNET.ATG" 
+#line  2522 "VBNET.ATG" 
 out rhs);
 
-#line  2517 "VBNET.ATG" 
+#line  2524 "VBNET.ATG" 
 		variable.Expression = rhs;
 		variable.EndLocation = t.EndLocation;
 		
 	}
 
 	void JoinCondition(
-#line  2573 "VBNET.ATG" 
+#line  2580 "VBNET.ATG" 
 out QueryExpressionJoinConditionVB condition) {
 
-#line  2575 "VBNET.ATG" 
+#line  2582 "VBNET.ATG" 
 		condition = new QueryExpressionJoinConditionVB();
 		condition.StartLocation = la.Location;
 		
@@ -6862,14 +6872,14 @@ out QueryExpressionJoinConditionVB condition) {
 		Expression rhs = null;
 		
 		Expr(
-#line  2581 "VBNET.ATG" 
+#line  2588 "VBNET.ATG" 
 out lhs);
 		Expect(116);
 		Expr(
-#line  2581 "VBNET.ATG" 
+#line  2588 "VBNET.ATG" 
 out rhs);
 
-#line  2583 "VBNET.ATG" 
+#line  2590 "VBNET.ATG" 
 		condition.LeftSide = lhs;
 		condition.RightSide = rhs;
 		condition.EndLocation = t.EndLocation;
@@ -6877,69 +6887,69 @@ out rhs);
 	}
 
 	void Argument(
-#line  2647 "VBNET.ATG" 
+#line  2654 "VBNET.ATG" 
 out Expression argumentexpr) {
 
-#line  2649 "VBNET.ATG" 
+#line  2656 "VBNET.ATG" 
 		Expression expr;
 		argumentexpr = null;
 		string name;
 		Location startLocation = la.Location;
 		
 		if (
-#line  2654 "VBNET.ATG" 
+#line  2661 "VBNET.ATG" 
 IsNamedAssign()) {
 			Identifier();
 
-#line  2654 "VBNET.ATG" 
+#line  2661 "VBNET.ATG" 
 			name = t.val;  
 			Expect(55);
 			Expr(
-#line  2654 "VBNET.ATG" 
+#line  2661 "VBNET.ATG" 
 out expr);
 
-#line  2656 "VBNET.ATG" 
+#line  2663 "VBNET.ATG" 
 			argumentexpr = new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };
 			
 		} else if (StartOf(24)) {
 			Expr(
-#line  2659 "VBNET.ATG" 
+#line  2666 "VBNET.ATG" 
 out argumentexpr);
 		} else SynErr(308);
 	}
 
 	void QualIdentAndTypeArguments(
-#line  2725 "VBNET.ATG" 
+#line  2732 "VBNET.ATG" 
 out TypeReference typeref, bool canBeUnbound) {
 
-#line  2726 "VBNET.ATG" 
+#line  2733 "VBNET.ATG" 
 		string name; typeref = null; 
 		Qualident(
-#line  2728 "VBNET.ATG" 
+#line  2735 "VBNET.ATG" 
 out name);
 
-#line  2729 "VBNET.ATG" 
+#line  2736 "VBNET.ATG" 
 		typeref = new TypeReference(name); 
 		if (
-#line  2730 "VBNET.ATG" 
+#line  2737 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			lexer.NextToken();
 			Expect(169);
 			if (
-#line  2732 "VBNET.ATG" 
+#line  2739 "VBNET.ATG" 
 canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma)) {
 
-#line  2733 "VBNET.ATG" 
+#line  2740 "VBNET.ATG" 
 				typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				while (la.kind == 22) {
 					lexer.NextToken();
 
-#line  2734 "VBNET.ATG" 
+#line  2741 "VBNET.ATG" 
 					typeref.GenericTypes.Add(NullTypeReference.Instance); 
 				}
 			} else if (StartOf(8)) {
 				TypeArgumentList(
-#line  2735 "VBNET.ATG" 
+#line  2742 "VBNET.ATG" 
 typeref.GenericTypes);
 			} else SynErr(309);
 			Expect(38);
@@ -6947,24 +6957,24 @@ typeref.GenericTypes);
 	}
 
 	void RankList(
-#line  2772 "VBNET.ATG" 
+#line  2779 "VBNET.ATG" 
 out int i) {
 
-#line  2773 "VBNET.ATG" 
+#line  2780 "VBNET.ATG" 
 		i = 0; 
 		while (la.kind == 22) {
 			lexer.NextToken();
 
-#line  2774 "VBNET.ATG" 
+#line  2781 "VBNET.ATG" 
 			++i; 
 		}
 	}
 
 	void Attribute(
-#line  2813 "VBNET.ATG" 
+#line  2820 "VBNET.ATG" 
 out ASTAttribute attribute) {
 
-#line  2815 "VBNET.ATG" 
+#line  2822 "VBNET.ATG" 
 		string name;
 		List<Expression> positional = new List<Expression>();
 		List<NamedArgumentExpression> named = new List<NamedArgumentExpression>();
@@ -6975,43 +6985,43 @@ out ASTAttribute attribute) {
 			Expect(26);
 		}
 		Qualident(
-#line  2821 "VBNET.ATG" 
+#line  2828 "VBNET.ATG" 
 out name);
 		if (la.kind == 37) {
 			AttributeArguments(
-#line  2822 "VBNET.ATG" 
+#line  2829 "VBNET.ATG" 
 positional, named);
 		}
 
-#line  2824 "VBNET.ATG" 
+#line  2831 "VBNET.ATG" 
 		attribute  = new ASTAttribute(name, positional, named) { StartLocation = startLocation, EndLocation = t.EndLocation };
 		
 	}
 
 	void AttributeArguments(
-#line  2829 "VBNET.ATG" 
+#line  2836 "VBNET.ATG" 
 List<Expression> positional, List<NamedArgumentExpression> named) {
 
-#line  2831 "VBNET.ATG" 
+#line  2838 "VBNET.ATG" 
 		bool nameFound = false;
 		string name = "";
 		Expression expr;
 		
 		Expect(37);
 		if (
-#line  2837 "VBNET.ATG" 
+#line  2844 "VBNET.ATG" 
 IsNotClosingParenthesis()) {
 
-#line  2838 "VBNET.ATG" 
+#line  2845 "VBNET.ATG" 
 			Location startLocation = la.Location; 
 			if (
-#line  2840 "VBNET.ATG" 
+#line  2847 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2840 "VBNET.ATG" 
+#line  2847 "VBNET.ATG" 
 				nameFound = true; 
 				IdentifierOrKeyword(
-#line  2841 "VBNET.ATG" 
+#line  2848 "VBNET.ATG" 
 out name);
 				if (la.kind == 55) {
 					lexer.NextToken();
@@ -7020,10 +7030,10 @@ out name);
 				} else SynErr(310);
 			}
 			Expr(
-#line  2843 "VBNET.ATG" 
+#line  2850 "VBNET.ATG" 
 out expr);
 
-#line  2845 "VBNET.ATG" 
+#line  2852 "VBNET.ATG" 
 			if (expr != null) {
 			if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
 			else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
@@ -7032,13 +7042,13 @@ out expr);
 			while (la.kind == 22) {
 				lexer.NextToken();
 				if (
-#line  2853 "VBNET.ATG" 
+#line  2860 "VBNET.ATG" 
 IsNamedAssign()) {
 
-#line  2853 "VBNET.ATG" 
+#line  2860 "VBNET.ATG" 
 					nameFound = true; 
 					IdentifierOrKeyword(
-#line  2854 "VBNET.ATG" 
+#line  2861 "VBNET.ATG" 
 out name);
 					if (la.kind == 55) {
 						lexer.NextToken();
@@ -7047,14 +7057,14 @@ out name);
 					} else SynErr(311);
 				} else if (StartOf(24)) {
 
-#line  2856 "VBNET.ATG" 
+#line  2863 "VBNET.ATG" 
 					if (nameFound) Error("no positional argument after named argument"); 
 				} else SynErr(312);
 				Expr(
-#line  2857 "VBNET.ATG" 
+#line  2864 "VBNET.ATG" 
 out expr);
 
-#line  2857 "VBNET.ATG" 
+#line  2864 "VBNET.ATG" 
 				if (expr != null) { if(name == "") positional.Add(expr);
 				else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
 				}
@@ -7065,34 +7075,34 @@ out expr);
 	}
 
 	void ParameterModifier(
-#line  3645 "VBNET.ATG" 
+#line  3652 "VBNET.ATG" 
 ParamModifierList m) {
 		if (la.kind == 72) {
 			lexer.NextToken();
 
-#line  3646 "VBNET.ATG" 
+#line  3653 "VBNET.ATG" 
 			m.Add(ParameterModifiers.In); 
 		} else if (la.kind == 69) {
 			lexer.NextToken();
 
-#line  3647 "VBNET.ATG" 
+#line  3654 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Ref); 
 		} else if (la.kind == 174) {
 			lexer.NextToken();
 
-#line  3648 "VBNET.ATG" 
+#line  3655 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Optional); 
 		} else if (la.kind == 182) {
 			lexer.NextToken();
 
-#line  3649 "VBNET.ATG" 
+#line  3656 "VBNET.ATG" 
 			m.Add(ParameterModifiers.Params); 
 		} else SynErr(313);
 	}
 
 	void Statement() {
 
-#line  2976 "VBNET.ATG" 
+#line  2983 "VBNET.ATG" 
 		Statement stmt = null;
 		Location startPos = la.Location;
 		string label = String.Empty;
@@ -7100,27 +7110,27 @@ ParamModifierList m) {
 		
 		if (la.kind == 1 || la.kind == 21) {
 		} else if (
-#line  2982 "VBNET.ATG" 
+#line  2989 "VBNET.ATG" 
 IsLabel()) {
 			LabelName(
-#line  2982 "VBNET.ATG" 
+#line  2989 "VBNET.ATG" 
 out label);
 
-#line  2984 "VBNET.ATG" 
+#line  2991 "VBNET.ATG" 
 			AddChild(new LabelStatement(t.val));
 			
 			Expect(21);
 			Statement();
 		} else if (StartOf(49)) {
 			EmbeddedStatement(
-#line  2987 "VBNET.ATG" 
+#line  2994 "VBNET.ATG" 
 out stmt);
 
-#line  2987 "VBNET.ATG" 
+#line  2994 "VBNET.ATG" 
 			AddChild(stmt); 
 		} else SynErr(314);
 
-#line  2990 "VBNET.ATG" 
+#line  2997 "VBNET.ATG" 
 		if (stmt != null) {
 		stmt.StartLocation = startPos;
 		stmt.EndLocation = t.Location;
@@ -7129,30 +7139,30 @@ out stmt);
 	}
 
 	void LabelName(
-#line  3419 "VBNET.ATG" 
+#line  3426 "VBNET.ATG" 
 out string name) {
 
-#line  3421 "VBNET.ATG" 
+#line  3428 "VBNET.ATG" 
 		name = String.Empty;
 		
 		if (StartOf(4)) {
 			Identifier();
 
-#line  3423 "VBNET.ATG" 
+#line  3430 "VBNET.ATG" 
 			name = t.val; 
 		} else if (la.kind == 5) {
 			lexer.NextToken();
 
-#line  3424 "VBNET.ATG" 
+#line  3431 "VBNET.ATG" 
 			name = t.val; 
 		} else SynErr(315);
 	}
 
 	void LocalDeclarationStatement(
-#line  2998 "VBNET.ATG" 
+#line  3005 "VBNET.ATG" 
 out Statement statement) {
 
-#line  3000 "VBNET.ATG" 
+#line  3007 "VBNET.ATG" 
 		ModifierList m = new ModifierList();
 		LocalVariableDeclaration localVariableDeclaration;
 		bool dimfound = false;
@@ -7161,22 +7171,22 @@ out Statement statement) {
 			if (la.kind == 88) {
 				lexer.NextToken();
 
-#line  3006 "VBNET.ATG" 
+#line  3013 "VBNET.ATG" 
 				m.Add(Modifiers.Const, t.Location); 
 			} else if (la.kind == 204) {
 				lexer.NextToken();
 
-#line  3007 "VBNET.ATG" 
+#line  3014 "VBNET.ATG" 
 				m.Add(Modifiers.Static, t.Location); 
 			} else {
 				lexer.NextToken();
 
-#line  3008 "VBNET.ATG" 
+#line  3015 "VBNET.ATG" 
 				dimfound = true; 
 			}
 		}
 
-#line  3011 "VBNET.ATG" 
+#line  3018 "VBNET.ATG" 
 		if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
 		Error("Dim is not allowed on constants.");
 		}
@@ -7189,135 +7199,135 @@ out Statement statement) {
 		localVariableDeclaration.StartLocation = t.Location;
 		
 		VariableDeclarator(
-#line  3022 "VBNET.ATG" 
+#line  3029 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		while (la.kind == 22) {
 			lexer.NextToken();
 			VariableDeclarator(
-#line  3023 "VBNET.ATG" 
+#line  3030 "VBNET.ATG" 
 localVariableDeclaration.Variables);
 		}
 
-#line  3025 "VBNET.ATG" 
+#line  3032 "VBNET.ATG" 
 		statement = localVariableDeclaration;
 		
 	}
 
 	void TryStatement(
-#line  3533 "VBNET.ATG" 
+#line  3540 "VBNET.ATG" 
 out Statement tryStatement) {
 
-#line  3535 "VBNET.ATG" 
+#line  3542 "VBNET.ATG" 
 		Statement blockStmt = null, finallyStmt = null;List<CatchClause> catchClauses = null;
 		
 		Expect(218);
 		EndOfStmt();
 		Block(
-#line  3538 "VBNET.ATG" 
+#line  3545 "VBNET.ATG" 
 out blockStmt);
 		if (la.kind == 75 || la.kind == 113 || la.kind == 123) {
 			CatchClauses(
-#line  3539 "VBNET.ATG" 
+#line  3546 "VBNET.ATG" 
 out catchClauses);
 		}
 		if (la.kind == 123) {
 			lexer.NextToken();
 			EndOfStmt();
 			Block(
-#line  3540 "VBNET.ATG" 
+#line  3547 "VBNET.ATG" 
 out finallyStmt);
 		}
 		Expect(113);
 		Expect(218);
 
-#line  3543 "VBNET.ATG" 
+#line  3550 "VBNET.ATG" 
 		tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
 		
 	}
 
 	void WithStatement(
-#line  3513 "VBNET.ATG" 
+#line  3520 "VBNET.ATG" 
 out Statement withStatement) {
 
-#line  3515 "VBNET.ATG" 
+#line  3522 "VBNET.ATG" 
 		Statement blockStmt = null;
 		Expression expr = null;
 		
 		Expect(233);
 
-#line  3518 "VBNET.ATG" 
+#line  3525 "VBNET.ATG" 
 		Location start = t.Location; 
 		Expr(
-#line  3519 "VBNET.ATG" 
+#line  3526 "VBNET.ATG" 
 out expr);
 		EndOfStmt();
 
-#line  3521 "VBNET.ATG" 
+#line  3528 "VBNET.ATG" 
 		withStatement = new WithStatement(expr);
 		withStatement.StartLocation = start;
 		
 		Block(
-#line  3524 "VBNET.ATG" 
+#line  3531 "VBNET.ATG" 
 out blockStmt);
 
-#line  3526 "VBNET.ATG" 
+#line  3533 "VBNET.ATG" 
 		((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
 		
 		Expect(113);
 		Expect(233);
 
-#line  3529 "VBNET.ATG" 
+#line  3536 "VBNET.ATG" 
 		withStatement.EndLocation = t.Location; 
 	}
 
 	void WhileOrUntil(
-#line  3506 "VBNET.ATG" 
+#line  3513 "VBNET.ATG" 
 out ConditionType conditionType) {
 
-#line  3507 "VBNET.ATG" 
+#line  3514 "VBNET.ATG" 
 		conditionType = ConditionType.None; 
 		if (la.kind == 231) {
 			lexer.NextToken();
 
-#line  3508 "VBNET.ATG" 
+#line  3515 "VBNET.ATG" 
 			conditionType = ConditionType.While; 
 		} else if (la.kind == 224) {
 			lexer.NextToken();
 
-#line  3509 "VBNET.ATG" 
+#line  3516 "VBNET.ATG" 
 			conditionType = ConditionType.Until; 
 		} else SynErr(316);
 	}
 
 	void LoopControlVariable(
-#line  3349 "VBNET.ATG" 
+#line  3356 "VBNET.ATG" 
 out TypeReference type, out string name) {
 
-#line  3350 "VBNET.ATG" 
+#line  3357 "VBNET.ATG" 
 		ArrayList arrayModifiers = null;
 		type = null;
 		
 		Qualident(
-#line  3354 "VBNET.ATG" 
+#line  3361 "VBNET.ATG" 
 out name);
 		if (
-#line  3355 "VBNET.ATG" 
+#line  3362 "VBNET.ATG" 
 IsDims()) {
 			ArrayTypeModifiers(
-#line  3355 "VBNET.ATG" 
+#line  3362 "VBNET.ATG" 
 out arrayModifiers);
 		}
 		if (la.kind == 63) {
 			lexer.NextToken();
 			TypeName(
-#line  3356 "VBNET.ATG" 
+#line  3363 "VBNET.ATG" 
 out type);
 
-#line  3356 "VBNET.ATG" 
+#line  3363 "VBNET.ATG" 
 			if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } 
 		}
 
-#line  3358 "VBNET.ATG" 
+#line  3365 "VBNET.ATG" 
 		if (type != null) {
 		if(type.RankSpecifier != null && arrayModifiers != null) {
 			Error("array rank only allowed one time");
@@ -7329,34 +7339,34 @@ out type);
 	}
 
 	void ReDimClause(
-#line  3428 "VBNET.ATG" 
+#line  3435 "VBNET.ATG" 
 out Expression expr) {
 		SimpleNonInvocationExpression(
-#line  3430 "VBNET.ATG" 
+#line  3437 "VBNET.ATG" 
 out expr);
 		ReDimClauseInternal(
-#line  3431 "VBNET.ATG" 
+#line  3438 "VBNET.ATG" 
 ref expr);
 	}
 
 	void SingleLineStatementList(
-#line  3335 "VBNET.ATG" 
+#line  3342 "VBNET.ATG" 
 List<Statement> list) {
 
-#line  3336 "VBNET.ATG" 
+#line  3343 "VBNET.ATG" 
 		Statement embeddedStatement = null; 
 		if (la.kind == 113) {
 			lexer.NextToken();
 
-#line  3338 "VBNET.ATG" 
+#line  3345 "VBNET.ATG" 
 			embeddedStatement = new EndStatement(); 
 		} else if (StartOf(49)) {
 			EmbeddedStatement(
-#line  3339 "VBNET.ATG" 
+#line  3346 "VBNET.ATG" 
 out embeddedStatement);
 		} else SynErr(317);
 
-#line  3340 "VBNET.ATG" 
+#line  3347 "VBNET.ATG" 
 		if (embeddedStatement != null) list.Add(embeddedStatement); 
 		while (la.kind == 21) {
 			lexer.NextToken();
@@ -7366,62 +7376,62 @@ out embeddedStatement);
 			if (la.kind == 113) {
 				lexer.NextToken();
 
-#line  3342 "VBNET.ATG" 
+#line  3349 "VBNET.ATG" 
 				embeddedStatement = new EndStatement(); 
 			} else if (StartOf(49)) {
 				EmbeddedStatement(
-#line  3343 "VBNET.ATG" 
+#line  3350 "VBNET.ATG" 
 out embeddedStatement);
 			} else SynErr(318);
 
-#line  3344 "VBNET.ATG" 
+#line  3351 "VBNET.ATG" 
 			if (embeddedStatement != null) list.Add(embeddedStatement); 
 		}
 	}
 
 	void CaseClauses(
-#line  3466 "VBNET.ATG" 
+#line  3473 "VBNET.ATG" 
 out List<CaseLabel> caseClauses) {
 
-#line  3468 "VBNET.ATG" 
+#line  3475 "VBNET.ATG" 
 		caseClauses = new List<CaseLabel>();
 		CaseLabel caseClause = null;
 		
 		CaseClause(
-#line  3471 "VBNET.ATG" 
+#line  3478 "VBNET.ATG" 
 out caseClause);
 
-#line  3471 "VBNET.ATG" 
+#line  3478 "VBNET.ATG" 
 		if (caseClause != null) { caseClauses.Add(caseClause); } 
 		while (la.kind == 22) {
 			lexer.NextToken();
 			CaseClause(
-#line  3472 "VBNET.ATG" 
+#line  3479 "VBNET.ATG" 
 out caseClause);
 
-#line  3472 "VBNET.ATG" 
+#line  3479 "VBNET.ATG" 
 			if (caseClause != null) { caseClauses.Add(caseClause); } 
 		}
 	}
 
 	void OnErrorStatement(
-#line  3369 "VBNET.ATG" 
+#line  3376 "VBNET.ATG" 
 out OnErrorStatement stmt) {
 
-#line  3371 "VBNET.ATG" 
+#line  3378 "VBNET.ATG" 
 		stmt = null;
 		GotoStatement goToStatement = null;
 		
 		Expect(171);
 		Expect(118);
 		if (
-#line  3377 "VBNET.ATG" 
+#line  3384 "VBNET.ATG" 
 IsNegativeLabelName()) {
 			Expect(132);
 			Expect(30);
 			Expect(5);
 
-#line  3379 "VBNET.ATG" 
+#line  3386 "VBNET.ATG" 
 			long intLabel = Int64.Parse(t.val);
 			if(intLabel != 1) {
 				Error("invalid label in on error statement.");
@@ -7430,10 +7440,10 @@ IsNegativeLabelName()) {
 			
 		} else if (la.kind == 132) {
 			GotoStatement(
-#line  3385 "VBNET.ATG" 
+#line  3392 "VBNET.ATG" 
 out goToStatement);
 
-#line  3387 "VBNET.ATG" 
+#line  3394 "VBNET.ATG" 
 			string val = goToStatement.Label;
 			
 			// if value is numeric, make sure that is 0
@@ -7450,88 +7460,88 @@ out goToStatement);
 			lexer.NextToken();
 			Expect(163);
 
-#line  3401 "VBNET.ATG" 
+#line  3408 "VBNET.ATG" 
 			stmt = new OnErrorStatement(new ResumeStatement(true));
 			
 		} else SynErr(319);
 	}
 
 	void GotoStatement(
-#line  3407 "VBNET.ATG" 
+#line  3414 "VBNET.ATG" 
 out GotoStatement goToStatement) {
 
-#line  3409 "VBNET.ATG" 
+#line  3416 "VBNET.ATG" 
 		string label = String.Empty;
 		
 		Expect(132);
 		LabelName(
-#line  3412 "VBNET.ATG" 
+#line  3419 "VBNET.ATG" 
 out label);
 
-#line  3414 "VBNET.ATG" 
+#line  3421 "VBNET.ATG" 
 		goToStatement = new GotoStatement(label);
 		
 	}
 
 	void ResumeStatement(
-#line  3455 "VBNET.ATG" 
+#line  3462 "VBNET.ATG" 
 out ResumeStatement resumeStatement) {
 
-#line  3457 "VBNET.ATG" 
+#line  3464 "VBNET.ATG" 
 		resumeStatement = null;
 		string label = String.Empty;
 		
 		if (
-#line  3460 "VBNET.ATG" 
+#line  3467 "VBNET.ATG" 
 IsResumeNext()) {
 			Expect(194);
 			Expect(163);
 
-#line  3461 "VBNET.ATG" 
+#line  3468 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(true); 
 		} else if (la.kind == 194) {
 			lexer.NextToken();
 			if (StartOf(50)) {
 				LabelName(
-#line  3462 "VBNET.ATG" 
+#line  3469 "VBNET.ATG" 
 out label);
 			}
 
-#line  3462 "VBNET.ATG" 
+#line  3469 "VBNET.ATG" 
 			resumeStatement = new ResumeStatement(label); 
 		} else SynErr(320);
 	}
 
 	void ReDimClauseInternal(
-#line  3434 "VBNET.ATG" 
+#line  3441 "VBNET.ATG" 
 ref Expression expr) {
 
-#line  3435 "VBNET.ATG" 
+#line  3442 "VBNET.ATG" 
 		List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; 
 		while (la.kind == 26 || 
-#line  3438 "VBNET.ATG" 
+#line  3445 "VBNET.ATG" 
 la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
 			if (la.kind == 26) {
 				lexer.NextToken();
 				IdentifierOrKeyword(
-#line  3437 "VBNET.ATG" 
+#line  3444 "VBNET.ATG" 
 out name);
 
-#line  3437 "VBNET.ATG" 
+#line  3444 "VBNET.ATG" 
 				expr = new MemberReferenceExpression(expr, name); 
 			} else {
 				InvocationExpression(
-#line  3439 "VBNET.ATG" 
+#line  3446 "VBNET.ATG" 
 ref expr);
 			}
 		}
 		Expect(37);
 		NormalOrReDimArgumentList(
-#line  3442 "VBNET.ATG" 
+#line  3449 "VBNET.ATG" 
 out arguments, out canBeNormal, out canBeRedim);
 		Expect(38);
 
-#line  3444 "VBNET.ATG" 
+#line  3451 "VBNET.ATG" 
 		expr = new InvocationExpression(expr, arguments);
 		if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
 			if (this.Errors.Count == 0) {
@@ -7543,10 +7553,10 @@ out arguments, out canBeNormal, out canBeRedim);
 	}
 
 	void CaseClause(
-#line  3476 "VBNET.ATG" 
+#line  3483 "VBNET.ATG" 
 out CaseLabel caseClause) {
 
-#line  3478 "VBNET.ATG" 
+#line  3485 "VBNET.ATG" 
 		Expression expr = null;
 		Expression sexpr = null;
 		BinaryOperatorType op = BinaryOperatorType.None;
@@ -7555,7 +7565,7 @@ out CaseLabel caseClause) {
 		if (la.kind == 111) {
 			lexer.NextToken();
 
-#line  3484 "VBNET.ATG" 
+#line  3491 "VBNET.ATG" 
 			caseClause = new CaseLabel(); 
 		} else if (StartOf(51)) {
 			if (la.kind == 144) {
@@ -7565,76 +7575,76 @@ out CaseLabel caseClause) {
 			case 40: {
 				lexer.NextToken();
 
-#line  3488 "VBNET.ATG" 
+#line  3495 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThan; 
 				break;
 			}
 			case 39: {
 				lexer.NextToken();
 
-#line  3489 "VBNET.ATG" 
+#line  3496 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThan; 
 				break;
 			}
 			case 43: {
 				lexer.NextToken();
 
-#line  3490 "VBNET.ATG" 
+#line  3497 "VBNET.ATG" 
 				op = BinaryOperatorType.LessThanOrEqual; 
 				break;
 			}
 			case 42: {
 				lexer.NextToken();
 
-#line  3491 "VBNET.ATG" 
+#line  3498 "VBNET.ATG" 
 				op = BinaryOperatorType.GreaterThanOrEqual; 
 				break;
 			}
 			case 20: {
 				lexer.NextToken();
 
-#line  3492 "VBNET.ATG" 
+#line  3499 "VBNET.ATG" 
 				op = BinaryOperatorType.Equality; 
 				break;
 			}
 			case 41: {
 				lexer.NextToken();
 
-#line  3493 "VBNET.ATG" 
+#line  3500 "VBNET.ATG" 
 				op = BinaryOperatorType.InEquality; 
 				break;
 			}
 			default: SynErr(321); break;
 			}
 			Expr(
-#line  3495 "VBNET.ATG" 
+#line  3502 "VBNET.ATG" 
 out expr);
 
-#line  3497 "VBNET.ATG" 
+#line  3504 "VBNET.ATG" 
 			caseClause = new CaseLabel(op, expr);
 			
 		} else if (StartOf(24)) {
 			Expr(
-#line  3499 "VBNET.ATG" 
+#line  3506 "VBNET.ATG" 
 out expr);
 			if (la.kind == 216) {
 				lexer.NextToken();
 				Expr(
-#line  3499 "VBNET.ATG" 
+#line  3506 "VBNET.ATG" 
 out sexpr);
 			}
 
-#line  3501 "VBNET.ATG" 
+#line  3508 "VBNET.ATG" 
 			caseClause = new CaseLabel(expr, sexpr);
 			
 		} else SynErr(322);
 	}
 
 	void CatchClauses(
-#line  3548 "VBNET.ATG" 
+#line  3555 "VBNET.ATG" 
 out List<CatchClause> catchClauses) {
 
-#line  3550 "VBNET.ATG" 
+#line  3557 "VBNET.ATG" 
 		catchClauses = new List<CatchClause>();
 		TypeReference type = null;
 		Statement blockStmt = null;
@@ -7646,27 +7656,27 @@ out List<CatchClause> catchClauses) {
 			if (StartOf(4)) {
 				Identifier();
 
-#line  3558 "VBNET.ATG" 
+#line  3565 "VBNET.ATG" 
 				name = t.val; 
 				if (la.kind == 63) {
 					lexer.NextToken();
 					TypeName(
-#line  3558 "VBNET.ATG" 
+#line  3565 "VBNET.ATG" 
 out type);
 				}
 			}
 			if (la.kind == 229) {
 				lexer.NextToken();
 				Expr(
-#line  3559 "VBNET.ATG" 
+#line  3566 "VBNET.ATG" 
 out expr);
 			}
 			EndOfStmt();
 			Block(
-#line  3561 "VBNET.ATG" 
+#line  3568 "VBNET.ATG" 
 out blockStmt);
 
-#line  3562 "VBNET.ATG" 
+#line  3569 "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 d3e23c65aa..ef6aebd36d 100644
--- a/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
+++ b/src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
@@ -1694,7 +1694,7 @@ SimpleExpr<out Expression pexpr>
 			[ IF (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of)
 					"(" "Of" TypeArgumentList<((MemberReferenceExpression)pexpr).TypeArguments> ")"
 			]
-		|	"!" IdentifierOrKeyword<out name> (. pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name)); .)
+		|	"!" IdentifierOrKeyword<out name> (. pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); .)
 		|	(. XmlAxisType type = XmlAxisType.Attribute; bool isXmlName = false; .)
 			( ".@" | "..." (. type = XmlAxisType.Descendents; .) ) [ XmlOpenTag (. isXmlName = true; .) ] IdentifierOrKeyword<out name> [ XmlCloseTag ]
 			(. pexpr = new XmlMemberAccessExpression(pexpr, type, name, isXmlName); .)
@@ -1780,7 +1780,7 @@ SimpleNonInvocationExpression<out Expression pexpr>
 				| IdentifierOrKeyword<out name>
 				(. pexpr = new MemberReferenceExpression(null, name); .)
 			) |
-			"!" IdentifierOrKeyword<out name> (. pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name)); .)
+			"!" IdentifierOrKeyword<out name> (. pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); .)
 			| (. XmlAxisType axisType = XmlAxisType.Element; bool isXmlIdentifier = false; .)
 			( "..." (. axisType = XmlAxisType.Descendents; .) | ".@" (. axisType = XmlAxisType.Attribute; .) ) (
 				[ XmlOpenTag (. isXmlIdentifier = true; .) ] IdentifierOrKeyword<out name> [ XmlCloseTag ]
@@ -1950,6 +1950,7 @@ DisjunctionExpr<out Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .) =
 	ConjunctionExpr<out outExpr>
 	{
@@ -1958,7 +1959,7 @@ DisjunctionExpr<out Expression outExpr>
 			| "OrElse" (. op = BinaryOperatorType.LogicalOr; .)
 			| "Xor"    (. op = BinaryOperatorType.ExclusiveOr; .)
 		)
-		ConjunctionExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .)
+		ConjunctionExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
 	}
 .
 
@@ -1966,6 +1967,7 @@ ConjunctionExpr<out Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .) =
 	NotExpr<out outExpr>
 	{
@@ -1973,7 +1975,7 @@ ConjunctionExpr<out Expression outExpr>
 			  "And"     (. op = BinaryOperatorType.BitwiseAnd; .)
 			| "AndAlso" (. op = BinaryOperatorType.LogicalAnd; .)
 		)
-		NotExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .)
+		NotExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
 	}
 .
 
@@ -1990,6 +1992,7 @@ ComparisonExpr<out Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .) =
 	ShiftExpr<out outExpr>
 	{
@@ -2005,10 +2008,10 @@ ComparisonExpr<out Expression outExpr>
 			| "IsNot" (. op = BinaryOperatorType.ReferenceInequality; .)
 		)
 		(
-			ShiftExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .)
-		|
+			ShiftExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
+		| (. Location startLocation2 = la.Location; .)
 			"Not"
-			ShiftExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not));  .)
+			ShiftExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not) { StartLocation = startLocation2, EndLocation = t.EndLocation }) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
 		)
 	}
 .
@@ -2017,6 +2020,7 @@ ShiftExpr<out Expression outExpr>
 	(.
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
+		Location startLocation = la.Location;
 	.) =
 	ConcatenationExpr<out outExpr> 
 	{
@@ -2024,20 +2028,21 @@ ShiftExpr<out Expression outExpr>
 			"<<"   (. op = BinaryOperatorType.ShiftLeft; .)
 			| ">>" (. op = BinaryOperatorType.ShiftRight; .)
 		)
-		ConcatenationExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .) 
+		ConcatenationExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) 
 	}
 	.
 
 ConcatenationExpr<out Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	AdditiveExpr<out outExpr> { "&" AdditiveExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr);  .) }
+	AdditiveExpr<out outExpr> { "&" AdditiveExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 AdditiveExpr<out Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .) =
 	ModuloExpr<out outExpr>
 	{
@@ -2045,26 +2050,27 @@ AdditiveExpr<out Expression outExpr>
 			  "+"   (. op = BinaryOperatorType.Add; .)
 			| "-" (. op = BinaryOperatorType.Subtract; .)
 		)
-		ModuloExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr);  .)
+		ModuloExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
 	}
 .
 
 ModuloExpr<out Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 = 
-	IntegerDivisionExpr<out outExpr> { "Mod" IntegerDivisionExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr);  .) }
+	IntegerDivisionExpr<out outExpr> { "Mod" IntegerDivisionExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 IntegerDivisionExpr<out Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	MultiplicativeExpr<out outExpr> { "\\" MultiplicativeExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr);  .) }
+	MultiplicativeExpr<out outExpr> { "\\" MultiplicativeExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 
 MultiplicativeExpr<out Expression outExpr>
 (.
 	Expression expr;
 	BinaryOperatorType op = BinaryOperatorType.None;
+	Location startLocation = la.Location;
 .) =
 	UnaryExpr<out outExpr>
 	{
@@ -2072,7 +2078,7 @@ MultiplicativeExpr<out Expression outExpr>
 			"*"   (. op = BinaryOperatorType.Multiply; .)
 			| "/" (. op = BinaryOperatorType.Divide; .)
 		) 
-		UnaryExpr<out expr> (. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .) 
+		UnaryExpr<out expr> (. outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; .) 
 	}
 .
 
@@ -2080,6 +2086,7 @@ UnaryExpr<out Expression uExpr>
 (.
 	Expression expr;
 	UnaryOperatorType uop = UnaryOperatorType.None;
+	Location startLocation = la.Location;
 	bool isUOp = false;
 .) =
 	{ 	"+" 		(. uop = UnaryOperatorType.Plus; isUOp = true; .)
@@ -2089,7 +2096,7 @@ UnaryExpr<out Expression uExpr>
 	ExponentiationExpr<out expr>
 	(.
 		if (isUOp) {
-			uExpr = new UnaryOperatorExpression(expr, uop);
+			uExpr = new UnaryOperatorExpression(expr, uop) { StartLocation = startLocation, EndLocation = t.EndLocation };
 		} else {
 			uExpr = expr;
 		}
@@ -2097,9 +2104,9 @@ UnaryExpr<out Expression uExpr>
 .
 
 ExponentiationExpr<out Expression outExpr>
-(. Expression expr; .)
+(. Expression expr; Location startLocation = la.Location; .)
 =
-	SimpleExpr<out outExpr> { "^" SimpleExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr);  .) }
+	SimpleExpr<out outExpr> { "^" SimpleExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
 .
 	
 ObjectCreateExpression<out Expression oce>
diff --git a/src/Libraries/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs b/src/Libraries/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs
index 6800cee84f..20a89c6b76 100644
--- a/src/Libraries/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs
+++ b/src/Libraries/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs
@@ -279,12 +279,6 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "Xor", BinaryOperatorType.ExclusiveOr, true);
 		}
 		
-		[Test]
-		public void VBNetTest()
-		{
-			VBNetTestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.Power);
-		}
-		
 		[Test]
 		public void VBNetPowerTest()
 		{