[VB9]

- added QueryExpressionVB
- fixed grammar for Take and Skip clauses
- clauses where not added to QueryExpression
- fixed Idenitifier assignment in From clause
----
- fixed newlines in NRefactoryASTGenerator

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@5697 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitorLINQ.cs

@@ -22,6 +22,12 @@ namespace NRefactoryToBooConverter
 			return null;
 		}
 		
+		public object VisitQueryExpressionVB(QueryExpressionVB queryExpressionVB, object data)
+		{
+			AddError(queryExpressionVB, "QueryExpressionVB is not supported.");
+			return null;
+		}
+		
 		public object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data)
 		{
 			AddError(queryExpressionFromClause, "QueryExpressionFromClause is not supported.");

src/Libraries/NRefactory/NRefactoryASTGenerator/AST/Expressions.cs

@@ -268,6 +268,10 @@ namespace NRefactoryASTGenerator.Ast
 		QueryExpressionClause selectOrGroupClause;
 	}
 	
+	class QueryExpressionVB : Expression {
+		List<QueryExpressionClause> clauses;
+	}
+	
 	[ImplementNullable]
 	abstract class QueryExpressionClause : AbstractNode, INullable { }
 	

src/Libraries/NRefactory/NRefactoryASTGenerator/Main.cs

@@ -20,6 +20,8 @@ namespace NRefactoryASTGenerator
 	{
 		public const string VisitPrefix = "Visit";
 		
+		static readonly string[] lineEndings = { "\r\n", "\r", "\n" };
+		
 		public static void Main(string[] args)
 		{
 			string directory = "../../../Project/Src/Ast/";
@@ -92,7 +94,7 @@ namespace NRefactoryASTGenerator
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(directory + "Generated.cs", writer.ToString());
+				File.WriteAllText(directory + "Generated.cs", NormalizeNewLines(writer));
 			}
 			
 			ccu = new CodeCompileUnit();
@@ -103,7 +105,7 @@ namespace NRefactoryASTGenerator
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "../IAstVisitor.cs", writer.ToString());
+				File.WriteAllText(visitorsDir + "../IAstVisitor.cs", NormalizeNewLines(writer));
 			}
 			
 			ccu = new CodeCompileUnit();
@@ -116,7 +118,7 @@ namespace NRefactoryASTGenerator
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", writer.ToString());
+				File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", NormalizeNewLines(writer));
 			}
 			
 			ccu = new CodeCompileUnit();
@@ -129,7 +131,7 @@ namespace NRefactoryASTGenerator
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", writer.ToString());
+				File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", NormalizeNewLines(writer));
 			}
 			
 			ccu = new CodeCompileUnit();
@@ -142,7 +144,7 @@ namespace NRefactoryASTGenerator
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
 				// CodeDom cannot output "sealed", so we need to use this hack:
 				File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs",
-				                  writer.ToString().Replace("public override object", "public sealed override object"));
+				                  NormalizeNewLines(writer).Replace("public override object", "public sealed override object"));
 			}
 			
 			//NotImplementedAstVisitor
@@ -154,11 +156,16 @@ namespace NRefactoryASTGenerator
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", writer.ToString());
+				File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", NormalizeNewLines(writer));
 			}
 			Debug.WriteLine("AST Generator done!");
 		}
 		
+		static string NormalizeNewLines(StringWriter writer)
+		{
+			return string.Join(Environment.NewLine, writer.ToString().Split(lineEndings, StringSplitOptions.None));
+		}
+		
 		static CodeTypeDeclaration CreateAstVisitorInterface(List<Type> nodeTypes)
 		{
 			CodeTypeDeclaration td = new CodeTypeDeclaration("IAstVisitor");

src/Libraries/NRefactory/NRefactoryASTGenerator/NRefactoryASTGenerator.csproj

@@ -12,7 +12,7 @@
     <RegisterForComInterop>False</RegisterForComInterop>
     <GenerateSerializationAssemblies>Auto</GenerateSerializationAssemblies>
     <BaseAddress>4194304</BaseAddress>
-    <PlatformTarget>AnyCPU</PlatformTarget>
+    <PlatformTarget>x86</PlatformTarget>
     <FileAlignment>4096</FileAlignment>
     <WarningLevel>4</WarningLevel>
     <NoWarn>0169</NoWarn>

src/Libraries/NRefactory/Project/Src/Ast/Generated.cs

@@ -4374,6 +4374,32 @@ public Location ExtendedEndLocation { get; set; }
 		}
 	}
 	
+	public class QueryExpressionVB : Expression {
+		
+		List<QueryExpressionClause> clauses;
+		
+		public List<QueryExpressionClause> Clauses {
+			get {
+				return clauses;
+			}
+			set {
+				clauses = value ?? new List<QueryExpressionClause>();
+			}
+		}
+		
+		public QueryExpressionVB() {
+			clauses = new List<QueryExpressionClause>();
+		}
+		
+		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+			return visitor.VisitQueryExpressionVB(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[QueryExpressionVB Clauses={0}]", GetCollectionString(Clauses));
+		}
+	}
+	
 	public class QueryExpressionWhereClause : QueryExpressionClause {
 		
 		Expression condition;

src/Libraries/NRefactory/Project/Src/IAstVisitor.cs

@@ -199,6 +199,8 @@ namespace ICSharpCode.NRefactory {
 		
 		object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data);
 		
+		object VisitQueryExpressionVB(QueryExpressionVB queryExpressionVB, object data);
+		
 		object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data);
 		
 		object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data);

src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG

@@ -2013,13 +2013,12 @@ LambdaExpr<out Expression expr>
 
 QueryExpr<out Expression expr>
 	(.
-		QueryExpression qexpr = new QueryExpression();
+		QueryExpressionVB qexpr = new QueryExpressionVB();
 		qexpr.StartLocation = la.Location;
-		List<QueryExpressionClause> middleClauses = new List<QueryExpressionClause>();
 		expr = qexpr;
 	.) =
-	FromOrAggregateQueryOperator<middleClauses>
-	{ QueryOperator<middleClauses> }
+	FromOrAggregateQueryOperator<qexpr.Clauses>
+	{ QueryOperator<qexpr.Clauses> }
 	(.
 		qexpr.EndLocation = t.EndLocation;
 	.)
@@ -2045,6 +2044,7 @@ QueryOperator<List<QueryExpressionClause> middleClauses>
 	| WhereQueryOperator<middleClauses>
 	| OrderByQueryOperator<middleClauses>
 	| PartitionQueryOperator<out partitionClause>
+	  (. middleClauses.Add(partitionClause); .)
 	| LetQueryOperator<middleClauses>
 	| JoinQueryOperator<out joinClause>
 	  (. middleClauses.Add(joinClause); .)
@@ -2177,11 +2177,12 @@ PartitionQueryOperator<out QueryExpressionPartitionVBClause partitionClause>
 		partitionClause.StartLocation = la.Location;
 		Expression expr = null;
 	.) =
+	  (
 	   "Take" (. partitionClause.PartitionType = QueryExpressionPartitionType.Take; .)
 	  [ "While" (. partitionClause.PartitionType = QueryExpressionPartitionType.TakeWhile; .) ]
-	  Expr<out expr>
 	| "Skip" (. partitionClause.PartitionType = QueryExpressionPartitionType.Skip; .)
-      [ "While" ] (. partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile; .)
+      [ "While" (. partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile; .) ]
+      )
 	  Expr<out expr>
 	(.
 		partitionClause.Expression = expr;
@@ -2297,7 +2298,7 @@ CollectionRangeVariableDeclaration<out QueryExpressionFromClause fromClause>
 		TypeReference typeName = null;
 		Expression inExpr = null;
 	.) =
-	Identifier
+	Identifier (. fromClause.Identifier = t.val; .)
 	[ "As" TypeName<out typeName> (. fromClause.Type = typeName; .) ] 
 	"In" Expr<out inExpr>
 	(.

src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNetParser.cs

@@ -140,7 +140,11 @@ namespace ICSharpCode.NRefactory.Parser.VB
 		
 		bool IsIdentifiedExpressionRange()
 		{
-			return la.kind == Tokens.As || la.kind == Tokens.Assign;
+			// t = Select
+			// la = Identifier
+			// Peek(1) = As or Assign
+			Token token = Peek(1);
+			return IsIdentifierToken(la) && (token.kind == Tokens.As || token.kind == Tokens.Assign);
 		}
 		
 		bool IsQueryExpression()

src/Libraries/NRefactory/Project/Src/Visitors/AbstractASTVisitor.cs

@@ -1012,6 +1012,16 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitQueryExpressionVB(QueryExpressionVB queryExpressionVB, object data) {
+			Debug.Assert((queryExpressionVB != null));
+			Debug.Assert((queryExpressionVB.Clauses != null));
+			foreach (QueryExpressionClause o in queryExpressionVB.Clauses) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			return null;
+		}
+		
 		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
 			Debug.Assert((queryExpressionWhereClause != null));
 			Debug.Assert((queryExpressionWhereClause.Condition != null));

src/Libraries/NRefactory/Project/Src/Visitors/AbstractAstTransformer.cs

@@ -1843,6 +1843,23 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitQueryExpressionVB(QueryExpressionVB queryExpressionVB, object data) {
+			Debug.Assert((queryExpressionVB != null));
+			Debug.Assert((queryExpressionVB.Clauses != null));
+			for (int i = 0; i < queryExpressionVB.Clauses.Count; i++) {
+				QueryExpressionClause o = queryExpressionVB.Clauses[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (QueryExpressionClause)nodeStack.Pop();
+				if (o == null)
+					queryExpressionVB.Clauses.RemoveAt(i--);
+				else
+					queryExpressionVB.Clauses[i] = o;
+			}
+			return null;
+		}
+		
 		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
 			Debug.Assert((queryExpressionWhereClause != null));
 			Debug.Assert((queryExpressionWhereClause.Condition != null));

src/Libraries/NRefactory/Project/Src/Visitors/NodeTrackingAstVisitor.cs

@@ -675,6 +675,13 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return result;
 		}
 		
+		public sealed override object VisitQueryExpressionVB(QueryExpressionVB queryExpressionVB, object data) {
+			this.BeginVisit(queryExpressionVB);
+			object result = this.TrackedVisitQueryExpressionVB(queryExpressionVB, data);
+			this.EndVisit(queryExpressionVB);
+			return result;
+		}
+		
 		public sealed override object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
 			this.BeginVisit(queryExpressionWhereClause);
 			object result = this.TrackedVisitQueryExpressionWhereClause(queryExpressionWhereClause, data);
@@ -1253,6 +1260,10 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return base.VisitQueryExpressionSelectVBClause(queryExpressionSelectVBClause, data);
 		}
 		
+		public virtual object TrackedVisitQueryExpressionVB(QueryExpressionVB queryExpressionVB, object data) {
+			return base.VisitQueryExpressionVB(queryExpressionVB, data);
+		}
+		
 		public virtual object TrackedVisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
 			return base.VisitQueryExpressionWhereClause(queryExpressionWhereClause, data);
 		}

src/Libraries/NRefactory/Project/Src/Visitors/NotImplementedAstVisitor.cs

@@ -386,6 +386,10 @@ namespace ICSharpCode.NRefactory.Visitors {
 			throw new global::System.NotImplementedException("QueryExpressionSelectVBClause");
 		}
 		
+		public virtual object VisitQueryExpressionVB(QueryExpressionVB queryExpressionVB, object data) {
+			throw new global::System.NotImplementedException("QueryExpressionVB");
+		}
+		
 		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
 			throw new global::System.NotImplementedException("QueryExpressionWhereClause");
 		}

src/Libraries/NRefactory/Test/NRefactoryTests.csproj

@@ -65,6 +65,7 @@
     <Compile Include="Parser\Expressions\LambdaExpressionTests.cs" />
     <Compile Include="Parser\Expressions\QueryExpressionTests.cs" />
     <Compile Include="Output\SnippetConversion.cs" />
+    <Compile Include="Parser\Expressions\QueryExpressionVBTests.cs" />
     <Compile Include="Parser\GlobalScope\AttributeSectionTests.cs" />
     <Compile Include="Output\CSharp\CSharpOutputTest.cs" />
     <Compile Include="Parser\Expressions\PrimitiveExpressionTests.cs" />

src/Libraries/NRefactory/Test/Parser/Expressions/QueryExpressionVBTests.cs

@@ -0,0 +1,172 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="siegfriedpammer@gmail.com" />
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Linq;
+using ICSharpCode.NRefactory.Ast;
+using ICSharpCode.NRefactory.Tests.Ast;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.Tests.Ast
+{
+	[TestFixture]
+	public class QueryExpressionVBTests
+	{
+		void RunTest(string expression, int expectedCount, Action<QueryExpressionVB> constraint, params Type[] expectedTypes)
+		{
+			var expr = ParseUtilVBNet.ParseExpression<QueryExpressionVB>(expression);
+			
+			Assert.AreEqual(expectedCount, expr.Clauses.Count);
+			
+			for (int i = 0; i < expectedTypes.Length; i++) {
+				Assert.IsTrue(expectedTypes[i] == expr.Clauses[i].GetType());
+			}
+			
+			constraint(expr);
+		}
+		
+		[Test]
+		public void SimpleQueryTest()
+		{
+			RunTest("From o In db.Orders Select o.OrderID", 2,
+			        expr => {
+			        	var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
+			        	var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause;
+			        	
+			        	Assert.AreEqual("o", fromClause.Identifier);
+			        	Assert.IsTrue(fromClause.InExpression is MemberReferenceExpression);
+			        	var inExpr = fromClause.InExpression as MemberReferenceExpression;
+			        	Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db");
+			        	
+			        	Assert.AreEqual(1, selectClause.Variables.Count);
+			        	Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression);
+			        	var member = selectClause.Variables[0].Expression as MemberReferenceExpression;
+			        	
+			        	Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o");
+			        },
+			        typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause)
+			       );
+		}
+		
+		[Test]
+		public void SkipTakeQueryTest()
+		{
+			RunTest("From o In db.Orders Select o.OrderID Skip 10 Take 5", 4,
+			        expr => {
+			        	var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
+			        	var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause;
+			        	var skipClause = expr.Clauses[2] as QueryExpressionPartitionVBClause;
+			        	var takeClause = expr.Clauses[3] as QueryExpressionPartitionVBClause;
+			        	
+			        	Assert.AreEqual("o", fromClause.Identifier);
+			        	Assert.IsTrue(fromClause.InExpression is MemberReferenceExpression);
+			        	var inExpr = fromClause.InExpression as MemberReferenceExpression;
+			        	Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db");
+			        	
+			        	Assert.AreEqual(1, selectClause.Variables.Count);
+			        	Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression);
+			        	var member = selectClause.Variables[0].Expression as MemberReferenceExpression;
+			        	
+			        	Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o");
+			        	
+			        	Assert.AreEqual(QueryExpressionPartitionType.Skip, skipClause.PartitionType);
+			        	Assert.IsTrue(skipClause.Expression is PrimitiveExpression &&
+			        	              (skipClause.Expression as PrimitiveExpression).StringValue == "10");
+			        	
+			        	Assert.AreEqual(QueryExpressionPartitionType.Take, takeClause.PartitionType);
+			        	Assert.IsTrue(takeClause.Expression is PrimitiveExpression &&
+			        	              (takeClause.Expression as PrimitiveExpression).StringValue == "5");
+			        },
+			        typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause),
+			        typeof(QueryExpressionPartitionVBClause), typeof(QueryExpressionPartitionVBClause)
+			       );
+		}
+		
+		[Test]
+		public void MultipleValuesSelect()
+		{
+			RunTest(@"From i In list Select i, x2 = i^2",
+			        2, expr => {
+			        	var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
+			        	var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause;
+			        	
+			        	Assert.AreEqual("i", fromClause.Identifier);
+			        	Assert.IsTrue(fromClause.InExpression is IdentifierExpression);
+			        	Assert.IsTrue((fromClause.InExpression as IdentifierExpression).Identifier == "list");
+			        	
+			        	Assert.AreEqual(2, selectClause.Variables.Count);
+			        	
+			        	var selectExpr1 = selectClause.Variables[0];
+			        	var selectExpr2 = selectClause.Variables[1];
+			        	
+			        	Assert.IsEmpty(selectExpr1.Identifier);
+			        	Assert.IsTrue(selectExpr1.Expression is IdentifierExpression &&
+			        	              (selectExpr1.Expression as IdentifierExpression).Identifier == "i");
+			        	
+			        	Assert.AreEqual("x2", selectExpr2.Identifier);
+			        	Assert.IsTrue(selectExpr2.Type.IsNull);
+			        	Assert.IsTrue(selectExpr2.Expression is BinaryOperatorExpression);
+			        	
+			        	var binOp = selectExpr2.Expression as BinaryOperatorExpression;
+			        	
+			        	Assert.AreEqual(BinaryOperatorType.Power, binOp.Op);
+			        	Assert.IsTrue(binOp.Left is IdentifierExpression && (binOp.Left as IdentifierExpression).Identifier == "i");
+			        	Assert.IsTrue(binOp.Right is PrimitiveExpression && (binOp.Right as PrimitiveExpression).StringValue == "2");
+			        },
+			        typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause)
+			       );
+		}
+		
+		[Test]
+		public void GroupTest()
+		{
+			Action<QueryExpressionVB> constraint = expr => {
+				var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
+				var groupClause = expr.Clauses[1] as QueryExpressionGroupVBClause;
+				var selectClause = expr.Clauses[2] as QueryExpressionSelectVBClause;
+				
+				Assert.AreEqual("p", fromClause.Identifier);
+				Assert.IsTrue(fromClause.InExpression is IdentifierExpression);
+				Assert.IsTrue((fromClause.InExpression as IdentifierExpression).Identifier == "products");
+				
+				Assert.AreEqual(1, groupClause.GroupVariables.Count);
+				Assert.AreEqual(1, groupClause.ByVariables.Count);
+				Assert.AreEqual(1, groupClause.IntoVariables.Count);
+				
+				var gv = groupClause.GroupVariables.First();
+				var bv = groupClause.ByVariables.First();
+				var iv = groupClause.IntoVariables.First();
+				
+				Assert.IsTrue(gv.Expression is IdentifierExpression && (gv.Expression as IdentifierExpression).Identifier == "p");
+				Assert.IsTrue(bv.Expression is MemberReferenceExpression &&
+				              (bv.Expression as MemberReferenceExpression).MemberName == "Category");
+				Assert.IsTrue((bv.Expression as MemberReferenceExpression).TargetObject is IdentifierExpression &&
+				              ((bv.Expression as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "p");
+				Assert.IsTrue(iv.Expression is IdentifierExpression &&
+				              (iv.Expression as IdentifierExpression).Identifier == "Group");
+				
+				Assert.AreEqual(2, selectClause.Variables.Count);
+				
+				var var1 = selectClause.Variables.First();
+				var var2 = selectClause.Variables.Skip(1).First();
+				
+				Assert.IsTrue(var1.Expression is IdentifierExpression &&
+				              (var1.Expression as IdentifierExpression).Identifier == "Category");
+				Assert.IsTrue(var2.Expression is InvocationExpression &&
+				              (var2.Expression as InvocationExpression).TargetObject is MemberReferenceExpression &&
+				              ((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).MemberName == "Average" &&
+				              ((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject is IdentifierExpression &&
+				              (((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "Group");
+			};
+			
+			RunTest(@"From p In products _
+            Group p By p.Category Into Group _
+            Select Category, AveragePrice = Group.Average(Function(p) p.UnitPrice)", 3, constraint,
+			        typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupVBClause), typeof(QueryExpressionSelectVBClause));
+		}
+	}
+}